diff-grok 1.0.9 → 1.1.0

package/.claude/settings.local.json

@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm run build:*)",
+      "Bash(npm run lint:*)",
+      "Bash(npx jest:*)",
+      "Bash(npm test:*)",
+      "Bash(npx eslint:*)"
+    ]
+  }
+}

package/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,29 @@
+---
+name: Bug report
+about: Report a bug in diff-grok
+title: "[BUG] "
+labels: bug
+assignees: ""
+
+---
+
+**What happened?**  
+A clear and concise description of the problem.
+
+**How to reproduce?**  
+Provide a minimal reproducible example (code snippet, inputs, parameters, Node/TS version, OS).
+
+**What did you expect to happen?**  
+Describe the expected behavior.
+
+**What actually happened?**  
+Describe the actual behavior, error messages, stack trace, wrong output, etc.
+
+**Environment:**  
+- diff-grok version:  
+- Node / TypeScript version:  
+- OS / Platform:  
+- Additional context (e.g. dependency versions):  
+
+(optional) **Example / Test case:**  
+Provide a minimal code snippet or scenario where bug occurs.

package/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest a new feature or improvement
+title: "[FEATURE] "
+labels: enhancement
+assignees: ""
+
+---
+
+**What problem would this feature solve?**  
+Describe the motivation, use-cases, or scenarios.
+
+**Proposed solution / API idea (if any):**  
+Give a rough idea how this could look (function signature, parameters, return type, etc.).  
+
+**Alternatives / Workarounds:**  
+Describe any existing workaround or alternative that motivated this.  
+
+**Additional context (optional):**  
+Remarks, performance considerations, backward-compatibility notes, etc.

package/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,22 @@
+## Description
+
+Please describe what this PR does and why it is needed.
+
+## Related Issue(s) / Motivation
+
+Closes / Addresses / References: #[issue number] (if applicable)
+
+## Type of change
+
+- [ ] Bug fix  
+- [ ] New feature  
+- [ ] Update / improvement  
+- [ ] Documentation / example update  
+
+## Checklist
+
+- [ ] I have read CONTRIBUTING.md  
+- [ ] My code follows project style (lint + formatting)  
+- [ ] I added / updated tests or examples (if applicable)  
+- [ ] All existing tests pass  
+- [ ] I updated documentation / README (if applicable)  

package/.github/workflows/deploy-docs.yml

@@ -0,0 +1,15 @@
+name: Deploy Docs
+on:
+  push:
+    branches: [ main ]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: npm ci
+      - run: npx typedoc
+      - uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./docs

package/CLAUDE.md

