TSBugs Explorer: Exploring and Benchmarking TypeScript Bugs

arXiv:2611.14940v1 [cs.SE] 11 Nov 2026

TSBugs Explorer: Exploring and Benchmarking TypeScript Bugs TianYi Tang

Saba Alimadadi

School of Computing Science Simon Fraser University Burnaby, BC, Canada tta89@sfu.ca

School of Computing Science Simon Fraser University Burnaby, BC, Canada saba@sfu.ca

Abstract—Curated datasets of real-world software bugs support empirical research in software testing, debugging, and automated program repair. However, exploring heterogeneous bug collections, comparing fault characteristics across projects, and constructing research-specific subsets often require manual inspection and custom scripts. We present TSB UGS E XPLORER, an interactive visual analytics platform built upon our previouslypublished dataset of 633 bugs from 16 open-source TypeScript repositories, classified into 11 fault categories. The platform integrates bug records, repository characteristics, dependency information, and taxonomy guidance through coordinated visualizations, interactive filtering, and detailed bug inspection. It supports alternative aggregation and normalization of fault distributions, pairwise repository comparisons, and analysis of differences in observed fault profiles. An integrated benchmark builder allows researchers to select bug subsets using multiple criteria, inspect their composition, and export records in CSV or JSON format. We demonstrate the platform through three research workflows: fault characterization, cross-repository comparison, and task-specific benchmark construction. Functional validation by two authors confirmed selection correctness, visualization consistency, export integrity, and reproducibility across the tested workflows. By making the existing corpus easier to explore, compare, and reuse, TSB UGS E XPLORER facilitates systematic, research-specific selection and export of TypeScript bug records. Index Terms—TypeScript, software bugs, mining software repositories, bug benchmarks, interactive exploration, research tools

I. I NTRODUCTION Curated datasets of real-world software bugs support empirical research and the evaluation of testing, debugging, fault localization, and automated program repair techniques [1], [2]. However, different research questions often require different subsets of bugs, selected by fault category, application domain, or repository. Effective dataset reuse therefore requires understanding the corpus composition, identifying relevant instances, and assessing their suitability for a study. Such selection decisions can influence empirical findings [3], yet exploring heterogeneous bug collections and constructing research-specific subsets often involves manual inspection and custom data-processing scripts. In previous work [4], we introduced a curated dataset of 633 bugs from 16 open-source TypeScript repositories, classified into 11 fault categories. We characterized fault distributions

and examined their relationships with repository characteristics, application domains, and dependency structures. Although the dataset and analysis artifacts were publicly released, researchers lacked an integrated interface for inspecting individual bugs, comparing repositories, and selecting subsets for further study. We address this limitation with TSB UGS E XPLORER, a web-based visual analytics platform that brings together bug records, fault classifications, repository characteristics, dependency metadata, and taxonomy guidance. TSB UGS E XPLORER combines coordinated visualizations and interactive filtering with searchable bug inspection, normalized cross-repository comparisons, and taxonomy guidance. Its benchmark builder enables researchers to select bug records using repository, fault-category, application-domain, and changed-file criteria, inspect the resulting distributions, and export the selected metadata in CSV or JSON format. By connecting exploratory analysis with configurable subset construction, the platform facilitates the systematic selection and reuse of TypeScript bug records. This paper describes the platform, illustrates three research workflows, and reports its functional validation and limitations. II. TSB UGS E XPLORER : DATASET AND P LATFORM A. Dataset and Implementation TSB UGS E XPLORER builds on our previously-published TypeScript bug dataset [4], comprising 633 bug instances from 16 open-source repositories, classified into 11 fault categories. It integrates bug records, repository characteristics, application domains, dependency metadata, and taxonomy definitions. Bug records contain repository identifiers, fault categories, changed-file counts and paths, and links to fixing commits. Repository metadata includes code size, activity, popularity, and development technologies. TSB UGS E XPLORER is implemented as a client-side web application using JavaScript and D3.js1 for interactive visualizations. Data is stored in separate JSON files for bugs, repositories, domains, dependencies, and taxonomy definitions, separating dataset content from application logic. Filtering, aggregation, visualization, and export are performed in the browser, without a dedicated backend or database. 1 https://d3js.org/

