react-msaview-cli 6.5.0 → 8.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/README.md +161 -122
  2. package/dist/index.js +130746 -0
  3. package/package.json +12 -17
package/README.md CHANGED
@@ -3,28 +3,29 @@
3
3
  Annotate a multiple sequence alignment and render it to a publication figure,
4
4
  from the command line, with no browser in the loop.
5
5
 
6
- Two things live here, and they compose:
6
+ The CLI has two groups of commands, and the second draws what the first writes:
7
7
 
8
- - **Annotate** — build a domain or exon GFF for an alignment, from InterPro's
8
+ - **Annotate**: build a domain or exon GFF for an alignment, from InterPro's
9
9
  precomputed matches (`interpro`), a live InterProScan run (`interproscan`), or
10
10
  a RefSeq transcript's exon model (`genestructure`).
11
- - **Render** — draw the alignment, its tree, and those annotations to a
12
- standalone SVG (`export-svg`). This is the same renderer the web viewer uses,
13
- driven headlessly, so the figure matches what the app shows.
11
+ - **Render**: draw the alignment, its tree, and those annotations to a
12
+ standalone SVG (`export-svg`). The command runs the web viewer's renderer
13
+ headlessly, so the figure matches what the app shows.
14
14
 
15
15
  ## Prerequisites
16
16
 
17
17
  - NodeJS v22+
18
18
 