@@ -0,0 +1,98 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+**diff-grok** is a zero-dependency TypeScript library for solving initial value problems (IVPs) for ordinary differential equations (ODEs), focused on stiff equations. It implements Rosenbrock-Wanner type numerical methods and includes a declarative model scripting system.
+
+## Build & Development Commands
+
+```bash
+npm install          # Install dev dependencies
+npm run build        # Compile TypeScript (tsc)
+npm run lint         # ESLint check: eslint "./src/**/*.ts"
+npm run lint-fix     # Auto-fix lint issues
+npm test             # Run Jest test suite
+```
+
+Run a single test file:
+```bash
+npx jest src/tests/correctness.test.ts
+```
+
+## Architecture
+
+### Module Structure
+
+- **`index.ts`** — Single entry point; re-exports everything from the four modules below.
+
+- **`src/solver-tools/`** — Core numerical solvers
+  - **Implicit methods** (for stiff ODEs): `mrt` (Modified Rosenbrock Triple), `ros3prw`, `ros34prw`
+    - Require Jacobian computation and linear system solves
+    - Use LU decomposition for solving W*k = b at each stage
+  - **Automatic methods** (stiffness-detecting): `lsoda` (variable-order Nordsieck Adams/BDF with automatic switching)
+    - Automatically switch between non-stiff (Adams) and stiff (BDF) modes
+    - Use consecutive rejection counting (Adams→BDF) and periodic trial steps (BDF→Adams)
+  - **Explicit methods** (for non-stiff ODEs): `rk3` (Bogacki-Shampine 3(2)), `rk4` (Runge-Kutta-Fehlberg 4(5)), `ab5` (Adams-Bashforth-Moulton 5), `ab4` (Adams-Bashforth-Moulton 4), `rkdp` (Dormand-Prince 5(4))
+    - Only require function evaluations (no Jacobian)
+    - Include `hMax` constraint to prevent poor interpolation
+    - `ab5` and `ab4` are multistep predictor-corrector methods bootstrapped with RKF45
+  - Key types: `ODEs` (problem definition), `Func` (RHS function signature), `SolverMethod`
+  - `solver-defs.ts` — Type definitions, adaptive step constants, Jacobian/derivative computation
+  - `lin-alg-tools.ts` — Linear algebra routines (LU decomposition, matrix ops)
+  - `callbacks/` — Flow control during solving (iteration limits, time limits)
+
+- **`src/scripting-tools/`** — Declarative model parsing and JS code generation
+  - `scripting-tools.ts` — Main parser: converts model DSL text → `IVP` object → JavaScript code
+  - Model DSL uses `#name`, `#equations`, `#argument`, `#inits`, `#parameters`, `#constants`, `#expressions` blocks
+  - Entry functions: `getIVP()` (parse model string), `getJScode()` (generate JS from IVP)
+
+- **`src/pipeline/`** — Multi-stage simulation orchestration
+  - Three pipeline creators for different model types:
+    - `BasicModelPipelineCreator` — Single-stage models
+    - `CyclicModelPipelineCreator` — Loop/dosing models (PK-PD)
+    - `UpdatesModelPipelineCreator` — Multi-stage models with state transitions
+  - `applyPipeline()` runs the full computation pipeline
+
+- **`src/worker-tools/`** — WebWorker integration for browser parallel computation
+  - `getIvp2WebWorker()` serializes IVP for worker transfer; `solveIvp()` runs in worker
+
+### Data Flow
+
+1. Define problem as `ODEs` object (programmatic) or parse model string via `getIVP()`
+2. Call solver method (`mrt`/`ros3prw`/`ros34prw`/`rk3`/`rk4`/`ab5`/`ab4`/`rkdp`/`lsoda`) → returns `Float64Array[]` (argument values + solution columns)
+3. For complex models: create pipeline via `getPipelineCreator()` → `applyPipeline()`
+
+### Performance Patterns
+
+- Uses `Float64Array` throughout for memory efficiency
+- Pre-allocated buffers to minimize GC pressure
+- RHS function signature `(t, y, output) => void` writes to pre-allocated output array
+
+## Code Style
+
+- **ESLint config**: Google style base, 2-space indent, 120 char max line length
+- **Curly braces**: `"multi-or-nest"` — single-statement bodies don't need braces, multi-line do
+- **TypeScript strict mode** enabled
+- Commit messages: `feat:`, `fix:`, `docs:` prefixes (conventional style)
+
+## Testing
+
+Tests are in `src/tests/` using Jest with ts-jest:
+- `correctness.test.ts` — Validates solver accuracy against reference solutions (threshold: MAX_MAD = 0.1)
+  - Tests all methods (implicit + explicit + automatic) against 6 problems with known exact solutions (11 methods total)
+  - 3 non-stiff problems (1D, 2D, 3D) + 3 stiff problems (1D, 2D, 3D)
+- `performance.test.ts` — Benchmarks solver speed on stiff problems (timeout: 10,000ms)
+  - Tests implicit and automatic methods (MRT, ROS3PRw, ROS34PRw, LSODA)
+  - Test problems: Robertson, HIRES, VDPOL, OREGO, E5, Pollution
+- `pipeline.test.ts` — Pipeline integration tests (3 model types)
+- Method definitions in `test-defs.ts`: `methods` map (all 11 solvers), `implicitMethods` map (stiff-capable only)
+
+## Key Types
+
+```typescript
+type Func = (t: number, y: Float64Array, output: Float64Array) => void;
+type ODEs = { name, arg: {name, start, finish, step}, initial, func: Func, tolerance, solutionColNames };
+type SolverMethod = (odes: ODEs, callback?: Callback) => Float64Array[];
+```

package/CONTRIBUTING.md

