renkin 0.1.0 → 0.17.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 kent-tokyo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,302 +1,623 @@
-# RENKIN — Retrosynthesis Engine
+# RENKIN — Retrosynthesis Engine for Knowledge-Informed Navigation
 
 > **Computer-Aided Synthesis Planning (CASP) · Pure Rust · WebAssembly · Python**  
 > Named after 錬金 (れんきん, *renkin*) — Japanese for alchemy: just as alchemists transformed base metals into gold, RENKIN transforms target molecules back into cheap starting materials.
 
-[![Crates.io](https://img.shields.io/crates/v/renkin)](https://crates.io/crates/renkin)
-[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
-[![WASM](https://img.shields.io/badge/WASM-ready-brightgreen)](https://github.com/kent-tokyo/renkin/tree/master/demo)
-[![Pure Rust](https://img.shields.io/badge/Pure-Rust-orange?logo=rust)](https://www.rust-lang.org)
+<p>
+  <a href="https://github.com/kent-tokyo/renkin/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/kent-tokyo/renkin/actions/workflows/ci.yml/badge.svg?branch=master"></a>
+  <a href="https://github.com/kent-tokyo/renkin/actions/workflows/docs.yml"><img alt="Docs" src="https://github.com/kent-tokyo/renkin/actions/workflows/docs.yml/badge.svg?branch=master"></a>
+</p>
 
-[日本語版 README](./README_ja.md)
+<p>
+  <a href="https://crates.io/crates/renkin"><img alt="Crates.io" src="https://img.shields.io/crates/v/renkin.svg"></a>
+  <a href="https://docs.rs/renkin"><img alt="docs.rs" src="https://docs.rs/renkin/badge.svg"></a>
+  <a href="https://pypi.org/project/renkin/"><img alt="PyPI" src="https://img.shields.io/pypi/v/renkin.svg"></a>
+  <a href="https://pypi.org/project/renkin/"><img alt="Python" src="https://img.shields.io/pypi/pyversions/renkin.svg"></a>
+  <a href="https://www.npmjs.com/package/renkin"><img alt="npm" src="https://img.shields.io/npm/v/renkin.svg"></a>
+  <a href="LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-blue.svg"></a>
+</p>
+
+[日本語版 README](./README_ja.md) · [中文版 README](./README_zh.md) · [**Documentation**](https://kent-tokyo.github.io/renkin/) · [**Live Demo →**](https://kent-tokyo.github.io/renkin/playground/)
 
 ---
 
 ## What is RENKIN?
 
-RENKIN is an open-source **retrosynthesis engine** for **computer-aided synthesis planning (CASP)** that automatically discovers optimal chemical reaction routes from a target molecule back to cheap, commercially available starting materials — a core problem in **drug discovery** and **medicinal chemistry**.
+RENKIN is an open-source **retrosynthesis engine** for **computer-aided synthesis planning (CASP)** that automatically discovers optimal chemical reaction routes from a target molecule back to cheap, commercially available starting materials.
+
+Built entirely in Rust with the [`chematic`](https://docs.rs/chematic/) cheminformatics crate — zero C/C++ dependencies, `#![forbid(unsafe_code)]` throughout. One codebase compiles to a native CLI, a Rust library, Python wheels (PyO3), and a WebAssembly module that runs entirely client-side in the browser.
 
-Built entirely in Rust with the [`chematic`](https://docs.rs/chematic/) cheminformatics crate, RENKIN solves the fundamental speed and dependency problems of existing Python-based CASP tools (AiZynthFinder, ASKCOS, Retro\*, etc.). It ships as:
+---
 
-- **CLI** — single binary, `cargo build --release`
-- **Python package** — `import renkin` via PyO3 + maturin
-- **WASM module** — 493 KB bundle, runs in the browser with no server
+## Installation
 
-All from a single pure-Rust codebase with zero C/C++ dependencies.
+```bash
+pip install renkin          # Python
+cargo add renkin            # Rust
+npm install renkin          # JavaScript / Node.js
+```
 
 ---
 
-## Key Features
+## Live Playground
 
-| Feature | Detail |
-|---|---|
-| **Pure Rust** | Zero C/C++ dependencies. Cross-platform with `cargo build` alone |
-| **A\* / AND-OR Tree Search** | Retro\*-equivalent algorithm proven more efficient than MCTS for retrosynthesis |
-| **SA Score heuristic** | `chematic::chem::sa_score` guides search toward synthetically accessible precursors |
-| **Beam search** | `--beam-width N` limits heap size for memory-bounded exploration |
-| **Graph-based Ar–Ar cleavage** | Bridge-bond detection via DFS — correctly handles biaryl (Suzuki) disconnections |
-| **Parallel rule application** | `rayon` parallelises SMIRKS rule evaluation; sequential fallback on WASM |
-| **Python bindings** | `maturin` extension — `import renkin; renkin.find_routes(...)` |
-| **WASM-ready** | 493 KB bundle via `wasm-pack`; browser demo with 2D structure rendering |
-| **~400 building blocks** | Curated commercial starting materials covering esters, amines, halides, heterocycles, amino acids, sulfonyl chlorides, boronic acids and more |
-| **Benchmark CLI** | `renkin-bench --input targets.smi` produces a JSON success/timing report |
+**[→ Try it now](https://kent-tokyo.github.io/renkin/playground/)** — runs entirely in WebAssembly: no installation, no server, no network calls.
 
 ---
 
-## Architecture
+## Quick Start
 
+```python
+import json
+import renkin
+
+result = json.loads(
+    renkin.find_routes(
+        target="CC(=O)Oc1ccccc1C(=O)O",  # Aspirin
+        depth=5,
+        max_routes=3,
+    )
+)
+
+for route in result["routes"]:
+    for step in route["steps"]:
+        print(f"  {step['target']} → {' + '.join(step['precursors'])}  [{step['rule']}]")
 ```
-Target SMILES
-     │
-     ▼
-┌─────────────────────────┐
-│     chem_env.rs         │  ← chematic wrapper
-│  - SMILES parse         │     SMARTS VF2 building-block check
-│  - SMIRKS retro rules   │     fragment sanitization
-│  - Building block check │     HashMap O(1) pre-filter
-└────────────┬────────────┘
-             │  par_iter (rayon / sequential on WASM)
-             ▼
-┌─────────────────────────┐
-│      search.rs          │  ← A* / AND-OR Tree Search
-│  - Priority queue       │     SA Score heuristic
-│  - Closed list          │     beam search pruning
-│  - Degenerate filter    │
-└────────────┬────────────┘
-             │
-             ▼
-┌─────────────────────────┐
-│      score.rs           │  ← Heuristic / Cost Function
-│  - SA Score (chematic)  │     h = Σ(1 + 0.5·(sa−1)/9)
-│  - MW step cost         │     g = Σ(1 + total_mw/2000)
-└────────────┬────────────┘
-             │
-             ▼
-  JSON  ←  CLI / Python / WASM
+
+```javascript
+import init, { find_routes } from './pkg/renkin.js';
+await init();
+const result = JSON.parse(find_routes("CC(=O)Oc1ccccc1C(=O)O", 5, 3, 0));
+```
+
+```bash
+./target/release/renkin --target "CC(=O)Oc1ccccc1C(=O)O" --depth 5 \
+    --templates data/templates_extracted_5000.smi --format tree
 ```
 
+```text
+Target: CC(=O)Oc1ccccc1C(=O)O
+Routes found: 3
+
+Route 1  [score=1.02, depth=1]
+OC(=O)c1ccccc1OC(=O)C
+└── [extracted_169]
+    ├── OC(=O)C  ✓ BB
+    └── [OH]c1ccccc1C(=O)O  ✓ BB
+
+Route 2  [score=1.02, depth=1]
+OC(=O)c1ccccc1OC(=O)C
+└── [extracted_145]
+    ├── CC(=O)Cl  ✓ BB
+    └── [OH]c1ccccc1C(=O)O  ✓ BB
+
+Route 3  [score=1.03, depth=1]
+OC(=O)c1ccccc1OC(=O)C
+└── [extracted_238]
+    ├── c1cccc(c1O)C(O)=O  ✓ BB
+    └── C([OH])(=O)C  ✓ BB
+```
+
+Use `--format mermaid` for GitHub/Notion-compatible flowcharts.
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/kent-tokyo/renkin/blob/master/examples/renkin_quickstart.ipynb)
+
 ---
 
-## Technology Stack
+## Current Limitations
 
-- **Language**: Rust (Edition 2024)
-- **Cheminformatics**: [`chematic`](https://crates.io/crates/chematic) v0.4.9+
-  - `chematic-smiles` — SMILES parsing & canonical SMILES
-  - `chematic-smarts` — VF2 substructure matching (building block identity)
-  - `chematic-rxn` — SMIRKS reaction application (`run_reactants`)
-  - `chematic-chem` — SA Score, molecular weight, aromaticity descriptors
-- **Search**: A\* + AND/OR Tree (Retro\* equivalent)
-- **Parallelism**: [`rayon`](https://crates.io/crates/rayon) — parallel SMIRKS rule application
-- **Python**: [`PyO3`](https://pyo3.rs) + [`maturin`](https://www.maturin.rs)
-- **WASM**: [`wasm-bindgen`](https://rustwasm.github.io/wasm-bindgen/) + [`wasm-pack`](https://rustwasm.github.io/wasm-pack/)
+⚠️ Benchmark numbers are under active re-measurement after a validator-accuracy
+fix — historical 78.0%/95.9%/81.8%(ChEMBL) figures elsewhere in this repo predate
+that fix and are invalidated. RENKIN does not predict yields, calibrated
+experimental success probabilities, or side reactions, and does not search
+the literature automatically (`success_probability` is a template-frequency
+search-ranking score, not a calibrated prediction — see
+[Benchmark](https://kent-tokyo.github.io/renkin/benchmark/) for the current
+corrected numbers, full methodology, and known limitations).
 
 ---
 
-## Installation
+## Why RENKIN?
 
-### As a library
+RENKIN is designed as a Rust-native synthesis planning stack:
 
-```toml
-# Cargo.toml
-[dependencies]
-renkin = "0.1"
-```
+| | |
+|---|---|
+| **Fast** | A\* / AND-OR tree search with beam search and template frequency weighting |
+| **Portable** | Native CLI · Python wheels · npm/WASM · browser playground — one codebase |
+| **Explainable** | Per-step `confidence`, `atom_economy`, `route_cost`, and `procedure_hint` |
+| **Verifiable** | `renkin-forward` validates each retrosynthetic step by forward-applying templates |
+| **Benchmarkable** | USPTO-50k, PaRoutes-style evaluation, route diversity, and atom balance checks |
+| **Agent-ready** | MCP server exposes routes and validation to Claude Desktop and AI agents |
+
+---
+
+## Constraint-based Search
+
+Restrict routes by the element composition of their building blocks.
 
-### CLI (from source)
+**Default search** — all 5 routes for biphenyl:
 
 ```bash
-git clone https://github.com/kent-tokyo/renkin
-cd renkin
-cargo build --release
+renkin --target "c1ccc(-c2ccccc2)cc1" --templates data/templates_extracted_5000.smi --format tree
+```
+
+```text
+Routes found: 5
+Route 1  [score=1.00, depth=1]  c1ccccc1Br + c1c(B(O)O)cccc1
+Route 2  [score=1.03, depth=1]  c1ccccc1Br + c1c(B(O)O)cccc1
+Route 3  [score=1.06, depth=1]  c1cc(Cl)ccc1 + c1c(B(O)O)cccc1
+Route 4  [score=1.08, depth=1]  c1(I)ccccc1  + c1c(B(O)O)cccc1
+Route 5  [score=1.08, depth=1]  c1ccccc1Br  + c1(B2OC(C(C)(C)O2)(C)C)ccccc1
 ```
 
-### Python
+**Constrained search** — boronic-acid coupling, no Br or I starting materials:
 
 ```bash
-pip install maturin
-git clone https://github.com/kent-tokyo/renkin && cd renkin
-python -m venv .venv && source .venv/bin/activate
-maturin develop --features python
+renkin --target "c1ccc(-c2ccccc2)cc1" --templates data/templates_extracted_5000.smi \
+    --require-elements "B" --avoid-elements "Br,I" --format tree
+```
+
+```text
+Routes found: 1
+
+Route 1  [score=1.06, depth=1]
+c1ccccc1-c2ccccc2
+└── [extracted_398]
+    ├── c1cc(Cl)ccc1  ✓ BB
+    └── c1c(B(O)O)cccc1  ✓ BB
 ```
 
+Constraints compose freely and are enforced in two layers:
+- `--avoid-elements` **prunes expansions during search** when a BB precursor contains a forbidden element (no dead-end nodes added to the heap).
+- A final route-level post-filter is still applied for correctness.
+- `--require-elements` is a route-level post-filter only.
+
+Add `--verbose` to print search statistics (nodes expanded, elapsed time) to stderr. Performance counters are available in native builds only; disabled in WASM.
+
 ---
 
-## Getting Started
+## Template Evidence Metadata
 
-### CLI
+Extracted templates only have a positional display name (`extracted_{i}`) that
+changes whenever the source `.smi` file is reordered or re-extracted, so
+external knowledge (a DOI, a reported yield, a known side reaction) can't be
+durably attached to one. Every template — hand-crafted and extracted — now
+has a stable `template_id` instead:
 
-```bash
-# Retrosynthesis (Aspirin, depth 3)
-./target/release/renkin --target "CC(=O)Oc1ccccc1C(=O)O" --depth 3
+- Hand-crafted rules: `rule:<rule_name>` (e.g. `rule:suzuki_retro`).
+- Extracted templates: `smirks-sha256:<hex>` — the SHA-256 hex digest of the
+  *trimmed* SMIRKS string. Independent of file position, load order, and
+  count; purely syntactic (no SMIRKS canonicalization — a semantically
+  equivalent SMIRKS written differently gets a different ID).
 
-# With beam search (top-50 nodes)
-./target/release/renkin --target "CC(=O)Oc1ccccc1C(=O)O" --depth 5 --beam-width 50
-```
+Run `renkin template ids <file.smi>` to list every template's `template_id`,
+display name, SMIRKS, and weight (TSV by default, `--format json` for JSON) —
+use this to look up the IDs you need when authoring a sidecar file.
 
-```
---target / -t      Target molecule SMILES
---depth  / -d      Max retrosynthesis depth (default: 5)
---max-routes / -n  Max routes to return (default: 5)
---beam-width / -w  Beam search width, 0 = unlimited A* (default: 0)
---building-blocks  Path to .smi file of commercial starting materials
+Attach curated evidence with `--template-metadata sidecar.json` (also
+available in Python as `find_routes(..., template_metadata_path=...)`),
+keyed by `template_id`:
+
+```json
+{
+  "schema_version": 1,
+  "templates": {
+    "smirks-sha256:ef8778a2888469d619c52cce7e74f6848e101049050dd1b765b78f32e3c94498": {
+      "references": [
+        { "id": "ref-1", "kind": "doi", "identifier": "10.xxxx/example" }
+      ],
+      "condition_candidates": [
+        {
+          "catalysts": ["Pd(PPh3)4"],
+          "bases": ["K2CO3"],
+          "solvents": ["EtOH", "water"],
+          "temperature_c": { "min": 75.0, "max": 85.0 },
+          "source": "literature",
+          "scope": "template",
+          "reference_ids": ["ref-1"]
+        }
+      ],
+      "reported_yields": [
+        {
+          "percentage": { "min": 72.0, "max": 81.0 },
+          "basis": "isolated",
+          "source": "literature",
+          "scope": "template",
+          "reference_ids": ["ref-1"]
+        }
+      ],
+      "warnings": [
+        {
+          "code": "possible_protodeboronation",
+          "severity": "medium",
+          "message": "Protodeboronation has been reported under prolonged aqueous heating.",
+          "source": "literature",
+          "scope": "template",
+          "reference_ids": ["ref-1"]
+        }
+      ]
+    }
+  }
+}
 ```
 
-### Python
+A matching step gets an `evidence` field with `condition_candidates`,
+`reported_yields`, `references`, and `warnings`; steps whose template has no
+sidecar entry get no `evidence` key at all. The sidecar is loaded and
+validated (schema version, duplicate/dangling reference IDs, yield range,
+range `min <= max`, non-empty DOI/patent identifiers) **before search
+starts** — malformed metadata is a hard error, and a `template_id` in the
+sidecar that matches no loaded rule prints a warning rather than failing
+silently.
+
+**What this is not:**
+- `reported_yields` is a curated record of what was reported externally —
+  **not a RENKIN prediction**. `step_confidence`/`success_probability` are
+  unaffected and keep meaning template-frequency-derived search-ranking
+  scores, not experimental success rates.
+- `warnings` reflects only what's explicitly present in the sidecar you
+  supply — **not** automatic side-reaction detection.
+- Templates without a matching sidecar entry get no fabricated evidence.
+  Nothing is invented for missing data.
+
+Yield/success prediction and automatic literature search are explicitly out
+of scope for this phase — tracked as future work in
+[#41](https://github.com/kent-tokyo/renkin/issues/41).
 
-```python
-import renkin, json
-
-routes = json.loads(renkin.find_routes(
-    "CC(=O)Oc1ccccc1C(=O)O",   # Aspirin
-    depth=3,
-    max_routes=5,
-))
-print(routes["routes_found"])   # number of routes found
-for r in routes["routes"]:
-    print(r["depth"], [s["rule"] for s in r["steps"]])
-```
+---
+
+## Key Features
 
-### WASM
+| Feature | Detail |
+|---|---|
+| **Pure Safe Rust** | `#![forbid(unsafe_code)]` on all crates — compiler-enforced, zero C/C++ dependencies |
+| **A\* / AND-OR Tree Search** | Retro\*-equivalent algorithm with pluggable heuristics (`MoleculeValueEstimator`, `ReactionPrior`) |
+| **Up to 50k reaction templates** | Auto-extracted from USPTO-50k/MIT via rdchiral; frequency-weighted priority; `--templates` for custom sets |
+| **Route scoring** | `confidence`, `step_confidence`, `success_probability` (Retro-prob style), `convergency`, `atom_economy` per step — see caveat below the table |
+| **Step metadata provenance** | Each step reports `metadata_source`/`metadata_scope` (e.g. `handcrafted_default`/`reaction_family`) so it's machine-readable whether `conditions`/`reaction_family` came from a rule-author default vs. something more grounded; absent for extracted templates, since nothing is fabricated for them. |
+| **Stable template IDs + evidence sidecar** | Every template gets a stable `template_id` — `rule:<name>` for hand-crafted rules, `smirks-sha256:<hex>` for extracted templates (independent of file order/position/count). Attach curated DOIs/patents, reported conditions, reported yields, and known side-reaction warnings via a `--template-metadata sidecar.json` file keyed by `template_id`; matching steps get an `evidence` field, everything else stays untouched — see [Template evidence metadata](#template-evidence-metadata) below. Run `renkin template ids <file.smi>` to list stable IDs for authoring a sidecar. Automatic yield/success prediction and literature search remain out of scope ([#41](https://github.com/kent-tokyo/renkin/issues/41)). |
+| **Route cost scoring** | `route_cost = Σ(BB cost) + steps×0.5`; actual prices via `--bb-prices CSV` or `--stock stock.csv` |
+| **Pareto multi-objective search** | `--format pareto` returns a Pareto front across `route_cost`, `success_probability`, `steps`, etc.; objectives configurable via `--objectives cost:min,success_probability:max,steps:min` |
+| **Constraint DSL** | `--constraints constraints.json` — JSON-driven synthesis planning: element filters, step limits, confidence thresholds, preferred reaction families; enables LLM → RENKIN pipeline |
+| **Output formats** | `--format json` · `tree` · `mermaid` · `explain` (human-readable per-route analysis) · `compare` (side-by-side table) · `compare-json` · `pareto` |
+| **Failure diagnostics** | Zero-route JSON output includes `diagnostics` block with `likely_causes` and `suggestions` |
+| **Forward validation** | `renkin-forward validate` verifies each step by applying templates forward; accepts `--route-json` or stdin |
+| **Plausibility report** | `renkin-bench --plausibility` — forward-validates best routes and reports composite plausibility score |
+| **PaRoutes benchmark** | `renkin-bench --input-format paroutes` for multi-step ground-truth evaluation with `depth_delta` and `route_diversity` |
+| **Atom balance check** | `renkin-bench` flags steps where `target_MW > Σ precursor_MW` (CompleteRXN reference) |
+| **Stock CSV management** | `renkin stock stats\|validate\|coverage` — inspect and validate stock CSV files with SMILES, name, vendor, price, hazard fields |
+| **Template quality tools** | `renkin template stats\|validate\|dedup\|explain\|coverage\|ids` — inspect SMIRKS template sets: frequency distribution, validity, duplicates, per-template lookup, coverage rate, stable template IDs |
+| **MCP server** | `renkin-mcp` exposes 6 tools: `find_routes`, `validate_route`, `explain_route`, `find_pareto_routes`, `plan_with_constraints`, `estimate_diversity` |
+| **`renkin-doctor`** | Environment diagnostic binary — checks templates, building blocks, Python import, tool versions, and data integrity |
+| **`renkin-kg`** | Reaction knowledge graph builder — constructs bipartite mol↔reaction graphs from routes; exports to GraphML or Cypher |
+| **Beam search** | `--beam-width N` for memory-bounded exploration; `SmallVec<[FEntry; 6]>` stack-allocated frontier |
+| **Parallel rule application** | `rayon` on non-WASM; sequential fallback on wasm32 |
+| **tract-onnx NN scorer** | Pure Rust ONNX inference (no C++ dep) — optional `--scorer` flag for Phase B template relevance scoring |
+| **`building_blocks` in JSON** | Each route includes the leaf starting-material SMILES — no manual step parsing needed |
+| **Tetrahedral stereo @/@@** | Full stereochemistry support via chematic 0.4.16 |
+| **Python** | `pip install renkin` — pre-built wheels for Linux/macOS/Windows |
+| **WASM** | ~500 KB bundle — runs in the browser at near-native speed |
+| **402 building blocks** | Aryl halides, boronic acids, heterocycles, amines, acids, amino acids (`data/building_blocks.smi`, unique compounds actually loaded — see Benchmark section) |
+
+> **`step_confidence`/`success_probability` are not yields or measured success rates.**
+> They're template-frequency-derived search-ranking scores (`rule_weight / max_rule_weight`,
+> multiplied across a route's steps) used to order candidate disconnections during search —
+> not a calibrated probability of experimental success, and not an expected isolated yield.
+> Route-level experimental yield/success-rate reporting is not implemented.
+
+---
+
+## Pipeline Examples
 
 ```bash
-wasm-pack build --target web --no-default-features
-# Output: pkg/  (npm-ready package)
-# Browser demo: python3 -m http.server 8080 → http://localhost:8080/demo/
-```
+# Route cost scoring with commercial prices
+renkin -t "Cc1ccc(-c2ccccc2)cc1" --bb-prices data/prices.csv --format json
 
-```javascript
-import init, { find_routes } from './pkg/renkin.js';
-await init();
+# Forward validation — pipe find_routes output directly
+renkin -t "CC(=O)Oc1ccccc1C(=O)O" --format json | renkin-forward validate
 
-const result = JSON.parse(find_routes(
-  "CC(=O)Oc1ccccc1C(=O)O",  // target SMILES
-  3,   // depth
-  5,   // max_routes
-  0,   // beam_width (0 = unlimited A*)
-));
-console.log(result.routes_found);
+# Faster template retrieval with bond-center index (~24% speedup)
+renkin -t "c1ccc(NC(=O)c2ccccc2)cc1" --templates data/templates_extracted_5000.smi --bond-index
 ```
 
-### Benchmark
+---
+
+## Benchmark
+
+USPTO-50k test set (4,907 molecules, full evaluation):
+
+> **Evaluation definition**: A molecule is *solved* if `find_routes` returns at least one route whose leaf precursors are all in the building block set, within depth=5 and beam=100. Ground-truth reactants from USPTO-50k are **not** checked — any commercially accessible route counts.
+
+### Corrected baseline (commit `e20dc8c`, 2026-07-22)
+
+| Public label | Internal metric | Value |
+|---|---|---|
+| Search-to-stock rate | `raw_solved_rate` | **20.09%** (986/4,907) |
+| Atom-balance-filtered rate | `atom_balanced_solved_rate` | **15.41%** (756/4,907) — subset of search-to-stock |
+| Current-validator-confirmed rate | `provenance_validated_solved_rate` | **0.88%** (43/4,907) — subset of atom-balance-filtered |
+
+402 building blocks (unique compounds actually loaded from `data/building_blocks.smi` — see below), 5,000 extracted templates, 28 handcrafted rules, depth=5, beam=100. These three rates are a nested series over the same 4,907 targets, not independent numbers, and none is an experimentally-verified synthesis success rate or a human-chemist-reviewed route-accuracy figure. `provenance_validated_solved_rate` is not a measured chemical-accuracy rate and not a proven lower bound on correctness — it only counts routes the current validator can positively confirm, and an unknown fraction of "invalid" verdicts may be validator false negatives rather than real chemistry or route errors (the split is unmeasured). Full methodology, per-rule breakdown, and reproduction command: [`tasks/phase31_final_remeasurement_run.md`](https://github.com/kent-tokyo/renkin/blob/master/tasks/phase31_final_remeasurement_run.md) · [Full benchmark details →](https://kent-tokyo.github.io/renkin/benchmark/)
+
+### Historical progression (pre-fix, invalidated — see notice above)
+
+⚠️ The figures in this subsection (78.0% single-pass, 95.9% cascade, 81.8% ChEMBL OOD) predate the 31.11/31.12 fixes, are invalidated, and have not been re-measured. Kept for continuity only — do not cite as current performance.
+
+> **Evaluation note**: All numbers use the standard USPTO-50k train/test split (same corpus). Templates are extracted from the training set and evaluated on the test set. Numbers reflect performance within the USPTO-50k domain; out-of-distribution generalization was separately evaluated via ChEMBL approved drugs (**81.8%**, 409/500, also not re-measured).
+
+| Config | Solved | Rate | BBs | Templates | depth | beam | ms/mol |
+|---|---|---|---|---|---|---|---|
+| v0.1.0 initial | 366/4907 | 7.5% | 463 | 31 | 3 | 50 | — |
+| + auto templates (top-300) | 1363/4907 | 27.8% | 463 | 222 | 3 | 50 | — |
+| + depth=5, top-500 templates | 2315/4907 | 47.2% | 463 | 314 | 5 | 50 | — |
+| + beam=100 | 2688/4907 | 54.8%* | 463 | 314 | 5 | 100 | — |
+| + Phase A (template freq. weighting) | 3540/4907 | 72.1%† | 463 | 314 | 5 | 100 | — |
+| + 5,000 templates, 480 BBs | 3826/4907 | 78.0% | 480 | 5,000 | 5 | 100 | 2,775 |
+| Phase A unlimited (beam=0) | 3832/4907 | 78.1% | 480 | 5,000 | 5 | 0 | — |
+| Phase B (NN scorer, tract-onnx) | 3826/4907 | 78.0% | 480 | 5,000 | 5 | 100 | 3,394 |
+| **+ diaryl sulfone rule, 509 BBs** | **3826/4907** | **78.0%** | **509** | **5,000** | **5** | **100** | **≈2,800** |
+| Cascade (stage2: depth=7, beam=300 on unsolved) | 4705/4907 | **95.9%** | 509 | 5,000 | 7 | 300 | — |
+
+\* 29/50 chunks, previous binary  
+† 50/50 chunks — **72.1%** (3,540/4,907) confirmed  
+BB counts in this historical table (463/480/509) are as originally documented at each point in time — legacy documentation values, not re-verified against `ChemEnv::bb_count()`. The corrected-baseline section above uses the actually-loaded count (402) for the current `data/building_blocks.smi`.
+
+*Note: LocalRetro (53.4%) and GLG (58.0%) report single-step top-1 prediction accuracy — a different metric, not directly comparable.*
+
+> **Benchmark scope note**: USPTO-50k is used here as a *standardized sanity benchmark*, not as proof of broad real-world synthesis performance. The corpus covers a narrow slice of reaction space (primarily C–C and C–N bond formations common in pharmaceutical synthesis), and reaction types with sparse USPTO representation are systematically underserved. Out-of-distribution performance on ChEMBL approved drugs (**81.8%**, 409/500, pre-fix, not re-measured) suggested the rule set generalizes beyond the test corpus, but neither historical number should be interpreted as a guarantee of route quality on arbitrary targets.
+
+### PaRoutes compatibility
+
+RENKIN is compatible with the [PaRoutes](https://github.com/AstraZeneca/PaRoutes) multi-step benchmark. Download their stock compounds and target molecules, then pass them directly:
 
 ```bash
-# Input: one SMILES per line, optional name after whitespace
-./scripts/run_benchmark.sh --input data/benchmark_targets.smi --depth 5
+renkin-bench \
+  --input paroutes_n1_targets.smi \
+  --building-blocks paroutes_stock.smi \
+  --templates data/templates_extracted_5000.smi \
+  --depth 5 --beam-width 100
 ```
 
-```json
-{
-  "total": 42, "solved": 37, "success_rate": 0.88,
-  "avg_depth": 1.05, "avg_time_ms": 2.5,
-  "results": [...]
-}
-```
+The JSON output includes `avg_nodes_expanded`, `avg_confidence`, `avg_convergency`, and `avg_success_prob` (Retro-prob style) alongside the standard solved/success_rate metrics.
 
 ---
 
-## CLI Output Example
+## Competitive Landscape
+
+⚠️ RENKIN's row below uses the corrected `raw_solved_rate` (20.09%, see notice near the top of this README) — the 95.9% cascade figure some earlier versions of this table cited is invalidated and not re-measured; it is not included here.
+
+| Tool | Language | License | WASM | Zero-dep | Algorithm | Template source | Stock |
+|---|---|---|---|---|---|---|---|
+| **ASKCOS** | Python | CC BY-NC | No | No (Docker, 64 GB) | MCTS + A\* | USPTO (ML) | ZINC |
+| **AiZynthFinder** | Python | MIT | No | No (conda + model) | MCTS | USPTO (ML, ~50k) | eMolecules (~6M) |
+| **SYNTHIA** | Closed | Proprietary | No | No | SMARTS + AND/OR | Manual curated | Sigma-Aldrich |
+| **IBM RXN** | Closed | Cloud SaaS | No | No | Transformer | USPTO | — |
+| **Retro\*** | Python | MIT | No | No (unmaintained) | A\* + AND/OR | USPTO (ML) | eMolecules |
+| **★ RENKIN** | **Rust** | **MIT** | **Yes** | **Yes** | **A\* + AND/OR** | Hand-curated + rdchiral (5k default; 50k via `--templates`) | 402+ |
+
+`raw_solved_rate` is the closest available RENKIN metric to the published route-finding success rates of the other planners above, but the figures are not directly comparable — stock size, template library, target set, search budget, and route-quality checks all differ across systems, and this table does not establish RENKIN as better or worse than the alternatives.
+
+**RENKIN's goal**: match state-of-the-art accuracy using only curated rules and auto-extracted SMIRKS templates — no GPU, no training data, no black boxes. Under RENKIN's benchmark setting (corrected baseline, commit `e20dc8c`, 2026-07-22), it reaches **20.09%** `raw_solved_rate` (986/4,907) single-pass — see the Benchmark section above for the full nested-metric series and why the stricter `provenance_validated_solved_rate` (0.88%) is not RENKIN's measured or bounded correctness rate. RENKIN runs anywhere: browser, CLI, Python — single `cargo build`.
+
+> ⚠️ The table above lists tools under different evaluation conditions. No matched-condition experiment against other tools has been performed.
+
+---
+
+## MCP Server
+
+`renkin-mcp` exposes retrosynthesis as an MCP tool so AI agents (Claude, etc.) can call it directly.
+
+**Setup** — add to `claude_desktop_config.json`:
 
 ```json
 {
-  "target": "CC(=O)Oc1ccccc1C(=O)O",
-  "routes_found": 2,
-  "routes": [
-    {
-      "steps": [
-        {
-          "rule": "ester_cleavage",
-          "target": "CC(=O)Oc1ccccc1C(=O)O",
-          "precursors": ["CC(=O)O", "Oc1ccccc1C(=O)O"]
-        }
-      ],
-      "depth": 1
-    }
-  ]
+  "mcpServers": {
+    "renkin": { "command": "/path/to/renkin-mcp" }
+  }
 }
 ```
 
-**depth: 0** means the target itself is a commercially available starting material (buy directly).
+**Tools** (6):
+
+| Tool | Description |
+|---|---|
+| `find_routes` | Retrosynthesis: SMILES → routes with scoring |
+| `validate_route` | Forward-validate a retrosynthetic route |
+| `explain_route` | Human-readable strengths/weaknesses per route |
+| `find_pareto_routes` | Pareto-front multi-objective route search |
+| `plan_with_constraints` | Constraint-DSL planning (element filters, step limits, confidence thresholds) |
+| `estimate_diversity` | Route diversity and coverage metrics |
+
+The server auto-detects `data/building_blocks.smi` and `data/templates_extracted_5000.smi` in the working directory. Falls back to the embedded `DEFAULT_BUILDING_BLOCKS` / `default_rules()` defaults if not found (152 unique building blocks per `ChemEnv::bb_count()`, 28 handcrafted rules — verified 2026-07-22; a "509-BB / 20-rule" figure was previously documented here without verification).
+
+```bash
+cargo build --release
+# binary: target/release/renkin-mcp
+```
 
 ---
 
-## Retro-Rules (14 total)
+## Architecture
 
-| Rule | Reaction type | Strategy |
-|---|---|---|
-| `ester_cleavage` | Ester → acid + alcohol | SMIRKS |
-| `amide_cleavage` | Amide → acid + amine | SMIRKS |
-| `friedel_crafts_acylation_retro` | Ar-C(=O)R → Ar-H + acyl chloride | SMIRKS |
-| `aryl_carboxylation_retro` | Ar-COOH → Ar-H + CO₂ surrogate | SMIRKS |
-| `aryl_amine_retro` | Ar-N → Ar-H + amine | SMIRKS |
-| `buchwald_hartwig_retro` | Ar-N → Ar-Br + amine | SMIRKS |
-| `aryl_ether_retro` | Ar-O → Ar-OH + fragment | SMIRKS |
-| `suzuki_retro` | Ar-Ar → Ar-Br + Ar-H | Graph (bridge-bond DFS) |
-| `cc_single_cleavage` | C–C → two fragments | SMIRKS |
-| `wittig_retro` | C=C → C=O + C=O | SMIRKS |
-| `reductive_amination_retro` | C–N → C=O + amine | SMIRKS |
-| `cn_aliphatic_cleavage` | C–N → two fragments | SMIRKS |
-| `co_aliphatic_cleavage` | C–O → two fragments | SMIRKS |
-| `alcohol_oxidation_retro` | C–OH → C=O | SMIRKS |
-
-`suzuki_retro` uses a graph-based bridge-bond algorithm instead of SMIRKS to correctly handle symmetric biaryls (biphenyl, 4-fluorobiphenyl, etc.) without the BFS leakage artifacts that affect SMIRKS-based approaches.
+### Workspace scope
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│ renkin workspace (this repository)                               │
+│                                                                  │
+│  renkin  (retrosynthesis)         renkin-forward                  │
+│  ──────────────────────           ─────────────────────────────  │
+│  target → precursors              reactants → products           │
+│  A* / AND-OR search               template-based forward         │
+│  route scoring & constraints      (validates retro routes)       │
+│        │                                    │                    │
+│        └──────────────────┬─────────────────┘                    │
+│                           ▼                                      │
+│               chematic  (molecular representation,               │
+│               SMILES, substructure matching, reaction SMARTS)    │
+└──────────────────────────────────────────────────────────────────┘
+```
+
+### Internal data flow (renkin crate)
+
+```
+Target SMILES
+     │
+     ▼
+┌─────────────────────────┐
+│     chem_env.rs         │  ← chematic wrapper
+│  - SMILES parse         │     canonical-SMILES FxHashSet BB lookup (O(1))
+│  - 20 built-in + up to 50k via --templates  │     fragment sanitization + ring-leak filter
+│  - Building block check │     apply_retro memoization cache
+└────────────┬────────────┘
+             │  par_iter (rayon / sequential on WASM)
+             ▼
+┌─────────────────────────┐
+│      search.rs          │  ← A* / AND-OR Tree Search
+│  - Priority queue       │     SA Score heuristic + memoization
+│  - Closed list          │     beam search (SmallVec frontier)
+│  - Arc<PathNode> paths  │     O(1) path sharing per child
+└────────────┬────────────┘
+             │
+             ▼
+┌─────────────────────────┐
+│      score.rs           │  ← Heuristic / Cost Function
+│  - SA Score (chematic)  │     h = Σ(1 + 0.5·(sa−1)/9)
+│  - MW step cost         │     g = Σ(1 + total_mw/2000)
+└────────────┬────────────┘
+             │
+             ▼
+┌─────────────────────────┐   (optional)
+│      scorer.rs          │  ← Phase B: NN Template Scorer
+│  - tract-onnx           │     Pure Rust ONNX inference
+│  - --scorer flag        │     molecule-specific template ranking
+└────────────┬────────────┘
+             │
+             ▼
+  JSON  ←  CLI / Python / WASM
+```
 
 ---
 
 ## Project Structure
 
 ```
-renkin/
+renkin/                          ← Cargo workspace root
 ├── Cargo.toml
-├── src/
-│   ├── lib.rs           # public library (DEFAULT_BUILDING_BLOCKS, re-exports)
-│   ├── main.rs          # CLI binary
-│   ├── bin/
-│   │   └── benchmark.rs # renkin-bench binary
-│   ├── chem_env.rs      # chematic wrapper — parse, retro rules, BB check
-│   ├── score.rs         # SA Score heuristic + step cost
-│   ├── search.rs        # A* / AND-OR tree engine + beam pruning
-│   ├── python.rs        # PyO3 bindings (--features python)
-│   └── wasm.rs          # wasm-bindgen bindings (cfg = wasm32)
+├── src/                         ← renkin crate (retrosynthesis)
+│   ├── lib.rs                   # public library
+│   ├── main.rs                  # CLI binary (--templates, --template-metadata, --scorer, --constraints, --objectives flags)
+│   ├── bin/benchmark.rs         # renkin-bench binary (--plausibility flag)
+│   ├── bin/doctor.rs            # renkin-doctor diagnostic binary
+│   ├── bin/fp.rs                # renkin-fp ECFP4 fingerprint (nn-scoring feature)
+│   ├── bin/mcp.rs               # renkin-mcp MCP server (6 tools)
+│   ├── chem_env.rs              # retro rules + BB lookup + template loader
+│   ├── score.rs                 # SA Score heuristic + step cost
+│   ├── search.rs                # A* / AND-OR tree engine + beam pruning
+│   ├── scorer.rs                # Phase B: tract-onnx NN template scorer
+│   ├── python.rs                # PyO3 bindings (--features python)
+│   └── wasm.rs                  # wasm-bindgen bindings (cfg = wasm32)
+├── crates/                      ← sibling crates
+│   ├── renkin-forward/          # forward reaction prediction (reactants → products)
+│   └── renkin-kg/               # reaction knowledge graph builder (GraphML / Cypher export)
 ├── data/
-│   ├── building_blocks.smi      # Commercial starting materials (~400 entries)
-│   └── benchmark_targets.smi   # 42-molecule benchmark set
-├── demo/
-│   └── index.html       # Browser WASM demo with 2D structure rendering
-└── scripts/
-    └── run_benchmark.sh # Benchmark runner with human-readable summary
+│   ├── building_blocks.smi              # 402 curated commercial starting materials (loaded/deduplicated count)
+│   ├── templates_extracted_5000.smi     # 5,000 auto-extracted SMIRKS templates
+│   ├── benchmark_targets.smi            # internal benchmark set
+│   └── bench_chunks/                    # USPTO-50k per-chunk results
+├── scripts/
+│   ├── extract_templates.py         # rdchiral template extraction pipeline
+│   └── run_benchmark_chunks.sh      # resumable chunked benchmark runner
+├── docs/                # MkDocs source → kent-tokyo.github.io/renkin/
+└── mkdocs.yml
 ```
 
 ---
 
 ## Roadmap
 
-- [x] **Phase 1** — SMIRKS retro-reaction rules + fragment sanitization
-- [x] **Phase 2** — A\* / AND-OR tree search, closed list, degenerate-route filter
-- [x] **Phase 3** — SA Score heuristic + beam search (`--beam-width`)
-- [x] **Phase 4** — Parallel rule application (`rayon`; sequential fallback on WASM)
-- [x] **Phase 5** — Python bindings (PyO3 + maturin)
-- [x] **Phase 6** — WASM build (493 KB, `pkg/` npm-ready)
-- [x] **Phase 7** — Benchmark CLI (`renkin-bench`)
-- [x] **Phase 8** — 21 unit tests, SMIRKS rules 5→14, building blocks ~30→~400
-- [x] **Phase 9** — Browser WASM demo (SmilesDrawer 2D rendering), benchmark target set
-- [x] **Phase 10** — Graph-based biaryl cleavage (suzuki_retro), O(1) BB HashMap index
-- [ ] **Phase 11** — Formal benchmark vs. AiZynthFinder / Retro\* on USPTO-50k
-- [ ] **Phase 12** — PyPI / npm publish
+### Recently shipped
+
+- [x] Stable `template_id` (`rule:<name>` / `smirks-sha256:<hex>`) + `--template-metadata` evidence sidecar + `renkin template ids` ([#41](https://github.com/kent-tokyo/renkin/issues/41) phase 1)
+- [x] `renkin-bench cascade` — multi-stage search (fast defaults → hard cases re-run deeper); only unsolved targets propagate to later stages. **78.0% → 95.9%** on USPTO-50k
+- [x] `renkin-bench --failure-taxonomy` — classify unsolved targets by cause (beam limit / depth limit / template gap / stock near-miss)
+- [x] Graph-based ester cleavage — BFS-leakage-free `R-C(=O)-O-R' → RCOOH + R'OH`
+- [x] `--top-templates N` — frequency-rank filter: use the top-N most frequent templates for speed / less noise
+- [x] `raw / validated / practical` solved-rate metrics (`--plausibility --practical-max-steps N`)
+- [x] Retro cache hit-rate in `SearchStats` + `--verbose`
+
+### In progress
+
+- [ ] Template retrieval index (element bitmask + bond-center prefilter) for the 50k template set
+- [ ] Calibrated route confidence (map `success_probability` to empirical solve rate)
+
+### Next
+
+- [ ] Graph rule expansion — sulfonamide / carbamate / urea cleavage (one PR per family, each with benchmark delta)
+- [ ] Stock-aware planning (price / hazard / availability re-ranking)
+
+<details>
+<summary>Earlier milestones</summary>
+
+- [x] Route cost scoring — `route_cost` field + `--bb-prices path.csv` / `--stock stock.csv`
+- [x] Cargo workspace — `crates/renkin-forward/` + `crates/renkin-kg/`
+- [x] `renkin-forward predict` / `validate` — forward prediction + route validation (stdin-pipe friendly)
+- [x] `renkin-doctor` — environment diagnostic binary (templates, BBs, Python, binaries)
+- [x] Failure diagnostics — zero-route output includes `likely_causes` + `suggestions` JSON block
+- [x] `--format explain|compare|compare-json` — human-readable and tabular route output
+- [x] `renkin stock stats|validate|coverage` — stock CSV management subcommand
+- [x] Pareto multi-objective search — `--format pareto`, `--objectives`, `find_pareto_routes` MCP
+- [x] Constraint DSL — `--constraints JSON`, `plan_with_constraints` MCP tool
+- [x] `renkin template stats|validate|dedup|explain|coverage` — template quality tools
+- [x] `renkin-kg` — reaction knowledge graph (bipartite mol↔reaction, GraphML/Cypher export)
+- [x] MCP server expanded to 6 tools (`explain_route`, `find_pareto_routes`, `plan_with_constraints`)
+- [x] SMIRKS retro-reaction rules + fragment sanitization
+- [x] A\* / AND-OR tree search, closed list, degenerate-route filter
+- [x] SA Score heuristic + beam search
+- [x] Parallel rule application (rayon; sequential fallback on WASM)
+- [x] Python bindings (PyO3 + maturin) · `pip install renkin`
+- [x] WASM build · `npm install renkin`
+- [x] Benchmark CLI (`renkin-bench`) + USPTO-50k evaluation
+- [x] WASM browser playground + i18n (EN/JA/ZH)
+- [x] Graph-based biaryl cleavage · O(1) canonical-SMILES BB index
+- [x] Published to crates.io / PyPI / npm · GitHub Actions CI/CD
+- [x] MkDocs documentation site · GitHub Pages playground
+- [x] Auto template extraction (rdchiral): **27.8%** → **78.0%** USPTO-50k
+- [x] Tetrahedral stereo @/@@ + E/Z double-bond stereo
+- [x] Template frequency weighting (Phase A): **72.1%** USPTO-50k
+- [x] FxHashMap · SmallVec beam frontier · SA Score memoization · Arc<PathNode> path sharing
+- [x] 5,000 extracted templates + 509 BBs: **78.0%** USPTO-50k (3,826/4,907 ✅)
+- [x] NN template scorer via `--scorer` flag (tract-onnx, Pure Rust ONNX)
+- [x] `--format tree|mermaid` route visualization
+- [x] Constraint-based search: `--avoid-elements`, `--require-elements`
+- [x] `--verbose` search statistics to stderr
+- [x] MCP server (`renkin-mcp`) — AI agents call retrosynthesis directly
+- [x] `#![forbid(unsafe_code)]` — compiler-enforced Pure Safe Rust
+
+</details>
 
 ---
 
-## Competitive Landscape
+## Citation
+
+If you use RENKIN in academic work, please cite:
+
+```bibtex
+@software{renkin2026,
+  author    = {kent-tokyo},
+  title     = {{RENKIN}: Retrosynthesis Engine for Knowledge-Informed Navigation},
+  year      = {2026},
+  url       = {https://github.com/kent-tokyo/renkin/releases/tag/v0.17.0},
+  version   = {0.17.0},
+  license   = {MIT}
+}
+```
 
-| Tool | Language | Algorithm | WASM | Zero-dep build |
-|---|---|---|---|---|
-| **ASKCOS** | Python | MCTS / A\* | No | No (Docker, 64 GB RAM) |
-| **AiZynthFinder** | Python | MCTS primary | No | No (conda, model download) |
-| **IBM RXN** | Closed | Transformer | No | No (cloud only) |
-| **SYNTHIA** | Closed | SMARTS + AND/OR | No | No (proprietary) |
-| **Retro\*** | Python | A\* + AND/OR | No | No (unmaintained) |
-| **★ RENKIN** | **Rust** | **A\* + AND/OR** | **Yes** | **Yes (`cargo build`)** |
+---
+
+## Security
 
-All existing open CASP tools are Python-based. RENKIN fills the vacant niche: Rust-native, WASM-deployable, zero-dependency, A\* search.
+Report vulnerabilities via [GitHub Private vulnerability reporting](https://github.com/kent-tokyo/renkin/security/advisories/new). See [SECURITY.md](SECURITY.md).
 
 ---
 
@@ -307,3 +628,7 @@ MIT
 ---
 
 *GitHub Topics: `retrosynthesis` `cheminformatics` `wasm` `rust` `drug-discovery` `casp` `synthesis-planning` `computational-chemistry`*
+
+---
+
+If RENKIN saves you time, a GitHub star helps others discover it.

package/package.json

@@ -2,7 +2,7 @@
   "name": "renkin",
   "type": "module",
   "description": "Ultra-fast retrosynthesis engine for computer-aided synthesis planning (CASP) — pure Rust, WASM-ready, Python bindings via PyO3",
-  "version": "0.1.0",
+  "version": "0.17.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -19,18 +19,11 @@
   "sideEffects": [
     "./snippets/*"
   ],
-  "bugs": {
-    "url": "https://github.com/kent-tokyo/renkin/issues"
-  },
   "keywords": [
     "retrosynthesis",
     "cheminformatics",
     "chemistry",
     "wasm",
-    "webassembly",
-    "drug-discovery",
-    "casp",
-    "smiles",
-    "synthesis-planning"
+    "drug-discovery"
   ]
 }