19
- Nothing else for `export-svg` and `interpro`. `interproscan` needs a backend to
20
- scan with — the EBI web API (the default, no install), or Docker, Singularity,
21
- or a local InterProScan (see [interproscan](#interproscan)).
19
+ `export-svg` and `interpro` need nothing else. `interproscan` needs a backend to
20
+ scan with: the EBI web API (the default, no install), Docker, Singularity, or a
21
+ local InterProScan (see [interproscan](#interproscan)).
22
22
 
23
23
  `export-svg` draws the alignment background as one embedded image when
24
- [@napi-rs/canvas](https://www.npmjs.com/package/@napi-rs/canvas) is present. It
25
- is an optional dependency with prebuilt binaries, so a normal install brings it
26
- in; on a platform it does not cover, the export still works and draws a
27
- rectangle per cell instead, which is much larger and slower for big alignments.
24
+ [@napi-rs/canvas](https://www.npmjs.com/package/@napi-rs/canvas) is present. The
25
+ package is an optional dependency with prebuilt binaries, so a normal install
26
+ brings it in. On a platform with no prebuilt binary, the export draws a
27
+ rectangle per cell, which makes a much larger file and runs slower on big
28
+ alignments.
28
29
 
29
30
  ## Setup
30
31
 
@@ -55,13 +56,14 @@ react-msaview-cli export-svg --msa kinases.aln --tree kinases.nwk \
55
56
 
56
57
  ![Src-family kinases: tree, SH3/SH2/kinase domain architecture, and the color key](../../docs/media/cli-domains.png)
57
58
 
58
- The domain architecture reads straight down the alignment — SH3, then SH2, then
59
- the catalytic domain — because every row is drawn in the alignment's own column
60
- space. The key on the right is generated from the domains actually present.
59
+ The domain architecture reads straight down the alignment: SH3, then SH2, then
60
+ the catalytic domain. The renderer draws every row in the alignment's column
61
+ space, so each domain lands in the same columns in every row. The key on the
62
+ right lists the domains present in the GFF.
61
63
 
62
64
  Every figure on this page is `export-svg` output, drawn from the Src-kinase and
63
65
  GPCR examples in
64
- [packages/examples](https://github.com/GMOD/JBrowseMSA/tree/main/packages/examples/src/examples/exampleData.ts).
66
+ [packages/examples](https://github.com/GMOD/JBrowseMSA/tree/main/packages/examples/data).
65
67
 
66
68
  ## Rendering figures
67
69
 
@@ -69,25 +71,42 @@ GPCR examples in
69
71
  react-msaview-cli export-svg --msa <file> [options]
70
72
  ```
71
73
 
72
- | Option | Description | Default |
73
- | ------------------------ | -------------------------------------------- | --------------- |
74
- | `--msa <file>` | MSA file (FASTA, Stockholm, Clustal, A3M) | _required_ |
75
- | `--tree <file>` | Newick tree file | |
76
- | `--gff <file>` | Domain or exon GFF (from the commands below) | |
77
- | `-o, --output <file>` | Output SVG file path | `alignment.svg` |
78
- | `--color-scheme <name>` | Color scheme | `maeditor` |
79
- | `--col-width <px>` | Width of one alignment column | `12` |
80
- | `--row-height <px>` | Height of one alignment row | `16` |
81
- | `--width <px>` | Viewport width, which sets the tree area | `1200` |
82
- | `--height <px>` | Viewport height | `600` |
83
- | `--tree-area-width <px>` | Tree panel width in pixels | |
74
+ | Option | Description | Default |
75
+ | ------------------------ | ---------------------------------------------- | --------------- |
76
+ | `--msa <file>` | MSA file (FASTA, Stockholm, Clustal, A3M, EMF) | _required_ |
77
+ | `--tree <file>` | Newick tree file | |
78
+ | `--gff <file>` | Domain or exon GFF (from the commands below) | |
79
+ | `-o, --output <file>` | Output SVG file path | `alignment.svg` |
80
+ | `--color-scheme <name>` | Color scheme | `maeditor` |
81
+ | `--col-width <px>` | Width of one alignment column | `12` |
82
+ | `--row-height <px>` | Height of one alignment row | `16` |
83
+ | `--width <px>` | Viewport width, which sets the tree area | `1200` |
84
+ | `--height <px>` | Viewport height | `600` |
85
+ | `--tree-area-width <px>` | Tree panel width in pixels | |
86
+ | `--format <name>` | Force the MSA format instead of sniffing it | |
87
+ | `--tracks <list>` | Tracks to draw above the alignment, by id | none |
88
+ | `--viewport` | Draw the viewport instead of the whole thing | |
89
+ | `--minimap` | Include the minimap bar (`--viewport` only) | |
90
+
91
+ ### Tracks
92
+
93
+ `--tracks` names the tracks to draw above the alignment, by id, or `all` for
94
+ every one this alignment has: `conservation`, `property-conservation` (protein
95
+ only), `sequence-logo`, `position-ruler`, `base-pairs` (a Stockholm `SS_cons`
96
+ line), and any track ids the file itself carries. The CLI reports a name that
97
+ matches no track.
98
+
99
+ ```bash
100
+ react-msaview-cli export-svg --msa kinases.aln --tracks conservation,position-ruler \
101
+ -o kinases.svg
102
+ ```
84
103
 
85
104
  ### Sizing the figure
86
105
 
87
- `export-svg` always draws the **entire** alignment, so the output is as wide as
88
- the alignment is long — `--width` and `--height` size the viewport the model
89
- lays out in, not the figure. What scales the figure is `--col-width` and
90
- `--row-height`:
106
+ `export-svg` draws the **entire** alignment unless `--viewport` asks for the
107
+ `--width` x `--height` window at the top left, so the output is normally as wide
108
+ as the alignment is long. `--width` and `--height` size the viewport the model
109
+ lays out in, not the figure. `--col-width` and `--row-height` scale the figure:
91
110
 
92
111
  ```bash
93
112
  ## a 90-column alignment at the default 12px columns: letters are legible
@@ -104,12 +123,11 @@ react-msaview-cli export-svg --msa kinases.aln --tree kinases.nwk \
104
123
 
105
124
  ![The same kinase family drawn as a colored overview beside its tree](../../docs/media/cli-quickstart.png)
106
125
 
107
- Residue letters draw only where there is room for them — columns at least 5px
108
- wide and wider than half the row height, rows at least 8px tall — which is the
109
- same rule the app applies as you zoom out. Below that you get the colored
110
- overview above, and for a whole-alignment figure that is usually what you want:
111
- the conserved blocks and the gaps are the signal at that scale, and the letters
112
- would be unreadable ink.
126
+ Residue letters draw only in columns at least 5px wide and wider than half the
127
+ row height, and in rows at least 8px tall. The app applies the same rule as you
128
+ zoom out. Below that size the figure is the colored overview above, which
129
+ usually suits a whole-alignment figure: at that scale the conserved blocks and
130
+ gaps are visible, and letters would be too small to read.
113
131
 
114
132
  ### Color schemes
115
133
 
@@ -124,50 +142,56 @@ react-msaview-cli export-svg --msa gpcrs.fa \
124
142
  `cinema`, and the `jalview_*` family (`jalview_zappo`, `jalview_taylor`,
125
143
  `jalview_hydrophobicity`, `jalview_buried`, `jalview_prophelix`,
126
144
  `jalview_propstrand`, `jalview_propturn`) color each residue by identity. The
127
- two `_dynamic` schemes — `clustalx_protein_dynamic` and
128
- `percent_identity_dynamic` — color by what the column actually contains, so
129
- conservation shows up as color rather than as something you have to read off.
130
- `nucleotide`, `clustalx_dna`, `jbrowse_dna` and `rainbow_dna` are for DNA;
131
- `none` turns background color off.
145
+ two `_dynamic` schemes, `clustalx_protein_dynamic` and
146
+ `percent_identity_dynamic`, color each residue by the composition of its column,
147
+ so conserved columns stand out by color. `nucleotide`, `clustalx_dna`,
148
+ `jbrowse_dna` and `rainbow_dna` are for DNA; `none` turns background color off.
132
149
 
133
150
  ### Output
134
151
 
135
- The SVG is pure vector: every cell is its own rectangle, so it scales without
136
- limit but grows with the alignment. A 10-row by 856-column figure is about
137
- 700KB. Converting to PNG or PDF for a journal:
152
+ The SVG grows with the alignment: a 10-row by 856-column figure is about 700KB.
153
+ The background is one embedded image where @napi-rs/canvas is installed, and a
154
+ rectangle per cell where it is not. The letters, the tree and the annotations
155
+ are vector either way. To convert to PNG or PDF for a journal:
138
156
 
139
157
  ```bash
140
158
  rsvg-convert -w 2000 alignment.svg -o alignment.png
141
159
  inkscape alignment.svg --export-filename=alignment.pdf
142
160
  ```
143
161
 
144
- Exports are reproducible — the same input gives the same bytes, so a figure can
145
- be regenerated in CI and diffed.
162
+ The same input gives the same bytes, so CI can regenerate a figure and diff it.
146
163
 
147
164
  ## Annotating
148
165
 
149
166
  ### interpro
150
167
 
151
168
  Build a domain GFF from InterPro's **precomputed** matches for UniProtKB
152
- accessions, instead of submitting sequences to a live InterProScan job. Every
153
- UniProtKB sequence already has InterPro matches computed and served by the EBI
154
- InterPro API, so for inputs that are real UniProt accessions this is instant,
155
- deterministic, and version-pinnable — no email or rate-limited job submission.
156
- Prefer this over `interproscan` whenever your rows are UniProt accessions.
169
+ accessions. The EBI InterPro API already serves matches for every UniProtKB
170
+ sequence, so the lookup returns in seconds, gives the same result for a given
171
+ InterPro release, and needs no email or rate-limited job. Use this instead of
172
+ `interproscan` whenever your rows are UniProt accessions.
157
173
 
158
174
  ```bash
159
175
  react-msaview-cli interpro <accessions.tsv> [options]
160
176
  ```
161
177
 
162
178
  The input is one accession per line, optionally followed by a tab- or
163
- space-separated row label; lines starting with `#` are ignored. The output GFF
164
- is byte-for-byte compatible with the `interproscan` command.
165
-
166
- | Option | Description | Default |
167
- | --------------------- | --------------------------------- | ------------- |
168
- | `-o, --output <file>` | Output GFF file path | `domains.gff` |
169
- | `--database <name>` | InterPro member db to read | `pfam` |
170
- | `--no-cache` | Re-fetch, ignoring the disk cache | off |
179
+ space-separated row label. The command skips lines starting with `#`. It writes
180
+ through the same GFF writer as `interproscan`, and adds a `#` header line naming
181
+ the InterPro release the coordinates came from.
182
+
183
+ | Option | Description | Default |
184
+ | --------------------- | ----------------------------------------------- | ------------- |
185
+ | `-o, --output <file>` | Output GFF file path | `domains.gff` |
186
+ | `--database <name>` | InterPro member db to read | `pfam` |
187
+ | `--msa <file>` | Alignment to check the rows of (see below) | |
188
+ | `--format <name>` | Force the `--msa` format instead of sniffing it | |
189
+ | `--no-cache` | Re-fetch, ignoring the disk cache | off |
190
+
191
+ InterPro computes matches on UniProt's canonical sequence, so on a row that is
192
+ an isoform or a fragment the matches land on the wrong residues. With `--msa`,
193
+ the CLI compares each row's ungapped length against the protein's and warns
194
+ about any that differ. It also warns about any accession with no matches.
171
195
 
172
196
  ```bash
173
197
  react-msaview-cli interpro accessions.tsv -o domains.gff
@@ -176,53 +200,54 @@ react-msaview-cli interpro accessions.tsv -o domains.gff --database cdd
176
200
 
177
201
  #### Caching
178
202
 
179
- The InterPro API serves one protein per request — there is no batch endpoint —
180
- so the request count is fixed at one per distinct accession. To keep that from
181
- being paid twice, every response is cached on disk under
182
- `$XDG_CACHE_HOME/react-msaview-cli/interpro` (override with
183
- `REACT_MSAVIEW_CACHE`), keyed by InterPro release so a new release misses
184
- cleanly rather than serving coordinates computed against the old one. Proteins
185
- with no matches are cached too, so they are not re-fetched every run.
203
+ The InterPro API serves one protein per request and has no batch endpoint, so a
204
+ run makes one request per distinct accession. The CLI caches every response on
205
+ disk under `$XDG_CACHE_HOME/react-msaview-cli/interpro` (override with
206
+ `REACT_MSAVIEW_CACHE`), keyed by InterPro release, so a new release fetches
207
+ fresh coordinates. The cache also records proteins with no matches, so a re-run
208
+ does not fetch them again.
186
209
 
187
- A re-run of the same dataset therefore makes one request — the release lookup —
188
- and answers the rest from disk. That also makes a failed run resumable: retries
189
- are automatic with backoff, and if the API is still unreachable the accessions
190
- already fetched stay cached, so re-running picks up where it stopped instead of
191
- asking EBI for all of them again.
210
+ A re-run of the same dataset makes one request, the release lookup, and reads
211
+ the rest from disk. A failed run can therefore resume. The CLI retries with
212
+ backoff, and if the API stays unreachable, the accessions it already fetched
213
+ stay cached, so the next run fetches only the rest.
192
214
 
193
215
  ### interproscan
194
216
 
195
217
  Run InterProScan on all sequences in an MSA file and output results as GFF3. Use
196
- this when the rows are not UniProt accessions — a de novo assembly, predicted
197
- proteins, anything InterPro has not already scanned.
218
+ this when the rows are not UniProt accessions: a de novo assembly, predicted
219
+ proteins, or anything else InterPro has not scanned.
198
220
 
199
221
  ```bash
200
222
  react-msaview-cli interproscan <input-msa> [options]
201
223
  ```
202
224
 
203
- | Option | Description | Default |
204
- | ---------------------------- | ------------------------------------------------------ | --------------------------------------- |
205
- | `-o, --output <file>` | Output GFF file path | `domains.gff` |
206
- | `--local` | Use a local InterProScan installation instead of EBI | `false` |
207
- | `--docker` | Run InterProScan via the `interpro/interproscan` image | `false` |
208
- | `--singularity` | Run InterProScan via a Singularity/Apptainer container | `false` |
209
- | `--singularity-image <img>` | Singularity image to use | `docker://interpro/interproscan:latest` |
210
- | `--interproscan-path <path>` | Path to local interproscan.sh | `interproscan.sh` |
211
- | `--programs <list>` | Comma-separated list of InterProScan programs | `PfamA,CDD` |
212
- | `--email <email>` | Email for EBI API (used only for EBI API runs) | `user@example.com` |
225
+ | Option | Description | Default |
226
+ | ---------------------------- | ------------------------------------------------------ | ------------------------------------------- |
227
+ | `-o, --output <file>` | Output GFF file path | `domains.gff` |
228
+ | `--local` | Use a local InterProScan installation instead of EBI | `false` |
229
+ | `--docker` | Run InterProScan via the `interpro/interproscan` image | `false` |
230
+ | `--singularity` | Run InterProScan via a Singularity/Apptainer container | `false` |
231
+ | `--docker-image <img>` | Docker image to run | `interpro/interproscan:5.78-109.0` |
232
+ | `--singularity-image <img>` | Singularity image to use | `docker://interpro/interproscan:5.78-109.0` |
233
+ | `--interproscan-path <path>` | Path to local interproscan.sh | `interproscan.sh` |
234
+ | `--interproscan-data <dir>` | Member database `data/` to mount into the container | |
235
+ | `--programs <list>` | Comma-separated list of programs, in EBI API naming | `PfamA,CDD` |
236
+ | `--format <name>` | Force the MSA format instead of sniffing it | |
237
+ | `--email <email>` | Email for EBI API (used only for EBI API runs) | `user@example.com` |
213
238
 
214
239
  By default (no backend flag) the CLI submits sequences to the EBI InterProScan
215
- REST API one at a time. `--local`, `--docker`, and `--singularity` instead run
240
+ REST API one at a time. `--local`, `--docker`, and `--singularity` run
216
241
  InterProScan on the whole alignment locally, which is much faster for large
217
242
  datasets.
218
243
 
219
244
  #### Choosing a backend
220
245
 
221
246
  ```bash
222
- ## EBI web API — no install, but one sequential submission per sequence
247
+ ## EBI web API: no install, one sequential submission per sequence
223
248
  react-msaview-cli interproscan alignment.fasta -o domains.gff --email you@example.com
224
249
 
225
- ## Docker — no InterProScan install, whole alignment in one run
250
+ ## Docker: no InterProScan install, whole alignment in one run
226
251
  react-msaview-cli interproscan alignment.fasta -o domains.gff --docker
227
252
 
228
253
  ## a local install
@@ -237,15 +262,24 @@ react-msaview-cli interproscan alignment.fasta -o domains.gff \
237
262
  Docker mounts a temp directory into the `interpro/interproscan` container, runs
238
263
  the scan on the whole alignment at once, and reads the JSON back out.
239
264
 
240
- The EBI API has usage limits: sequences go one at a time, sequentially, to avoid
241
- overwhelming the server. Past about 100 sequences, use a local or container
242
- backend.
265
+ The published image carries InterProScan but **not** its member database data,
266
+ which is a separate multi-gigabyte download. Fetch and unpack the matching
267
+ release's `data/` directory (see the
268
+ [InterProScan docs](https://interproscan-docs.readthedocs.io/)) and point
269
+ `--interproscan-data` at it. Both container backends mount it at
270
+ `/opt/interproscan/data` and look for it there.
271
+
272
+ The EBI API has usage limits, so the CLI submits sequences one at a time. Past
273
+ about 100 sequences, use a local or container backend.
243
274
 
244
275
  #### InterProScan programs
245
276
 
246
- `--programs` takes any combination of `PfamA` (in the default), `CDD` (in the
247
- default), `SMART`, `SUPERFAMILY`, `Gene3D`, `PANTHER`, `TIGRFAM`, `Hamap`,
248
- `ProSiteProfiles`, `ProSitePatterns`, `PRINTS`, `PIRSF`, and `MobiDBLite`.
277
+ `--programs` takes the EBI API's names whichever backend runs: `PfamA` and `CDD`
278
+ (the default), `SMART`, `SuperFamily`, `Gene3d`, `PANTHER`, `TIGRFAM`, `HAMAP`,
279
+ `PrositeProfiles`, `PrositePatterns`, `PRINTS`, `PIRSF`, `MobiDBLite`, `Coils`,
280
+ `SFLD`. InterProScan 5 spells several of them differently (`Pfam`, not `PfamA`;
281
+ `NCBIfam`, which absorbed TIGRFAM; `Hamap`; `SUPERFAMILY`; `Gene3D`), and the
282
+ CLI passes the translated names to the local, Docker and Singularity backends.
249
283
 
250
284
  ```bash
251
285
  react-msaview-cli interproscan alignment.fasta -o domains.gff \
@@ -255,20 +289,21 @@ react-msaview-cli interproscan alignment.fasta -o domains.gff \
255
289
  ### genestructure
256
290
 
257
291
  Build a **gene-structure GFF** for a coding-sequence alignment from a RefSeq
258
- transcript, overlaid the same way InterProScan domains are. The exon model is
259
- fetched from the NCBI Datasets v2 API; each species' Nth exon is named `exon-N`,
260
- so a given exon is the same color in every row and the exon architecture reads
261
- straight down the alignment.
292
+ transcript, overlaid the same way InterProScan domains are. The command fetches
293
+ the exon model from the NCBI Datasets v2 API and names each species' Nth exon
294
+ `exon-N`, so a given exon is the same color in every row and the exon
295
+ architecture reads straight down the alignment.
262
296
 
263
297
  ```bash
264
298
  react-msaview-cli genestructure <input-msa> --gene <symbol> --ref <rowname> [options]
265
299
  ```
266
300
 
267
- The exon boundaries of the chosen transcript are mapped onto the reference row's
268
- columns, then projected into every other row's own ungapped coordinates — so an
269
- exon that picks up a frameshifting indel in one lineage gets shorter on exactly
270
- that row while staying column-aligned with the rest. The reference row must be
271
- the transcript's coding sequence (the CLI warns if its length doesn't match).
301
+ The command maps the chosen transcript's exon boundaries onto the reference
302
+ row's columns, then projects them into every other row's ungapped coordinates.
303
+ An exon that picks up a frameshifting indel in one lineage therefore gets
304
+ shorter on that row and stays in the same columns as the rest. The reference row
305
+ must be the transcript's coding sequence; the CLI warns if its length doesn't
306
+ match.
272
307
 
273
308
  | Option | Description | Default |
274
309
  | --------------------- | --------------------------------------------- | ------------------- |
@@ -289,20 +324,23 @@ react-msaview-cli genestructure aln.fa --transcript NM_000505.4 --ref human
289
324
 
290
325
  ## Input formats
291
326
 
292
- The CLI detects the MSA format from the file:
327
+ The CLI sniffs the format from the file's content, not from its name. `--format`
328
+ (`fasta`, `a3m`, `stockholm`, `clustal`, `emf`) overrides a wrong guess. FASTA
329
+ and A3M share a leading `>`, so the CLI tells them apart heuristically.
293
330
 
294
331
  - **FASTA** (`.fasta`, `.fa`, `.faa`)
295
332
  - **Clustal** (`.clustal`, `.aln`)
296
333
  - **Stockholm** (`.sto`, `.stockholm`)
297
- - **A3M** (`.a3m`) — AlphaFold/ColabFold
298
- - **EMF** (`.emf`) — Ensembl Multi Format
334
+ - **A3M** (`.a3m`), from AlphaFold/ColabFold
335
+ - **EMF** (`.emf`), Ensembl Multi Format
299
336
 
300
337
  ## Annotation output format
301
338
 
302
- The annotation commands write standard GFF3, one `protein_match` line per hit.
303
- `start`/`end` are 1-based positions in the **ungapped** sequence (gaps are
304
- stripped before scanning), and the attributes carry the signature accession,
305
- name, and description:
339
+ The annotation commands write standard GFF3, one line per feature:
340
+ `protein_match` for a domain from `interpro`/`interproscan`, `exon` for a
341
+ segment from `genestructure`. `start`/`end` are 1-based positions in the
342
+ **ungapped** sequence, and the attributes carry the accession, name, and
343
+ description:
306
344
 
307
345
  ```gff
308
346
  ##gff-version 3
@@ -318,9 +356,8 @@ $ react-msaview-cli interproscan gpcrs.fasta -o domains.gff --docker
318
356
  Reading MSA from gpcrs.fasta...
319
357
  Found 4 sequences
320
358
  Processing 4 non-empty sequences...
321
- Running InterProScan via Docker...
322
- Running InterProScan via Docker on 4 sequences (image: interpro/interproscan:latest)...
323
- docker run --rm -v /tmp/interproscan-Xyz12:/data interpro/interproscan:latest -i /data/input.fasta -o /data/output.json -f JSON -appl PfamA,CDD
359
+ Running InterProScan via Docker on 4 sequences...
360
+ docker run --rm -v /tmp/interproscan-Xyz12:/data -v /opt/interproscan-5.78-109.0/data:/opt/interproscan/data interpro/interproscan:5.78-109.0 -i /data/input.fasta -o /data/output.json -f JSON -appl Pfam,CDD
324
361
  Converting results to GFF...
325
362
  Writing output to domains.gff...
326
363
  Done!
@@ -328,12 +365,12 @@ Done!
328
365
 
329
366
  ## Using the GFF elsewhere
330
367
 
331
- The same file the CLI writes loads into every other front end.
368
+ The web viewer, the React component and the R package all load the file the CLI
369
+ writes.
332
370
 
333
371
  In the web viewer, select it in the import form's **Annotation GFF file or URL**
334
- field. (The **Annotations > Open InterProScan results...** menu item takes
335
- InterProScan JSON rather than GFF, so use the import form for the file generated
336
- above.)
372
+ field, or open it over a loaded alignment with **Annotations > Open annotation
373
+ file...**, which also accepts the JSON an InterProScan run returns.
337
374
 
338
375
  In the React component, pass it inline as the `gff` prop:
339
376
 
@@ -349,9 +386,10 @@ msaview(msa = "alignment.fasta", gff = "domains.gff")
349
386
 
350
387
  ## Troubleshooting
351
388
 
352
- **EBI API timeout.** Use `--local`, `--docker`, or `--singularity` to run
353
- InterProScan yourself. For large datasets those are much faster than the API
354
- regardless.
389
+ **EBI API timeout.** We measured one sequence waiting fifteen minutes in the
390
+ queue. The CLI waits an hour per job and keeps the results of the sequences that
391
+ finished. Use `--local`, `--docker`, or `--singularity` to run InterProScan
392
+ yourself; on large datasets they are much faster than the API.
355
393
 
356
394
  **Local InterProScan not found.**
357
395
 
@@ -367,8 +405,9 @@ nucleotide; try other `--programs`; verify the input parses as one of the
367
405
  formats above.
368
406
 
369
407
  **The exported figure is enormous.** `export-svg` draws the whole alignment at
370
- `--col-width` per column. Drop `--col-width` until it fits — below ~8px the
371
- residue letters stop drawing, which is most of the file size.
408
+ `--col-width` per column. Lower `--col-width` until it fits. Below 5px, or below
409
+ half the row height, the residue letters stop drawing, and they account for most
410
+ of the file size.
372
411
 
373
412
  ## Uses
374
413