Agent skill

Analyzing SQL Traces

by nwjs in nwjs/chromium.src

Extracts raw trace data from Perfetto traces, runs arbitrary SQL queries for custom follow-up analysis, and applies expert cognitive principles (Tiered Flow Analysis, Semantic Mismatch, Redundancy)…

BSD-3-ClauseAuto-check passedDatabases

Install Analyzing SQL Traces

skills CLI
$ npx skills add nwjs/chromium.src --skill analyzing-sql-traces -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install nwjs/chromium.src analyzing-sql-traces --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/nwjs/chromium.src.git skills-src && mkdir -p .claude/skills && cp -r skills-src/agents/skills/analyzing-sql-traces .claude/skills/analyzing-sql-traces && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
analyzing-sql-traces
GitHub stars
160
Token cost
~2.9k tokens
SKILL.md length
841 words
Files
7 (incl. scripts, references)
Skills in repo
64
Repo updated
First seen
Licence
BSD-3-Clause

At a glance

Extracts raw trace data from Perfetto traces, runs arbitrary SQL queries for custom follow-up analysis, and applies expert cognitive principles (Tiered Flow Analysis, Semantic Mismatch, Redundancy)…

  • Works in 3 steps: Prerequisites & Context → Core Workflow → Output Artifact Contracts
  • You need to analyze a trace under a specific focus/entrypoint slice
  • SKILL.md covers 1. Prerequisites & Context, 2. Core Workflow and 3. Output Artifact Contracts
  • Runs Python scripts from its folder

What it does

Analyzing SQL Traces is an agent skill from nwjs/chromium.src. Extracts raw trace data from Perfetto traces, runs arbitrary SQL queries for custom follow-up analysis, and applies expert cognitive principles (Tiered Flow Analysis, Semantic Mismatch, Redundancy) to identify performance bottlenecks, structural redundancies, and tracer gaps. Use when you need to analyze a trace under a specific focus/entrypoint slice, identify uninstrumented 'black boxes', or execute arbitrary SQL queries on trace databases directly using SQLite/Perfetto SQL syntax, and generate a precise…

Its SKILL.md is about 2.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 8 other files, including scripts and reference files (for example `references/cognitive_principles.md`, `scripts/query_trace.py` and `scripts/trace_analyzer.py`).

It sits in Databases, covering SQL. It works with SQL and SQLite. The repository describes itself as: Chromium codebase with NW.js modifications. Based on https://chromium.googlesource.com/chromium/src.git. The licence is BSD-3-Clause.

When your agent uses it

  • You need to analyze a trace under a specific focus/entrypoint slice
  • Identify uninstrumented black boxes
  • Execute arbitrary SQL queries on trace databases directly using SQLite/Perfetto SQL syntax
  • Generate a precise instrumentation breakdown plan

Example prompts

  • “black boxes”
  • “Use the analyzing-sql-traces skill to extract raw trace data from Perfetto traces, runs arbitrary SQL queries for custom follow-up analysis, and…”
  • “/analyzing-sql-traces”

Requirements

  • Python 3

Workflow steps

3 steps, taken from the step headings in SKILL.md.

  1. Prerequisites & Context
  2. Core Workflow
  3. Output Artifact Contracts

What it can do on your machine

Read from SKILL.md and the folder at commit a9e8946. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 5 files in scripts/ (Python), which the agent can run.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Analyzing SQL Traces loads about 2.9k tokens when it runs, and up to ~5.1k if it reads all its reference files. Until then it costs about 165 tokens; SKILL.md has 841 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~165
When it runs · the whole SKILL.md, loaded when a task matches
~2.9k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~5.1k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from nwjs/chromium.src at commit a9e8946, republished under its BSD-3-Clause licence (© nwjs). 841 words, ~2,949 tokens.