@@ -0,0 +1,74 @@
+# Contributing to diff-grok 🚀
+
+Thank you for your interest in contributing to diff-grok!  
+We welcome bug reports, documentation improvements, new features, and help with tests or examples.
+
+## ✅ How to contribute
+
+### Reporting issues
+
+- Please search existing issues before creating a new one — your problem or idea may already be discussed or solved.  
+- When reporting a bug, include as much information as possible: error messages, minimal reproducible example, environment (Node version, OS, TypeScript version), and expected vs actual behavior.  
+- For feature requests — describe the motivation, proposed API (if relevant), and possible use-cases.
+
+### Submitting pull requests (PR)
+
+1. Fork the repository and create a branch:  
+   `feat/your-feature` or `fix/bug-description` or `docs/update-readme`  
+2. Make sure your code follows the existing style (TypeScript, ESLint, Prettier — as used in the repo).  
+3. Add or update tests/examples if applicable.  
+4. Run linter and tests before committing:
+
+```bash
+   npm install  
+   npm run lint  
+   npm test
+```
+
+5. Commit with a clear message. Prefer descriptive messages, e.g.:
+
+```bash
+feat: add new Rosenbrock method,
+fix: correct edge behaviour in solver,
+docs: improve README example for ODE usage.
+```
+
+6. Rebase or merge main upstream if needed; make sure no conflicts remain.
+
+7. Create a PR, describing what you’ve changed and referencing related issues (if any).
+
+## 🧑‍💻 Code style & conventions
+
+Project uses TypeScript.
+
+Follow the existing coding conventions and folder structure.
+
+Keep changes focused and minimal — avoid mixing unrelated changes (e.g. code + formatting + docs) in one PR.
+
+Write clear, self-contained commits.
+
+## 📚 Documentation & Examples
+
+If you fix or add public API — update README or add an example.
+
+For new features — prefer adding minimal examples or tests demonstrating usage.
+
+If you change behavior in edge cases — mention it clearly in docs/README.
+
+## 🗣 Communication & Etiquette
+
+Use GitHub Issues and Pull Requests for all discussions.
+
+Be respectful and patient: contributors and maintainers may be in different timezones or busy.
+
+Before opening an Issue or PR — read existing content (README, issues, pull requests) to avoid duplicates.
+
+## 🔧 CI, Tests, and Quality
+
+Ensure all existing tests pass; add new tests if adding functionality.
+
+Code should pass linting/formatting checks.
+
+If your change is substantial — consider adding a test or example illustrating it.
+
+Thank you for helping make diff-grok better! 🎉

package/README.MD

@@ -1,15 +1,31 @@
 # Diff Grok
 