The platform provides five views: Dashboard, Bug Explorer, Compare Projects, Benchmark Builder, and Taxonomy. (a)

B. Interactive Exploration and Inspection The Dashboard provides interactive visualizations of faultcategory distributions, repository coverage, application domains, and repository characteristics (Figure 1). Its filtering and search toolbar (Figure 1(a)) supports selection by repository, fault category, and application domain, as well as keyword search across bug records, repositories, and affected files. Filters are coordinated across Dashboard visualizations and the Bug Explorer, and can also be applied through direct interaction with chart elements. Active criteria appear as removable filter chips, allowing users to combine or reverse selections. The category distribution (Figure 1(b)) offers two aggregation modes: Sample Count, reporting the number of collected bugs per category, and Project-Weighted, averaging category proportions across repositories so that each contributes equally, regardless of its sampled bug count. These modes distinguish the composition of the collected sample from the average faultcategory profile across repositories. The Fault Landscape Heatmap (Figure 1(d)) displays faultcategory distributions across repositories, with rows and columns adapting to active filters. Its within-project percentage mode complements raw counts for comparing category composition across repositories. Other visualizations show repository coverage (Figure 1(c)), application-domain distributions (Figure 1(e)), and repository size and popularity, with markers indicating sampled bug counts (Figure 1(f)). The Bug Explorer supports keyword search, attributebased filtering, and inspection of individual bug records (Figure 2(a)). Each record provides its classification, affected file paths, fixing commit, repository characteristics, and related bugs. Shared filters connect aggregate patterns to individual bug instances. The Compare Projects view enables pairwise repository comparison through normalized fault-category distributions, repository metrics, and dependency/tooling profiles (Figure 2(b)). Its Category Difference visualization highlights percentage-point differences between repository fault profiles. The Taxonomy view provides category definitions, classification guidance, commonly confused categories, and representative examples. Together, these views support exploration at the dataset, repository, and individual-bug levels. C. Benchmark Construction and Export The Benchmark Builder enables researchers to construct research-specific bug subsets by combining repository, faultcategory, application-domain, and minimum changed-file criteria (Figure 2(c)). Searchable multi-selection controls and Select All and Clear actions support iterative refinement of selection criteria. The interface dynamically updates the matching bug count and displays category and repository distributions, allowing researchers to examine subset composition before export.

(b)

(c)

(d)

(e)

(f)

Fig. 1. Interactive visualizations in TSB UGS E XPLORER: (a) filtering and search toolbar for repository, fault-category, domain, and keyword queries; (b) fault-category distribution with sample-count and project-weighted modes; (c) repository coverage; (d) fault landscape heatmap showing category distributions across repositories; (e) application-domain distribution; and (f) repository characteristics.

Selected records can be exported in CSV or JSON format, preserving bug identifiers, classifications, repository information, changed-file metadata, and fixing-commit links. JSON export retains the corresponding bug objects, while a textual summary describes the selected subset. These facilities support the preparation of task-specific bug collections for subsequent empirical studies. The current implementation exports bug metadata rather than reconstructing executable buggy and fixed program versions. III. R ESEARCH W ORKFLOWS AND P RELIMINARY E VALUATION We illustrate three research workflows supported by TSB UGS E XPLORER: characterizing fault distributions, comparing repository fault profiles, and constructing task-specific bug subsets.