Download SKILL.mdSave it as .claude/skills/analyzing-sql-traces/SKILL.md (or your agent's skills folder). This skill also uses 6 other files; get the full folder from GitHub.
name
analyzing-sql-traces
description
Extracts raw trace data from Perfetto traces, runs arbitrary SQL queries for custom follow-up analysis, and applies expert cognitive principles (Tiered Flow Analysis, Semantic Mismatch, Redundancy) to identify performance bottlenecks, structural redundancies, and tracer gaps. Use when you need to analyze a trace under a specific focus/entrypoint slice, identify uninstrumented 'black boxes', or execute arbitrary SQL queries on trace databases directly using SQLite/Perfetto SQL syntax, and generate a precise instrumentation breakdown plan or refactoring instructions for the Codebase Agent. Don't use for capture or compilation tasks.

Analyzing SQL Traces

A specialized skill for analyzing Perfetto browser traces (individually or comparatively) to detect performance bottlenecks and generate codebase refactoring or instrumentation recommendations.

1. Prerequisites & Context

  • Treatment Traces (one or more .pb files).
  • Control Traces (optional, one or more .pb files for comparison).
  • Target Slice or Metric Window (e.g., Startup.FirstWebContents.FirstContentfulPaint, OmniboxEditModel::OpenMatch).
  • Analysis Mode Input: Select either descendants (to analyze child slices of a specific target) or window (to analyze all slices overlapping a metric window).
⚠️ Safety & Sandbox Compliance (Zero-Grant Rule)

To prevent triggering unnecessary user permission/access grant prompts:

  • ALWAYS write all intermediate and final outputs to the parent E2E session's unified analysis directory inside the workspace: out/e2e_nla_run_{parent_session_id}/analysis/ (where {parent_session_id} is passed by the Orchestrator).
    • Raw data / comparison reports: out/e2e_nla_run_{parent_session_id}/analysis/raw_trace_data.txt (Mode A, Text flamegraph) out/e2e_nla_run_{parent_session_id}/analysis/raw_trace_report.md (Mode A, Markdown report) out/e2e_nla_run_{parent_session_id}/analysis/comparison_report.md (Mode B, Markdown report) out/e2e_nla_run_{parent_session_id}/analysis/comparison_flamegraph.txt (Mode B, Text flamegraph)
    • Structured JSON: out/e2e_nla_run_{parent_session_id}/analysis/trace_analysis_results.json
    • Markdown Dispatch Report: out/e2e_nla_run_{parent_session_id}/analysis/trace_analysis_dispatch_report.md
  • NEVER execute shell utilities like mkdir, ls, touch, or rm to manage these files.
  • ALWAYS rely on the internal Python APIs inside trace_analyzer.py or trace_comparator.py to programmatically create directories and manage files silently.
  • ALWAYS run the scripts with vpython3 agents/skills/analyzing-sql-traces/scripts/trace_analyzer.py or vpython3 agents/skills/analyzing-sql-traces/scripts/trace_comparator.py to avoid extra permmision grant prompts.

2. Core Workflow

Step 1: Determine the Analysis Mode & Run Extraction
Mode A: Single-Group Analysis (Only Treatment Traces Provided)

First, run the trace analyzer to produce an aggregated text flamegraph:

bash
vpython3 agents/skills/analyzing-sql-traces/scripts/trace_analyzer.py \
  --traces {path/to/treatment_trace_*.pb} \
  --target "{focus_slice_or_metric}" \
  --mode {descendants|window} \
  --format text \
  --output out/e2e_nla_run_{parent_session_id}/analysis/raw_trace_data.txt

Second, run the trace analyzer to produce a markdown report with cumulative redundancy analysis:

bash
vpython3 agents/skills/analyzing-sql-traces/scripts/trace_analyzer.py \
  --traces {path/to/treatment_trace_*.pb} \
  --target "{focus_slice_or_metric}" \
  --mode {descendants|window} \
  --format markdown \
  --output out/e2e_nla_run_{parent_session_id}/analysis/raw_trace_report.md

Read the generated out/e2e_nla_run_{parent_session_id}/analysis/raw_trace_data.txt and out/e2e_nla_run_{parent_session_id}/analysis/raw_trace_report.md using view_file.

Mode B: Comparative Analysis (Both Control and Treatment Traces Provided)

First, run the trace comparator to generate the tabular comparative report:

bash
vpython3 agents/skills/analyzing-sql-traces/scripts/trace_comparator.py \
  --control {path/to/control_trace_*.pb} \
  --experiment {path/to/treatment_trace_*.pb} \
  --target "{focus_slice_or_metric}" \
  --mode {descendants|window} \
  --format markdown \
  --output out/e2e_nla_run_{parent_session_id}/analysis/comparison_report.md

Second, run the trace comparator to generate the high-level comparative text flamegraph (use --min-dur to filter out minor slices, e.g., $\ge 5.0\text{ ms}$):

bash
vpython3 agents/skills/analyzing-sql-traces/scripts/trace_comparator.py \
  --control {path/to/control_trace_*.pb} \
  --experiment {path/to/treatment_trace_*.pb} \
  --target "{focus_slice_or_metric}" \
  --mode {descendants|window} \
  --format text \
  --min-dur 5.0 \
  --output out/e2e_nla_run_{parent_session_id}/analysis/comparison_flamegraph.txt

Read the generated out/e2e_nla_run_{parent_session_id}/analysis/comparison_report.md and out/e2e_nla_run_{parent_session_id}/analysis/comparison_flamegraph.txt using view_file.

Advanced Filtering & Aggregation Options (Optional)

Both scripts (trace_analyzer.py and trace_comparator.py) support optional flags to refine slice selection when multiple events share the same name:

  • Aggregation Mode (--aggregate): If the target slice can be called multiple times, use this flag to aggregate all occurrences (cumulative durations and self-times) into a single merged call tree.
  • Slice Argument Filtering (--arg-key <key> and --arg-value <value>): To analyze only a specific call out of multiple occurrences, filter by its arguments (e.g. --arg-key "task.posted_from.file_name" --arg-value "content/browser/browser_main_loop.cc"). Note: The --arg-value parameter supports SQL LIKE operator syntax (e.g. %google.com/search% to perform prefix or wildcard substring matches).
  • Parent Bounding Target (--boundary-target <name>): Restricts the target slice search to only those occurrences that fall chronologically within the execution time windows of a specified parent/boundary event (descendants mode only). Use with --boundary-arg-key <key> and --boundary-arg-value <value> to target specific parent navigation/workflow windows.

Step 2: Apply Cognitive Principles

Open and read the mandatory reasoning guide to evaluate the results, focusing on browser logic and filtering out infrastructure noise: file:///.agents/skills/analyzing-sql-traces/references/cognitive_principles.md


Step 3: Run Arbitrary SQL Queries (Follow-up Analysis)

If you need custom details or want to perform follow-up analysis not covered by the default trace analyzer/comparator (e.g. searching for specific args, getting stats on specific threads, custom joins), ALWAYS run the arbitrary query script query_trace.py rather than creating a custom script yourself.

Show full SKILL.md (322 more words)Show less
Usage Guideline

Run the query_trace.py helper script using vpython3:

bash
vpython3 agents/skills/analyzing-sql-traces/scripts/query_trace.py \
  --trace {path/to/trace.pb} \
  --query "{sql_query}"

Example:

bash
vpython3 agents/skills/analyzing-sql-traces/scripts/query_trace.py \
  --trace out/Default/trace.pb \
  --query "SELECT name, sum(dur)/1e6 AS total_dur_ms FROM slice GROUP BY name ORDER BY total_dur_ms DESC LIMIT 10;"
Common Perfetto Tables & Schemas

Here are common SQLite tables available in Perfetto trace databases:

slice Table

Contains individual track event slices (slices represent synchronous work on a thread).

  • id (INT): Unique ID for the slice
  • name (STRING): Name of the slice / event
  • ts (INT): Start timestamp in nanoseconds
  • dur (INT): Duration in nanoseconds
  • track_id (INT): Track ID on which the slice executed
  • parent_id (INT): Parent slice ID (if nested)
  • arg_set_id (INT): ID referencing key-value arguments associated with this slice
process Table
  • upid (INT): Unique process ID
  • name (STRING): Name of the process (e.g. Browser, Renderer, GPU Process)
  • pid (INT): OS process ID
thread Table
  • utid (INT): Unique thread ID
  • name (STRING): Name of the thread (e.g. CrBrowserMain, Compositor)
  • upid (INT): Parent process ID
  • tid (INT): OS thread ID
thread_track Table
  • id (INT): Track ID
  • utid (INT): Thread ID associated with this track
args Table

Contains key-value arguments associated with slices.

  • arg_set_id (INT): Reference ID matching slice's arg_set_id
  • key (STRING): Hierarchical argument key (e.g. task.posted_from.file_name)
  • string_value / int_value / real_value (STRING / INT / REAL): Argument value
Reference Queries
Get Top 10 Longest Slices
sql
SELECT s.name, s.dur / 1e6 AS dur_ms, t.name AS thread_name, p.name AS process_name
FROM slice s
JOIN thread_track tt ON s.track_id = tt.id
JOIN thread t USING(utid)
JOIN process p USING(upid)
ORDER BY s.dur DESC
LIMIT 10;
List All Processes and Threads in a Trace
sql
SELECT p.name AS process_name, p.upid, t.name AS thread_name, t.utid
FROM process p
JOIN thread t USING(upid)
ORDER BY process_name, thread_name;
Find Slices by Name containing a substring
sql
SELECT name, dur/1e6 AS dur_ms, ts
FROM slice
WHERE name LIKE '%FirstContentfulPaint%'
ORDER BY ts ASC;

3. Output Artifact Contracts

You must generate two separate outputs to complete this task:

Output A: Structured Dispatch JSON

This payload is designed for direct parsing by the Orchestrator to feed to the Codebase & Instrumentation Agent. Save it to out/e2e_nla_run_{parent_session_id}/analysis/trace_analysis_results.json.

json
{
  "status": "SUCCESS",
  "analysis": {
    "target_slice": "FocusSliceName",
    "total_duration_ms": 260.6,
    "bottlenecks": [
      {
        "method_name": "CulpritMethodName",
        "severity_score": 8.5,
        "vectors": {
          "critical_path": true,
          "relative_overhead": 0.22,
          "semantic_simplicity": "HIGH" | "MEDIUM" | "LOW",
          "cumulative_redundancy": true
        },
        "breakdown_strategy": {
          "type": "GAP_INSTRUMENTATION" | "FULL_INSTRUMENTATION" | "FLOW_REFACTORING" | "REDUNDANCY_OPTIMIZATION",
          "target_method": "CulpritMethodName",
          "category": "omnibox" | "navigation" | "blink",
          "known_children": ["ChildA", "ChildB"],
          "gap_ms": 12.28,
          "instructions": "Detailed, step-by-step C++ refactoring or instrumentation instructions for the Codebase Agent."
        }
      }
    ]
  }
}
Output B: Markdown Dispatch Report (For Orchestrator Review)

Save a beautifully formatted report to out/e2e_nla_run_{parent_session_id}/analysis/trace_analysis_dispatch_report.md.

  • Format: Use GitHub-style alerts (> [!IMPORTANT]) for the Codebase Agent Dispatch Instructions to make them stand out.
  • Structure:
    1. Executive Summary: Overall metrics (total time, depth, count of bottlenecks).
    2. Flow-Aware Inefficiencies: Detailed analysis of slow flows (include simple Mermaid diagrams of the redundancy path if applicable).
    3. Prioritized Bottlenecks: Ranked list with direct codebase instructions.
    4. Redundancy Summary Table: Top 10 repeated operations.

© nwjs, BSD-3-Clause. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 6 other files (scripts, references) in agents/skills/analyzing-sql-traces of nwjs/chromium.src.

  • SKILL.md
  • references/cognitive_principles.md
  • scripts/query_trace.py
  • scripts/trace_analyzer.py
  • scripts/trace_analyzer_lib.py
  • scripts/trace_comparator.py
  • scripts/trace_processing_unittest.py

Open the folder on GitHubat commit a9e8946

Compare with similar skills

Analyzing SQL Traces next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Analyzing SQL Traces compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Analyzing SQL Traces this skillnwjs/chromium.src160—~2.9kAutomated safety check: PassBSD-3-Clause
SQL Database Support for pRESTprest/prest4.6k—~1.6kAutomated safety check: PassMIT
Cursor BYOK Database Schemaleookun/cursor-byok3.2k—~1.3kAutomated safety check: PassMIT
Squixeduardofuncao/squix273—~784Automated safety check: PassMIT
Golang Databaseunxed/f42412 repos~2.9kAutomated safety check: PassMIT
Import ExportAHS12/thoth-blueprint626—~499Automated safety check: PassGPL-3.0

Similar skills

  • Guides classifying, gap-analyzing and scaffolding support for a new SQL database in pREST, from Postgres-compatible variants to entirely new dialects.

    4.6k GitHub stars~1.6k tokensUpdated today
    DatabasesAuto-check passed
  • Cursor BYOK Database Schema

    leookun/cursor-byok

    Guides SQLite schema changes in the Cursor BYOK server, keeping SQLx migrations, the Rust store, API contracts and fixtures aligned.

    3.2k GitHub stars~1.3k tokensUpdated today
    DatabasesAuto-check passed
  • Squix

    eduardofuncao/squix

    Run SQL queries across databases (Postgres, MySQL, SQLite, etc.) via the squix CLI.

    273 GitHub stars~784 tokensUpdated 15 days ago
    DatabasesAuto-check passed
  • Comprehensive guide for Go database access — parameterized queries, struct scanning, NULLable columns, transactions, isolation levels, SELECT FOR UPDATE, connection pool, batch processing, context…

    241 GitHub starsUsed in 2 repos~2.9k tokens
    DatabasesAuto-check passed
  • Import Export

    AHS12/thoth-blueprint

    Change SQL, SQLite worker, DBML, JSON, Mermaid, SVG, or database export/import flows while preserving diagram semantics and round trips.

    626 GitHub stars~499 tokensUpdated 1 mo ago
    DatabasesAuto-check passed
  • SQL

    sendou-ink/sendou.ink

    Help write, debug, and explore SQLite database queries using Kysely.

    297 GitHub stars~423 tokensUpdated today
    DatabasesAuto-check passed

More from nwjs/chromium.src

All 64 skills in this repo
  • Autonomous multi-agent performance optimization loop for Chromium and V8.

    160 GitHub stars~4.2k tokensUpdated 4 days ago
    Auto-check passed
  • Automated Tracing

    nwjs/chromium.src

    Automated Tracing & Performance Telemetry in Chromium using Perfetto and Telemetry benchmarks.

    160 GitHub stars~1.5k tokensUpdated 4 days ago
    Auto-check passed
  • Chrome Releases

    nwjs/chromium.src

    Queries Chrome commit, version, release, and milestone metadata.

    160 GitHub stars~1.3k tokensUpdated 4 days ago
    Auto-check passed
  • Chromium Docs

    nwjs/chromium.src

    Search and reference Chromium documentation from the local docs index, including design docs, APIs, and development guides.

    160 GitHub stars~1.2k tokensUpdated 4 days ago
    Auto-check passed
  • Gn Deps Debugging

    nwjs/chromium.src

    Diagnose Chromium GN dependency and include-visibility failures, including BUILD.gn deps/publicdeps, DEPS include rules, private headers, and circular dependencies.

    160 GitHub stars~1.5k tokensUpdated 4 days ago
    Auto-check passed
  • Histogram Extension

    nwjs/chromium.src

    Extension pipeline to bump expiration dates of Chromium UMA histograms.

    160 GitHub stars~503 tokensUpdated 4 days ago
    Auto-check passed

Works with

Categories

Questions about Analyzing SQL Traces

What does Analyzing SQL Traces do?

Extracts raw trace data from Perfetto traces, runs arbitrary SQL queries for custom follow-up analysis, and applies expert cognitive principles (Tiered Flow Analysis, Semantic Mismatch, Redundancy)…. src. Extracts raw trace data from Perfetto traces, runs arbitrary SQL queries for custom follow-up analysis, and applies expert cognitive principles (Tiered Flow Analysis, Semantic Mismatch, Redundancy) to identify performance bottlenecks, structural redundancies, and tracer gaps.

When should I use Analyzing SQL Traces?

Analyzing SQL Traces fits situations like: you need to analyze a trace under a specific focus/entrypoint slice; identify uninstrumented black boxes; execute arbitrary SQL queries on trace databases directly using SQLite/Perfetto SQL syntax; generate a precise instrumentation breakdown plan.

How do I install Analyzing SQL Traces in Claude Code?

Run `npx skills add nwjs/chromium.src --skill analyzing-sql-traces -a claude-code`. Or copy the skill folder (agents/skills/analyzing-sql-traces in nwjs/chromium.src) into .claude/skills/analyzing-sql-traces in your project. Claude Code loads it when a task matches its description.

How do I install Analyzing SQL Traces in Codex?

Run `npx skills add nwjs/chromium.src --skill analyzing-sql-traces -a codex`. Or copy the skill folder (agents/skills/analyzing-sql-traces in nwjs/chromium.src) into .agents/skills/analyzing-sql-traces in your project. Codex loads it when a task matches its description.

Can I use Analyzing SQL Traces in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add nwjs/chromium.src --skill analyzing-sql-traces -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/analyzing-sql-traces, .gemini/skills/analyzing-sql-traces, .github/skills/analyzing-sql-traces and .opencode/skills/analyzing-sql-traces in your project.

What does Analyzing SQL Traces need to run?

Going by SKILL.md and its folder, Analyzing SQL Traces needs Python for the scripts in its folder. Our summary lists: Python 3.

Does Analyzing SQL Traces access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Analyzing SQL Traces safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Analyzing SQL Traces use?

Analyzing SQL Traces is published under the BSD-3-Clause licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Analyzing SQL Traces use?

About 2.9k tokens (SKILL.md is roughly 12k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 2.2k tokens, read only when the agent opens those files.

What are the alternatives to Analyzing SQL Traces?

Skills that share tags, products or a category with Analyzing SQL Traces: SQL Database Support for pREST (prest/prest, 4.6k stars), Cursor BYOK Database Schema (leookun/cursor-byok, 3.2k stars), Squix (eduardofuncao/squix, 273 stars) and Golang Database (unxed/f4, 241 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Analyzing SQL Traces?

nwjs (a GitHub organization) maintains it in nwjs/chromium.src, which has 160 GitHub stars. The repository holds 64 skills in this directory. The repository was last updated on October 3, 2026.

Source: nwjs/chromium.src on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.