-A lightweight TypeScript library for solving initial value problem ([IVP](https://en.wikipedia.org/wiki/Initial_value_problem)) for ordinary differential equations ([ODEs](https://en.wikipedia.org/wiki/Ordinary_differential_equation)) using numerical methods. This library focuses on solving [stiff equations](https://en.wikipedia.org/wiki/Stiff_equation).
+[![DOI](https://zenodo.org/badge/635090135.svg)](https://doi.org/10.5281/zenodo.17974378)
+[![Docs-stable](https://img.shields.io/badge/docs-stable-blue.svg)](https://datagrok-ai.github.io/diff-grok/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-success.svg)](https://github.com/datagrok-ai/diff-grok/blob/main/LICENSE)
+[![Build Status](https://github.com/datagrok-ai/diff-grok/actions/workflows/libraries.yaml/badge.svg)](https://github.com/datagrok-ai/diff-grok/actions/workflows/libraries.yaml)
+[![Run tests](https://github.com/datagrok-ai/diff-grok/actions/workflows/test.yaml/badge.svg)](https://github.com/datagrok-ai/diff-grok/actions/workflows/test.yaml)
+
+A lightweight TypeScript library for solving initial value problem ([IVP](https://en.wikipedia.org/wiki/Initial_value_problem)) for ordinary differential equations ([ODEs](https://en.wikipedia.org/wiki/Ordinary_differential_equation)) using numerical methods. The primary solver is [LSODA](https://doi.org/10.1137/0904010) — a variable-order method that automatically detects stiffness and switches between Adams (non-stiff) and BDF (stiff) formulations.
 
 ## Features
 
 * Solving both [stiff](https://en.wikipedia.org/wiki/Stiff_equation) and non-stiff equations
 * Fast computations
-* A set of Rosenbrock–Wanner-type methods:
+* Automatic stiffness-detecting method:
+  * [LSODA](https://doi.org/10.1137/0904010) - variable-order Nordsieck-based solver with automatic switching between Adams (non-stiff) and BDF (stiff) methods ([Petzold, 1983](https://doi.org/10.1137/0904010); [Hindmarsh, 1983](https://computing.llnl.gov/sites/default/files/ODEPACK_pub1_u88007.pdf)). Ported to TypeScript from the C library [liblsoda](https://github.com/sdwfrost/liblsoda)
+* Implicit methods (for stiff ODEs) - Rosenbrock–Wanner type:
   * The modified Rosenbrock triple ([MRT](https://doi.org/10.1137/S1064827594276424))
   * The [ROS3PRw](https://doi.org/10.1016/j.cam.2015.03.010) method
   * The [ROS34PRw](https://doi.org/10.1016/j.cam.2015.03.010) method
+* Explicit methods (for non-stiff ODEs):
+  * Runge-Kutta type:
+    * The Bogacki-Shampine 3(2) method ([RK3](https://en.wikipedia.org/wiki/Bogacki%E2%80%93Shampine_method))
+    * The Runge-Kutta-Fehlberg method ([RK4](https://en.wikipedia.org/wiki/Runge%E2%80%93Kutta%E2%80%93Fehlberg_method))
+    * The Dormand-Prince 5(4) method ([RKDP](https://en.wikipedia.org/wiki/Dormand%E2%80%93Prince_method))
+  * Adams-Bashforth type:
+    * The predictor-corrector method of order 4 ([AB4](https://en.wikipedia.org/wiki/Linear_multistep_method))
+    * The predictor-corrector method of order 5 ([AB5](https://en.wikipedia.org/wiki/Linear_multistep_method))
 * Scripting:
   * declarative specification of models
   * auto-generated JavaScript code
@@ -18,8 +34,34 @@ A lightweight TypeScript library for solving initial value problem ([IVP](https:
 
 ## Installation
 
+To install via npm:
+
 ```bash
-npm i diff-grok
+npm install diff-grok
+```
+
+Minimal "Hello World" example:
+
+```typescript
+// example.ts
+
+import {ODEs, mrt} from 'diff-grok';
+
+const task: ODEs = {
+  name: 'Example',
+  arg: {name: 't', start: 0, finish: 1, step: 0.1},
+  initial: [1, -1],
+  func: (t: number, y: Float64Array, output: Float64Array) => {
+    out[0] = y[0] - t;
+  },
+  tolerance: 1e-7,
+  solutionColNames: ['y(t)'],
+};
+
+const solution = mrt(task);
+
+console.log('t:', solution[0]);
+console.log('y(t):', solution[1]);
 ```
 
 ## Solving
@@ -35,10 +77,23 @@ on the segment $[t_0, t_1]$ with the step $h$:
 
 1. Import `ODEs` and a desired numerical method:
 
+   Automatic method:
+   * `lsoda` - [LSODA](https://doi.org/10.1137/0904010) variable-order solver with automatic switching between Adams (non-stiff) and BDF (stiff)
+
+   Implicit methods (for stiff ODEs):
    * `mrt` - the [MRT](https://doi.org/10.1137/S1064827594276424) method
    * `ros3prw`- the [ROS3PRw](https://doi.org/10.1016/j.cam.2015.03.010) method
    * `ros34prw` - the [ROS34PRw](https://doi.org/10.1016/j.cam.2015.03.010) method
 
+   Explicit methods (for non-stiff ODEs) — Runge-Kutta type:
+   * `rk3` - the Bogacki-Shampine 3(2) method
+   * `rk4` - the Runge-Kutta-Fehlberg 4(5) method
+   * `rkdp` - the Dormand-Prince 5(4) method
+
+   Explicit methods (for non-stiff ODEs) — Adams-Bashforth type:
+   * `ab4` - the predictor-corrector method of order 4
+   * `ab5` - the predictor-corrector method of order 5
+
 2. Specify `ODEs` object that defines a problem:
 
    * `name` - name of a model
@@ -71,10 +126,10 @@ x(0) = 1 \\
 y(0) = -1
 \end{cases}$$
 
-To solve it on the segment $[0, 2]$ with the step $0.01$ using the [MRT](https://doi.org/10.1137/S1064827594276424) method with the tolerance $10^{-7}$, we start with imports:
+To solve it on the segment $[0, 2]$ with the step $0.01$ using [LSODA](https://doi.org/10.1137/0904010) with the tolerance $10^{-7}$, we start with imports:
 
 ```typescript
-import {ODEs, mrt} from '@datagrok-ai/diff-studio-tools';
+import {ODEs, lsoda} from 'diff-grok';
 ```
 
 Next, we create
@@ -101,7 +156,7 @@ const task: ODEs = {
 Finally, we call the specified numerical method to solve `task`:
 
 ```typescript
-const solution = mrt(task);
+const solution = lsoda(task);
 ```
 
 Currently, `solution` contains:
@@ -141,18 +196,84 @@ The following [classic problems](https://archimede.uniba.it/~testset/testsetivps
   * describes a chemical reaction part of the air pollution model designed at The Dutch National Institute of Public Health and Environmental Protection
   * [pollution.ts](./src/examples/pollution.ts)
 
-The MRT, ROS3PRw and ROS34PRw methods demonstrate the following time performance (AMD Ryzen 5 5600H 3.30 GHz CPU):
+The LSODA, MRT, ROS3PRw and ROS34PRw methods demonstrate the following time performance (AMD Ryzen 5 5600H 3.30 GHz CPU):
+
+|Problem|Segment|Points|Tolerance|LSODA, ms|MRT, ms|ROS3PRw, ms|ROS34PRw, ms|
+|-|-|-|-|-|-|-|-|
+|[Rober](https://archimede.uniba.it/~testset/report/rober.pdf)|[0, 10E+11]|40K|1E-7|67|175|446|285|
+|[HIRES](https://archimede.uniba.it/~testset/report/hires.pdf)|[0, 321.8122]|32K|1E-10|125|122|362|215|
+|[VDPOL](https://archimede.uniba.it/~testset/report/vdpol.pdf)|[0, 2000]|20K|1E-12|268|492|1576|760|
+|[OREGO](https://archimede.uniba.it/~testset/report/orego.pdf)|[0, 360]|36K|1E-8|76|205|483|199|
+|[E5](https://archimede.uniba.it/~testset/report/e5.pdf)|[0, 10E+13]|40K|1E-6|7|6|17|8|
+|[Pollution](https://archimede.uniba.it/~testset/report/pollu.pdf)|[0, 60]|30K|1E-6|12|18|50|23|
+
+Maximum absolute deviations (MADs) from the reference solutions obtained using SciPy (Radau) are summarized in the table below:
+
+|Problem|LSODA|MRT|ROS3PRw|ROS34PRw|
+|-|-|-|-|-|
+|[Rober](https://archimede.uniba.it/~testset/report/rober.pdf)|1.87e-8|1.87e-8|1.88e-8|1.88e-8|
+|[HIRES](https://archimede.uniba.it/~testset/report/hires.pdf)|1.51e-11|4.80e-11|1.05e-14|2.87e-14|
+|[VDPOL](https://archimede.uniba.it/~testset/report/vdpol.pdf)|5.12e-4|5.12e-4|5.12e-4|5.12e-4|
+|[OREGO](https://archimede.uniba.it/~testset/report/orego.pdf)|3.84e-6|3.05e-5|3.45e-7|2.31e-6|
+|[E5](https://archimede.uniba.it/~testset/report/e5.pdf)|3.02e-19|1.12e-19| 1.33e-19|3.40e-17|
+|[Pollution](https://archimede.uniba.it/~testset/report/pollu.pdf)|1.23e-10|4.06e-10|9.16e-12|1.58e-10|
+
+Run [check-methods.ts](./src/examples/check-methods.ts) to reproduce these results (see [here](#examples) how to run scripts standalone).
+
+The following charts compare the Diff Grok and Radau solutions for the **van der Pol** system:
+
+![VDPOL](images/VDPOL.png)
+
+The following graphs present a comparison of the Diff Grok and Radau solutions for the **Pollution** model, highlighting a portion of the functions:
+
+![Pollution](images/POLL.png)
+
+<details>
+<summary><strong>Gallery</strong></summary>
+
+**VDPOL**
+
+![VDPOL](images/VDP0L.png)
+
+**HIRES**
+
+![HIRES](images/HIRES.png)
+
+**E5**
+
+![E5](images/E5.png)
+
+**POLL**
+
+![POLL](images/POLL-full.png)
+
+**OREGO**
+
+![OREGO](images/OREGO.png)
+
+**Rober**
+
+![ROBER](images/ROBER.png)
+
+</details>
+
+<details>
+<summary><strong>Run benchmarks</strong></summary>
+
+Run benchmark models and find the reference solutions via the following links to the [Datagrok](https://public.datagrok.ai) platform:
+
+|Problem|Diff Grok|Radau|
+|-|-|-|
+|Rober|[ROBER.ivp](https://public.datagrok.ai/file/System.AppData/DiffStudio/benchmarks/ROBER.ivp)|[ROBER.csv](https://public.datagrok.ai/file/System.AppData/DiffStudio/benchmarks/ROBER-using-Radau.csv?browse=files)|
+|HIRES|[HIRES.ivp](https://public.datagrok.ai/file/System.AppData/DiffStudio/benchmarks/HIRES.ivp)|[HIRES.csv](https://public.datagrok.ai/file/System.AppData/DiffStudio/benchmarks/HIRES-using-Radau.csv?browse=files)|
+|VDPOL|[VDPOL.ivp](https://public.datagrok.ai/file/System.AppData/DiffStudio/benchmarks/VDPOL.ivp)|[VDPOL.csv](https://public.datagrok.ai/file/System.AppData/DiffStudio/benchmarks/VANDERPOL-using-Radau.csv?browse=files)|
+|OREGO|[OREGO.ivp](https://public.datagrok.ai/file/System.AppData/DiffStudio/benchmarks/OREGO.ivp)|[OREGO.csv](https://public.datagrok.ai/file/System.AppData/DiffStudio/benchmarks/OREGO-using-Radau.csv?browse=files)|
+|E5|[E5.ivp](https://public.datagrok.ai/file/System.AppData/DiffStudio/benchmarks/E5.ivp)|[E5.csv](https://public.datagrok.ai/file/System.AppData/DiffStudio/benchmarks/E5-using-Radau.csv?browse=files)|
+|Pollution|[POLL.ivp](https://public.datagrok.ai/file/System.AppData/DiffStudio/benchmarks/POLL.ivp)|[POLL.csv](https://public.datagrok.ai/file/System.AppData/DiffStudio/benchmarks/POLL-using-Radau.csv?browse=files)|
 
-|Problem|Segment|Points|Tolerance|MRT, ms|ROS3PRw, ms|ROS34PRw, ms|
-|-|-|-|-|-|-|-|
-|[Rober](https://archimede.uniba.it/~testset/report/rober.pdf)|[0, 10E+11]|40K|1E-7|103|446|285|
-|[HIRES](https://archimede.uniba.it/~testset/report/hires.pdf)|[0, 321.8122]|32K|1E-10|222|362|215|
-|[VDPOL](https://archimede.uniba.it/~testset/report/vdpol.pdf)|[0, 2000]|20K|1E-12|963|1576|760|
-|[OREGO](https://archimede.uniba.it/~testset/report/orego.pdf)|[0, 360]|36K|1E-8|381|483|199|
-|[E5](https://archimede.uniba.it/~testset/report/e5.pdf)|[0, 10E+13]|40K|1E-6|14|17|8|
-|[Pollution](https://archimede.uniba.it/~testset/report/pollu.pdf)|[0, 60]|30K|1E-6|36|50|23|
+In the file [print-benchmark.ts](./src/examples/print-benchmark.ts), you can find standalone functions that print the solutions of these problems to the console, as well as Python scripts for computing the solutions using SciPy.
 
-Run [check-methods.ts](./src/examples/check-methods.ts) to check results.
+</details>
 
 ## Scripting
 
@@ -262,7 +383,7 @@ To transform any model to JavaScript code with an appropriate specification of `
 1. Import the parsing and code generating tools:
 
 ```typescript
-import {getIVP, getJScode} from '@datagrok-ai/diff-studio-tools';
+import {getIVP, getJScode} from 'diff-grok';
 ```
 
 2. Define a string with a model specification, use a simple [model syntax](#model-components-and-syntax):
@@ -302,7 +423,7 @@ Diff Grok **pipeline** is a powerful feature for complex process simulation and
 1. Start with imports:
 
 ```typescript
-import * as DGL from '@datagrok/diff-grok';
+import * as DGL from 'diff-grok';
 ```
 
 2. Define your model:
@@ -394,3 +515,136 @@ Learn more
  * Diff Studio example [models](https://datagrok.ai/help/compute/models)
  * [Parameters optimization](https://datagrok.ai/help/compute/function-analysis#parameter-optimization)
  * [Sensitivity analysis](https://datagrok.ai/help/compute/function-analysis#sensitivity-analysis)
+
+## Environment Requirements
+
+### Development & Build
+
+* **Node.js ≥ 19.3.0** (required for development and building the library)
+* **npm** or **yarn** package manager
+
+### Runtime Environments
+
+#### Server-Side (Node.js)
+
+* **Node.js ≥ 16.0.0** (for server-side usage)
+  * Requires support for ES modules
+  * `Float64Array` and typed arrays support (available since Node.js 0.10+)
+
+#### Operating Systems
+
+* Windows (x64, ARM64)
+* macOS (Intel & Apple Silicon)
+* Linux (most common distributions)
+
+#### Browser Support
+
+The library runs in all modern browsers with ES2015+ support. Key requirements:
+
+* **ES Modules** (native `import`/`export`)
+* **Typed Arrays** (`Float64Array`, `Uint8Array`)
+* **WebWorkers** (for pipeline computations)
+* **ArrayBuffer** support
+
+| Browser                | Minimum Version | Supported? | Notes                                           |
+| ---------------------- | --------------- | ---------- | ----------------------------------------------- |
+| **Chrome**             | 63+             | ✔️ Yes      | Full ES2015+ and WebWorker support              |
+| **Firefox**            | 60+             | ✔️ Yes      | Full ES2015+ and WebWorker support              |
+| **Safari (macOS/iOS)** | 11.1+           | ✔️ Yes      | Native ES module and WebWorker support          |
+| **Edge (Chromium)**    | 79+             | ✔️ Yes      | Same support level as Chrome                    |
+| **Opera**              | 50+             | ✔️ Yes      | Chromium-based, full support                    |
+| **Legacy Browsers**    | -               | ❌ No       | IE 11, pre-Chromium Edge, old Android browsers  |
+
+**Browser Feature Requirements:**
+* ES2015 (ES6) JavaScript support
+* Native ES modules (`<script type="module">`)
+* `Float64Array` and other typed arrays
+* `WebWorker` API (for parallel computations)
+* `Promise` support
+* `Math` object with standard functions (`exp`, `sin`, `cos`, etc.)
+
+**Notes:**
+* For older browsers, consider using a transpiler (Babel) and bundler (Webpack/Rollup)
+* TypeScript compilation target should be ES2015 or higher
+* WebWorker support is required for pipeline computations; without it, computations run on the main thread
+
+### Bundler Configuration
+
+When bundling for browsers, ensure:
+* ES module output format is preserved or properly transformed
+* TypedArray polyfills are not included (not needed for target browsers)
+* WebWorker files are properly handled by your bundler
+
+### Polyfills
+
+No polyfills required for target environments. All required features are natively supported in the minimum browser versions listed above.
+
+## Examples
+
+Diff Grok contains a set of examples located in the folder [src/examples](./src/examples/):
+
+|File|Features|
+|-|-|
+|[basic-use.ts](./src/examples/basic-use.ts)|Minimal "Hello World" example. Illustrates the use of the [LSODA](https://doi.org/10.1137/0904010) method.|
+|[check-methods.ts](./src/examples/check-methods.ts)| Checks the [performance](#performance) of numerical methods.|
+|[corr-probs.ts](./src/examples/corr-probs.ts)|Solves a set of problems with exact solutions and evaluate the deviation.|
+|[cyclic-model.ts](./src/examples/cyclic-model.ts)| Considers pharmacokinetic-pharmacodynamic (PK-PD) simulation and shows how to apply pipelines and cyclic models.|
+|[model-updates.ts](./src/examples/model-updates.ts)|Considers gluconic acid (GA) production by Aspergillus niger modeling and shows how to apply pipelines and models with updates.|
+|[pipeline-use.ts](./src/examples/pipeline-use.ts)|Considers modeling queues and shows shows how to apply pipelines and models with customized outputs.|
+|[scripting.ts](./src/examples/scripting.ts)|Shows how to generate JS-script from Diff Grok model.|
+
+<details>
+<summary><strong>Run examples</strong></summary>
+
+To run examples standalone:
+
+1. Install TypeScript locally. If your project does not already include TypeScript:
+```bash
+npm install --save-dev typescript
+```
+
+2. Create a tsconfig.json. If you do not have one yet:
+```bash
+npx tsc --init
+```
+Recommended configuration:
+```json
+{
+  "compilerOptions": {
+    "target": "es6",
+    "lib": ["ES2022", "dom"],
+    "sourceMap": true,
+    "strict": true,
+    "moduleResolution": "node",
+    "types": ["jest", "node"],
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+  }
+}
+```
+
+3. Compile the TypeScript file:
+```bash
+tsc src/examples/basic-use.ts
+```
+
+4. Run:
+```bash
+node src/examples/basic-use.js
+```
+
+</details>
+
+## References
+
+* L. Petzold, "Automatic Selection of Methods for Solving Stiff and Nonstiff Systems of Ordinary Differential Equations," *SIAM J. Sci. Stat. Comput.*, 4(1), 136–148, 1983. [doi:10.1137/0904010](https://doi.org/10.1137/0904010)
+* A. C. Hindmarsh, "ODEPACK, A Systematized Collection of ODE Solvers," *Scientific Computing*, R. S. Stepleman et al. (eds.), North-Holland, Amsterdam, pp. 55–64, 1983. [link](https://computing.llnl.gov/sites/default/files/ODEPACK_pub1_u88007.pdf)
+* The LSODA solver is ported to TypeScript from the C library [liblsoda](https://github.com/sdwfrost/liblsoda)
+* T. Rang and L. Angermann, "New Rosenbrock W-Methods of Order 3 for Partial Differential Algebraic Equations of Index 1," *BIT Numer. Math.*, 45, 761–787, 2005. [doi:10.1007/s10543-005-0035-y](https://doi.org/10.1016/j.cam.2015.03.010)
+* E. Hairer and G. Wanner, *Solving Ordinary Differential Equations II: Stiff and Differential-Algebraic Problems*, Springer, 1996. [doi:10.1137/S1064827594276424](https://doi.org/10.1137/S1064827594276424)
+
+## Contributing
+
+We welcome contributions of all kinds - bug reports, feature requests, documentation updates, and pull requests.
+
+Before contributing, please read our [Contributing Guidelines](./CONTRIBUTING.md).

package/index.js

@@ -1,5 +1,5 @@
-export { mrt, ros3prw, ros34prw, CallbackAction, DEFAULT_OPTIONS, getCallback } from './src/solver-tools';
-export { perfProbs, corrProbs } from './src/examples';
+export { mrt, ros3prw, ros34prw, rk4, ab5, ab4, rkdp, rk3, lsoda, CallbackAction, DEFAULT_OPTIONS, getCallback, Callback, IterCheckerCallback, TimeCheckerCallback } from './src/solver-tools';
+export { perfProbs, corrProbs, refPoints, printRobertson, printHires, printOrego, printE5, printVdpol, printPollution } from './src/examples';
 export { DF_NAME, CONTROL_EXPR, MAX_LINE_CHART, getIVP, getScriptLines, getScriptParams, getJScode, SCRIPTING, BRACE_OPEN, BRACE_CLOSE, BRACKET_OPEN, BRACKET_CLOSE, ANNOT_SEPAR, CONTROL_SEP, STAGE_COL_NAME, ARG_INPUT_KEYS, DEFAULT_SOLVER_SETTINGS, ModelError, getFunc4worker } from './src/scripting-tools';
 export { getIvp2WebWorker, solveIvp } from './src/worker-tools';
 export { applyPipeline, getOutputCode, getOutputNames, PipelineCreator, BasicModelPipelineCreator, getInputVector, getPipelineCreator, CyclicModelPipelineCreator, UpdatesModelPipelineCreator } from './src/pipeline';