A. Research Workflows Scenario 1: Characterizing fault distributions. Consider a researcher investigating tooling and configuration faults in TypeScript projects. Our previous study identified 172 such instances (27.2% of 633 bugs) [4]. Using the Dashboard (Figure 1(b)), the researcher compares category counts with project-weighted proportions to distinguish the composition of the collected sample from the average repository-level profile. The researcher then examines the Fault Landscape Heatmap (Figure 1(d)), switching between counts and within-project percentages to compare category distributions across repositories. Coordinated filters allow refinement by category, repository, and domain, while the Bug Explorer (Figure 2(a)) provides access to matching records, affected files, and fixing commits. This workflow connects aggregate patterns with individual bug instances. Scenario 2: Comparing repository fault profiles. A researcher comparing two TypeScript repositories selects them in the Compare Projects view (Figure 2(b)). Normalized category distributions account for differences in sampled bug counts, while the Category Difference visualization highlights percentage-point contrasts. Repository characteristics and dependency/tooling profiles provide context for interpreting the observed differences. The researcher can investigate contrasting categories through the Taxonomy and Bug Explorer views, supporting hypothesis generation and targeted case selection. These comparisons describe the sampled bugs and do not establish causal relationships or ecosystem-wide prevalence. Scenario 3: Constructing a task-specific benchmark. Consider a researcher selecting candidate bugs for evaluating TypeScript testing or debugging techniques. Using the Benchmark Builder (Figure 2(c)), the researcher selects four fault categories (Asynchrony/Event Handling, API Misuse, Logic Error, and Type Error) and can further restrict the selection by repository, application domain, or minimum changed-file count. The interface previews matching bug counts and category and repository distributions, allowing the researcher to assess subset composition before exporting records in CSV or JSON format. The exports preserve bug identifiers, classifications, changed-file metadata, and fixing-commit links, supporting subsequent analysis and retrieval of source artifacts. The resulting subset contains bug metadata; reconstructing executable buggy versions, environments, and tests remains a separate task.

(a)

(b)

(c)

B. Preliminary Evaluation We conducted a structured functional validation of TSB UGS E XPLORER covering data integrity, selection correctness, visualization consistency, export integrity, and workflow reproducibility. Two authors performed predefined checks, independently cross-validating selected results and operations. Data integrity and selection correctness. We compared category distributions with the published dataset and sampled bug records from every repository and fault category against

Fig. 2. Selected interfaces supporting research workflows in TSB UGS E X PLORER (a) Bug Explorer for searching and inspecting individual bug records; (b) Compare Projects for examining normalized fault-category distributions and differences between repositories; and (c) Benchmark Builder for selecting customized bug subsets, previewing their composition, and exporting records in CSV or JSON format.

source JSON data. We tested repository, category, domain, and minimum changed-file filters individually and in combination, comparing selected identifiers and counts with independently derived reference sets. We also checked selection/reset behavior and bug details. Visualization consistency. We checked category counts, heatmap values, and repository/domain charts against source data, independently recalculating project-weighted proportions and signed cross-repository percentage-point differences. We also verified coordinated filtering, navigation, filter chips, and reset behaviour. Export integrity. We checked CSV and JSON exports against selected records, including identifiers, counts, classifications, changed-file metadata, and fixing-commit references. Repeated exports and zero-result selections were also tested. Workflow reproducibility and availability. We reproduced the three research scenarios in section III, including the benchmark subset in Figure 2(c). We verified all five views, hosted and local deployments, and documentation and artifact availability. All checks passed for the tested cases following correction of identified data inconsistencies. These results provide evidence of functional correctness and workflow reproducibility, rather than exhaustive verification. IV. R ELATED W ORK Bug Datasets and Benchmarks. Curated benchmarks such as Defects4J [1], BugsJS [2], and BugsInPy [5] provide realworld bugs for evaluating software testing, debugging, and repair techniques in Java, JavaScript, and Python, respectively. Studies of fault taxonomies [6] and dataset selection bias [3] further highlight the importance of understanding benchmark composition. Our previous work [4] introduced a curated TypeScript bug corpus and examined its fault categories in relation to repository characteristics, application domains, and dependencies. TSB UGS E XPLORER builds on this corpus to support interactive exploration and research-specific subset selection rather than introducing a new bug dataset. JavaScript and TypeScript Bug Research. Prior studies investigated client-side JavaScript faults [7], concurrency bugs in Node.js [8], and performance bugs [9]. Other work examined the relationship between TypeScript’s type system and software defects [10], [11]. These studies provide empirical evidence about particular fault mechanisms or language characteristics, whereas TSB UGS E XPLORER facilitates exploration of a previously classified TypeScript corpus across fault categories, repositories, and application domains. Bug Exploration and Repository Analytics. Beyond its benchmark and taxonomy, BugsJS provides a web-based interface for inspecting bug information and an API for accessing buggy and fixed versions and executing tests [2]. Generalpurpose repository analysis platforms, including Boa [12] and GrimoireLab [13], support mining and visualization of software development data. In contrast, TSB UGS E XPLORER focuses on interactive analysis of fault-category distributions within a curated TypeScript corpus, combining coordinated

filtering, normalized cross-repository comparisons, recordlevel inspection, and configurable metadata export. Unlike executable bug benchmarks, its subset builder exports selected bug records rather than reconstructed program environments. V. AVAILABILITY, L IMITATIONS , AND F UTURE W ORK Availability and Reuse. TSB UGS E XPLORER is publicly accessible through a hosted instance, 2 with its source code and application data available in a public GitHub repository. 3 A versioned release is permanently archived on Zenodo [14]. The underlying TypeScript bug dataset and original analysis artifacts are maintained in a separate repository associated with our previous study [4]. The application can be deployed locally using a static web server, without a dedicated backend or database. Its modular JSON files separate bug records, repository metadata, application domains, dependencies, and taxonomy information from the visualization logic. The repository provides documentation for local setup, data organization, and maintenance. Researchers can explore the corpus through the hosted or local interface and export selected bug records in CSV or JSON format. Limitations and Future Work. The platform inherits the sampling and classification limitations of its underlying dataset, which covers 16 selected TypeScript repositories. Its visualizations and comparisons characterize the collected bugs rather than establishing ecosystem-wide fault prevalence or causal relationships. The Benchmark Builder exports bug metadata but does not reconstruct executable buggy and fixed versions, dependencies, or test environments. Selection criteria are not currently exported as machine-readable specifications, so users must retain their criteria separately to reproduce a subset. Although the separation of data and visualization logic provides a basis for adapting the platform to other bug corpora, such adaptation has not been evaluated. Future work includes expanding the corpus, supporting reusable selection specifications and configurable data schemas and taxonomies, and integrating executable bug environments where feasible. VI. C ONCLUSION We presented TSB UGS E XPLORER, an interactive platform for exploring and reusing a curated TypeScript bug dataset. By integrating fault distributions, cross-repository comparisons, bug inspection, and configurable subset export, it extends the utility of the published corpus beyond static analyses and manual data processing. The platform supports researchspecific benchmark construction and provides a reusable resource for empirical studies of TypeScript reliability, testing, and debugging. ACKNOWLEDGMENT OpenAI’s ChatGPT was used to assist with manuscript drafting and editing and to generate portions of the initial software implementation. The authors reviewed, revised, and refined the AI-assisted outputs and remain responsible for the final manuscript, software, and reported results. 2 https://tsbugs-explorer.vercel.app/ 3 https://github.com/SEatSFU/TSBugsExplorer

R EFERENCES [1] R. Just, D. Jalali, and M. D. Ernst, “Defects4j: a database of existing faults to enable controlled testing studies for java programs,” in Proceedings of the 2014 International Symposium on Software Testing and Analysis, ser. ISSTA 2014. New York, NY, USA: Association for Computing Machinery, 2014, p. 437–440. [2] P. Gyimesi, B. Vancsics, A. Stocco, D. Mazinanian, A. Beszedes, R. Ferenć, and A. Mesbah, “Bugsjs: a benchmark and taxonomy of javascript bugs,” Software Testing, Verification & Reliability, 2020. [3] C. Bird, A. Bachmann, E. Aune, J. Duffy, A. Bernstein, V. Filkov, and P. Devanbu, “Fair and balanced? bias in bug-fix datasets,” in Proceedings of the 7th Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on The Foundations of Software Engineering, ser. ESEC/FSE ’09. New York, NY, USA: Association for Computing Machinery, 2009, p. 121–130. [4] T. Tang, S. Alimadadi, and N. Sumner, “From logic to toolchains: An empirical study of bugs in the typescript ecosystem,” in Proceedings of the 23rd International Conference on Mining Software Repositories, 2026, pp. 539–549. [5] R. Widyasari, S. Q. Sim, C. Lok, H. Qi, J. Phan, Q. Tay, C. Tan, F. Wee, J. E. Tan, Y. Yieh et al., “Bugsinpy: a database of existing bugs in python programs to enable controlled testing and debugging studies,” in Proceedings of the 28th ACM joint meeting on european software engineering conference and symposium on the foundations of software engineering, 2020, pp. 1556–1560. [6] G. Catolino, F. Palomba, A. Zaidman, and F. Ferrucci, “Not all bugs are the same: Understanding, characterizing, and classifying bug types,” Journal of Systems and Software, vol. 152, pp. 165–181, 2019.

[7] F. S. Ocariza, K. Bajaj, K. Pattabiraman, and A. Mesbah, “An empirical study of client-side javascript bugs,” 2013 ACM / IEEE International Symposium on Empirical Software Engineering and Measurement, 2013. [8] J. Wang, W. Dou, Y. Gao, C. Gao, F. Qin, K. Yin, and J. Wei, “A comprehensive study on real world concurrency bugs in node.js,” in 2017 32nd IEEE/ACM International Conference on Automated Software Engineering (ASE), 2017, pp. 520–531. [9] M. Selakovic and M. Pradel, “Performance issues and optimizations in javascript: an empirical study,” in Proceedings of the 38th International Conference on Software Engineering, 2016, pp. 61–72. [10] Z. Gao, C. Bird, and E. T. Barr, “To type or not to type: quantifying detectable bugs in javascript,” in 2017 IEEE/ACM 39th International Conference on Software Engineering (ICSE). IEEE, 2017, pp. 758– 769. [11] J. Bogner and M. Merkel, “To type or not to type? a systematic comparison of the software quality of javascript and typescript applications on github,” in Proceedings of the 19th international conference on mining software repositories, 2022, pp. 658–669. [12] R. Dyer, H. A. Nguyen, H. Rajan, and T. N. Nguyen, “Boa: Ultra-largescale software repository and source-code mining,” ACM Transactions on Software Engineering and Methodology (TOSEM), vol. 25, no. 1, pp. 1–34, 2015. [13] S. Dueñas, V. Cosentino, J. M. Gonzalez-Barahona, A. d. C. San Felix, D. Izquierdo-Cortazar, L. Cañas-Dı́az, and A. P. Garcı́a-Plaza, “Grimoirelab: A toolset for software development analytics,” PeerJ Computer Science, vol. 7, p. e601, 2021. [14] T. Tang and S. Alimadadi, “TSBugs Explorer: Exploring and Benchmarking TypeScript Bugs,” 2026. [Online]. Available: https: //doi.org/10.5281/zenodo.24122281

Related documents

• TSBugs Explorer: Exploring and Benchmarking TypeScript Bugs#1648970
• Fine-Tuning Large Language Models to Classify Pull Request-Issue Alignments: Going Beyond Prompting#821067
• CausalRepair: Bridging the Causality Gap in Large Language Model-Based Automated Program Repair via Dual-Slicing#444705
• A Feature-Driven Framework for Software Fault Prediction#200556
• Fine-Tuning Qwen3-27B for C-to-Rust Code Translation: A Three-Stage Curriculum of Pretraining, Debugging-Aware SFT, and Task-Specific SFT#458350