@jbrowse/plugin-linear-genome-view 5.0.0-beta.13 → 5.0.0-beta.16

package/esm/LinearGenomeView/rExport/exportLinearView.d.ts

@@ -0,0 +1,13 @@
+import type { LinearGenomeViewModel } from '../model.ts';
+/** The R script that redraws the tracks open in the view, over its visible regions. */
+export declare function exportLinearViewToR(view: LinearGenomeViewModel, out?: string): {
+    drawn: number;
+    script: undefined;
+    notes: string[];
+} | {
+    drawn: number;
+    script: string;
+    notes: string[];
+};
+/** Downloads the view's R script, telling the user what it leaves out. */
+export declare function downloadRScript(view: LinearGenomeViewModel): Promise<void>;

package/esm/LinearGenomeView/rExport/exportLinearView.js

@@ -0,0 +1,98 @@
+import { fullConfSnapshot, readConfObject } from '@jbrowse/core/configuration';
+import { getSession } from '@jbrowse/core/util';
+import { getSnapshot } from '@jbrowse/mobx-state-tree';
+import { exportTracksToR } from './rScript.js';
+function trackConf(track) {
+    return track.configuration;
+}
+/** The regions on screen, each displayed region cut to what the view shows of it. */
+function viewRegions(view) {
+    const blocks = view.dynamicBlocks.contentBlocks;
+    if (blocks.length === 0) {
+        return view.displayedRegions.map(r => ({
+            refName: r.refName,
+            start: Math.floor(r.start),
+            end: Math.ceil(r.end),
+        }));
+    }
+    const byRegion = new Map();
+    for (const block of blocks) {
+        const key = block.displayedRegionIndex ?? -1;
+        const held = byRegion.get(key);
+        if (held?.refName === block.refName) {
+            held.start = Math.min(held.start, Math.floor(block.start));
+            held.end = Math.max(held.end, Math.ceil(block.end));
+        }
+        else {
+            byRegion.set(key, {
+                refName: block.refName,
+                start: Math.floor(block.start),
+                end: Math.ceil(block.end),
+            });
+        }
+    }
+    return [...byRegion.values()];
+}
+/** The view's assembly config as written. */
+function assemblyOf(view) {
+    const name = view.assemblyNames[0];
+    const configuration = name
+        ? getSession(view).assemblyManager.get(name)?.configuration
+        : undefined;
+    return configuration
+        ? getSnapshot(configuration)
+        : undefined;
+}
+function tracksOf(view) {
+    const tracks = [];
+    for (const track of view.tracks) {
+        const display = track.displays[0];
+        if (display) {
+            const { type, displayId, ...written } = getSnapshot(display.configuration);
+            const { heightMode, height } = fullConfSnapshot(display.configuration);
+            tracks.push({
+                trackId: track.configuration.trackId,
+                trackName: readConfObject(trackConf(track), 'name') ||
+                    track.configuration.trackId,
+                displayType: display.type,
+                adapter: readConfObject(trackConf(track), 'adapter'),
+                display: written,
+                heightMode,
+                height,
+            });
+        }
+    }
+    return tracks;
+}
+/** The R script that redraws the tracks open in the view, over its visible regions. */
+export function exportLinearViewToR(view, out) {
+    return exportTracksToR({
+        tracks: tracksOf(view),
+        regions: viewRegions(view),
+        assembly: assemblyOf(view),
+        bpPerPx: view.bpPerPx,
+        out,
+        notes: view.displayedRegions.some(r => r.reversed)
+            ? ['view: shown right to left, where the figure runs left to right']
+            : [],
+    });
+}
+/** Downloads the view's R script, telling the user what it leaves out. */
+export async function downloadRScript(view) {
+    const session = getSession(view);
+    try {
+        const { saveAs } = await import('@jbrowse/core/util/FileSaver');
+        const { script, notes } = exportLinearViewToR(view);
+        if (!script) {
+            session.notify(`No open track has an R export. ${notes.join('; ')}`, 'warning');
+            return;
+        }
+        saveAs(new Blob([script], { type: 'text/plain;charset=utf-8' }), 'jbrowse_view.R');
+        if (notes.length) {
+            session.notify(`Exported with ${notes.length} note${notes.length === 1 ? '' : 's'} in the script header`, 'info');
+        }
+    }
+    catch (e) {
+        session.notifyError(`${e}`, e);
+    }
+}

package/esm/LinearGenomeView/rExport/rScript.d.ts

@@ -0,0 +1,75 @@
+/** A view's region, 0-based half-open, on the assembly's canonical contig. */
+export interface Region {
+    refName: string;
+    start: number;
+    end: number;
+}
+export interface RExportTrack {
+    trackId: string;
+    trackName: string;
+    displayType: string;
+    adapter: Record<string, unknown>;
+    /** The display's config as written, its defaults left out, which the engine fills from the same schema. */
+    display: Record<string, unknown>;
+    /** The display's resolved sizing, which a feature track exports so the figure drops what the view drops. */
+    heightMode?: unknown;
+    height?: unknown;
+}
+/** The ggjbrowse release whose readers and `jbrowse_stack` the script calls. */
+export declare const GGJBROWSE_VERSION = "0.10.0";
+/**
+ * A resolved config writes an unset slot as `''`, `[]` or `{}`, which a reader
+ * would take for a setting. Keeps `false` and `0`, which are values.
+ */
+export declare function withoutUnset(value: unknown): unknown;
+export declare function rStr(s: string): string;
+/**
+ * A config value as the R literal ggjbrowse hands the engine: a `list` per
+ * object, `c()` per vector of scalars, `list()` per vector of objects and per
+ * empty vector, which jsonlite would otherwise write as `{}`.
+ */
+export declare function rValue(value: unknown): string;
+/**
+ * The path or URL a JBrowse file location points at, as R opens it: a `uri`
+ * resolved against its `baseUri` as the browser's fetch resolved it, a
+ * `file://` URL as its path, or a `localPath`.
+ */
+export declare function locationPath(location: unknown): string | undefined;
+/**
+ * The view's assembly as the R value every reader takes: `jbrowse_assembly()`
+ * of its sequence and alias files where ggjbrowse builds the same config from
+ * their paths, and otherwise the config itself, its locations paths R opens.
+ */
+export declare function assemblyArgument(snapshot: Record<string, unknown>): {
+    value: string;
+} | {
+    skipped: string;
+};
+/** A region as JBrowse's location box writes it, 1-based and inclusive. */
+export declare function locusOf(refName: string, start: number, end: number): string;
+/**
+ * One R script for a view's tracks over its regions: a ggjbrowse reader per
+ * track, reading each as its display does, then `jbrowse_stack()` drawing
+ * them as the view stacks them. A track ggjbrowse cannot read lands in the
+ * header instead of stopping the figure: a script that quietly differs from
+ * its view says so.
+ */
+export declare function exportTracksToR({ tracks, regions, assembly: assemblySnapshot, bpPerPx, out, notes: viewNotes, }: {
+    tracks: readonly RExportTrack[];
+    regions: readonly Region[];
+    /** The view's assembly config as written, which names its sequence and its contigs' aliases. */
+    assembly?: Record<string, unknown>;
+    /** The view's zoom, which decides what a feature or quantitative display shows. */
+    bpPerPx?: number;
+    out?: string;
+    /** What the caller knows of the view that the figure does not show. */
+    notes?: readonly string[];
+}): {
+    drawn: number;
+    script: undefined;
+    notes: string[];
+} | {
+    drawn: number;
+    script: string;
+    notes: string[];
+};

package/esm/LinearGenomeView/rExport/rScript.js

@@ -0,0 +1,465 @@
+import { expandAssemblySequence, expandSidecarShorthand, refNameAliasAdapterType, } from '@jbrowse/core/assemblyManager/expandAssemblyConfigShorthand';
+import { resolveUri } from '@jbrowse/core/util';
+/**
+ * Each display ggjbrowse reads, by the reader that reads it, and the adapters
+ * it opens (the slot holding the file and the extension the reader knows it
+ * by).
+ */
+const READERS = {
+    LinearBasicDisplay: {
+        call: 'jbrowse_features',
+        adapters: {
+            Gff3TabixAdapter: { slot: 'gffGzLocation', ext: /\.gff3?\.gz$/ },
+            Gff3Adapter: { slot: 'gffLocation', ext: /\.gff3?$/ },
+            GtfTabixAdapter: { slot: 'gtfGzLocation', ext: /\.gtf\.gz$/ },
+            GtfAdapter: { slot: 'gtfLocation', ext: /\.gtf$/ },
+            BedTabixAdapter: { slot: 'bedGzLocation', ext: /\.bed\.gz$/ },
+            BedAdapter: { slot: 'bedLocation', ext: /\.bed$/ },
+            BigBedAdapter: { slot: 'bigBedLocation', ext: /\.(bb|bigbed)$/ },
+        },
+    },
+    LinearVariantDisplay: {
+        call: 'jbrowse_features',
+        adapters: {
+            VcfTabixAdapter: { slot: 'vcfGzLocation', ext: /\.vcf\.gz$/ },
+            VcfAdapter: { slot: 'vcfLocation', ext: /\.vcf$/ },
+        },
+    },
+    LinearMultiSampleVariantDisplay: {
+        call: 'jbrowse_variants',
+        adapters: {
+            VcfTabixAdapter: { slot: 'vcfGzLocation', ext: /\.vcf\.gz$/ },
+            VcfAdapter: { slot: 'vcfLocation', ext: /\.vcf$/ },
+        },
+    },
+    LinearWiggleDisplay: {
+        call: 'jbrowse_wiggle',
+        adapters: {
+            BigWigAdapter: { slot: 'bigWigLocation', ext: /$/ },
+            MultiWiggleAdapter: {},
+        },
+    },
+    LinearAlignmentsDisplay: {
+        call: 'jbrowse_alignments',
+        adapters: {
+            BamAdapter: { slot: 'bamLocation', ext: /(?<!\.cram)$/ },
+            CramAdapter: { slot: 'cramLocation', ext: /\.cram$/ },
+        },
+    },
+};
+/** The ggjbrowse release whose readers and `jbrowse_stack` the script calls. */
+export const GGJBROWSE_VERSION = '0.10.0';
+const INSTALL = 'remotes::install_github("GMOD/ggjbrowse")';
+function isSet(value) {
+    return !(value === undefined ||
+        value === null ||
+        value === '' ||
+        (Array.isArray(value) && value.length === 0) ||
+        (typeof value === 'object' &&
+            !Array.isArray(value) &&
+            Object.keys(value).length === 0));
+}
+/**
+ * A resolved config writes an unset slot as `''`, `[]` or `{}`, which a reader
+ * would take for a setting. Keeps `false` and `0`, which are values.
+ */
+export function withoutUnset(value) {
+    if (Array.isArray(value)) {
+        return value.map(withoutUnset);
+    }
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .map(([k, v]) => [k, withoutUnset(v)])
+            .filter(([, v]) => isSet(v)));
+    }
+    return value;
+}
+export function rStr(s) {
+    return JSON.stringify(s);
+}
+const RESERVED = new Set([
+    'if',
+    'else',
+    'repeat',
+    'while',
+    'function',
+    'for',
+    'next',
+    'break',
+    'in',
+    'TRUE',
+    'FALSE',
+    'NULL',
+    'Inf',
+    'NaN',
+    'NA',
+]);
+function isIdentifier(s) {
+    return /^[A-Za-z.][A-Za-z0-9._]*$/.test(s) && !RESERVED.has(s);
+}
+/**
+ * A config value as the R literal ggjbrowse hands the engine: a `list` per
+ * object, `c()` per vector of scalars, `list()` per vector of objects and per
+ * empty vector, which jsonlite would otherwise write as `{}`.
+ */
+export function rValue(value) {
+    if (value === null || value === undefined) {
+        return 'NULL';
+    }
+    if (typeof value === 'string') {
+        return rStr(value);
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return typeof value === 'number' ? String(value) : value ? 'TRUE' : 'FALSE';
+    }
+    if (Array.isArray(value)) {
+        const items = value.map(rValue).join(', ');
+        return value.length && value.every(v => typeof v !== 'object')
+            ? `c(${items})`
+            : `list(${items})`;
+    }
+    return `list(${Object.entries(value)
+        .map(([k, v]) => `${isIdentifier(k) ? k : rStr(k)} = ${rValue(v)}`)
+        .join(', ')})`;
+}
+/**
+ * The path or URL a JBrowse file location points at, as R opens it: a `uri`
+ * resolved against its `baseUri` as the browser's fetch resolved it, a
+ * `file://` URL as its path, or a `localPath`.
+ */
+export function locationPath(location) {
+    const loc = location;
+    if (!loc?.uri) {
+        return loc?.localPath;
+    }
+    const resolved = resolveUri({ uri: loc.uri, baseUri: loc.baseUri });
+    return resolved.startsWith('file://')
+        ? decodeURIComponent(new URL(resolved).pathname)
+        : resolved;
+}
+function isLocation(v) {
+    return (typeof v === 'object' &&
+        v !== null &&
+        !Array.isArray(v) &&
+        (typeof v.uri === 'string' ||
+            typeof v.localPath === 'string'));
+}
+/** An adapter config with each location a path or URL R opens, each path also pushed onto `uris`. */
+function openable(value, uris) {
+    if (isLocation(value)) {
+        const uri = locationPath(value);
+        if (uri) {
+            uris.push(uri);
+        }
+        return { uri };
+    }
+    if (Array.isArray(value)) {
+        return value.map(v => openable(v, uris));
+    }
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, openable(v, uris)]));
+    }
+    return value;
+}
+/**
+ * The file argument of a track's reader: its path where ggjbrowse would choose
+ * the track's adapter for it from the extension, and the adapter config itself
+ * where the adapter carries a setting or the name hides its format, so every
+ * setting reaches the engine as the browser has it.
+ */
+function fileArgument(adapters, adapter) {
+    const type = String(adapter.type);
+    const known = adapters[type];
+    if (!known) {
+        return { skipped: `${type} has no R reader for this display` };
+    }
+    const uris = [];
+    const located = withoutUnset(openable(adapter, uris));
+    if (uris.length === 0) {
+        return { skipped: `${type} names no file` };
+    }
+    if (uris.some(u => u.startsWith('blob:'))) {
+        return {
+            skipped: 'it reads a file opened in the browser, which R cannot reach',
+        };
+    }
+    const file = known.slot
+        ? (locationPath(adapter[known.slot]) ??
+            (typeof adapter.uri === 'string' ? adapter.uri : undefined))
+        : undefined;
+    const index = adapter.index;
+    const indexPath = locationPath(index?.location) ?? locationPath(adapter.craiLocation);
+    const besideSuffix = type === 'CramAdapter' ? '.crai' : type === 'BamAdapter' ? '.bai' : '.tbi';
+    const plainSlots = new Set([
+        'type',
+        'uri',
+        'index',
+        'craiLocation',
+        known.slot,
+    ]);
+    const plain = file !== undefined &&
+        known.ext?.test(file.replace(/\?.*$/, '').toLowerCase()) &&
+        Object.keys(located).every(k => plainSlots.has(k)) &&
+        Object.keys(index ?? {}).every(k => k === 'location' || k === 'indexType') &&
+        (index?.indexType === 'CSI') === !!indexPath?.endsWith('.csi');
+    return plain
+        ? {
+            file: rStr(file),
+            index: indexPath && indexPath !== `${file}${besideSuffix}`
+                ? indexPath
+                : undefined,
+            uris,
+        }
+        : { file: rValue(located), uris };
+}
+/**
+ * Each sequence adapter `jbrowse_assembly()` builds from a path, by the
+ * extension ggjbrowse reads it off, and the index each takes beside it.
+ */
+const SEQUENCE_ADAPTERS = {
+    TwoBitAdapter: { slot: 'twoBitLocation', ext: /\.2bit$/, beside: {} },
+    BgzipFastaAdapter: {
+        slot: 'fastaLocation',
+        ext: /\.gz$/,
+        beside: { faiLocation: '.fai', gziLocation: '.gzi' },
+    },
+    IndexedFastaAdapter: {
+        slot: 'fastaLocation',
+        ext: /^(?!.*\.(2bit|gz)$)/,
+        beside: { faiLocation: '.fai' },
+    },
+};
+/** The path of a sequence adapter `jbrowse_assembly()` rebuilds from that path alone. */
+function plainSequence(adapter) {
+    const { type, uri, baseUri, ...slots } = adapter;
+    if (type === undefined && typeof uri === 'string') {
+        return Object.keys(slots).length
+            ? undefined
+            : locationPath({ uri, baseUri });
+    }
+    const known = SEQUENCE_ADAPTERS[String(type)];
+    const file = known && uri === undefined && locationPath(slots[known.slot]);
+    return file &&
+        known.ext.test(file.replace(/\?.*$/, '').toLowerCase()) &&
+        Object.entries(slots).every(([k, v]) => k === known.slot ||
+            (known.beside[k] !== undefined &&
+                locationPath(v) === `${file}${known.beside[k]}`))
+        ? file
+        : undefined;
+}
+/** The path of an alias adapter ggjbrowse reads as that path alone. */
+function plainAliases(adapter) {
+    const { type, uri, baseUri, location, ...rest } = adapter;
+    const file = typeof uri === 'string'
+        ? locationPath({ uri, baseUri })
+        : locationPath(location);
+    return file &&
+        Object.keys(rest).length === 0 &&
+        type === refNameAliasAdapterType(file)
+        ? file
+        : undefined;
+}
+/**
+ * The view's assembly as the R value every reader takes: `jbrowse_assembly()`
+ * of its sequence and alias files where ggjbrowse builds the same config from
+ * their paths, and otherwise the config itself, its locations paths R opens.
+ */
+export function assemblyArgument(snapshot) {
+    const config = expandAssemblySequence(snapshot);
+    const name = String(config.name);
+    const sequence = withoutUnset(config.sequence?.adapter);
+    if (!sequence) {
+        return { skipped: 'the assembly names no sequence' };
+    }
+    const aliasConfig = config.refNameAliases;
+    const aliases = aliasConfig
+        ? withoutUnset(expandSidecarShorthand(aliasConfig, refNameAliasAdapterType).adapter)
+        : undefined;
+    const uris = [];
+    const located = {
+        name,
+        sequence: { adapter: openable(sequence, uris) },
+        ...(aliases
+            ? { refNameAliases: { adapter: openable(aliases, uris) } }
+            : {}),
+    };
+    if (uris.some(u => u.startsWith('blob:'))) {
+        return {
+            skipped: 'the assembly reads a file opened in the browser, which R cannot reach',
+        };
+    }
+    const sequenceFile = plainSequence(sequence);
+    const aliasFile = aliases && plainAliases(aliases);
+    return sequenceFile && (!aliases || aliasFile)
+        ? {
+            value: `jbrowse_assembly(${[
+                rStr(sequenceFile),
+                ...(aliasFile ? [rStr(aliasFile)] : []),
+                `name = ${rStr(name)}`,
+            ].join(', ')})`,
+        }
+        : { value: rValue(located) };
+}
+/** A region as JBrowse's location box writes it, 1-based and inclusive. */
+export function locusOf(refName, start, end) {
+    const n = (x) => Math.round(x).toLocaleString('en-US');
+    return `${refName}:${n(start + 1)}-${n(end)}`;
+}
+function lociLiteral(loci) {
+    return loci.length === 1
+        ? rStr(loci[0])
+        : `c(${loci.map(l => rStr(l)).join(', ')})`;
+}
+/** An R-safe name per track id, unique within the script. */
+function trackNames(tracks) {
+    const taken = new Set(['locus', 'width', 'assembly', 'fig']);
+    return tracks.map(track => {
+        let base = track.trackId
+            .replaceAll(/[^a-zA-Z0-9]/g, '_')
+            .replace(/^(?=[\d_])/, 'x');
+        if (!isIdentifier(base)) {
+            base = `${base}_track`;
+        }
+        let name = base;
+        for (let n = 2; taken.has(name); n++) {
+            name = `${base}_${n}`;
+        }
+        taken.add(name);
+        return name;
+    });
+}
+/** What the figure cannot show of a track whose settings ggjbrowse reads. */
+function settingNotes(track) {
+    const color = track.display.color;
+    return [
+        ...(color?.field === 'mateRefName'
+            ? [
+                'color: mateRefName colors each contig by its hash, where the browser orders them by the assembly',
+            ]
+            : []),
+    ];
+}
+/**
+ * One R script for a view's tracks over its regions: a ggjbrowse reader per
+ * track, reading each as its display does, then `jbrowse_stack()` drawing
+ * them as the view stacks them. A track ggjbrowse cannot read lands in the
+ * header instead of stopping the figure: a script that quietly differs from
+ * its view says so.
+ */
+export function exportTracksToR({ tracks, regions, assembly: assemblySnapshot, bpPerPx, out = 'figure.png', notes: viewNotes = [], }) {
+    const notes = [...viewNotes];
+    const assembly = assemblySnapshot && assemblyArgument(assemblySnapshot);
+    if (assembly && 'skipped' in assembly) {
+        notes.push(`assembly: ${assembly.skipped}`);
+    }
+    const assemblyValue = assembly && 'value' in assembly ? assembly.value : undefined;
+    const loci = regions.map(r => locusOf(r.refName, r.start, r.end));
+    const totalBp = regions.reduce((sum, r) => sum + r.end - r.start, 0);
+    const viewPx = bpPerPx ? Math.round(totalBp / bpPerPx) : undefined;
+    const widthReaders = [];
+    const names = trackNames(tracks);
+    const reads = [];
+    const drawn = [];
+    let alignments;
+    tracks.forEach((track, i) => {
+        const reader = READERS[track.displayType];
+        if (!reader) {
+            notes.push(`${track.trackName}: ${track.displayType} has no R reader in ggjbrowse yet`);
+            return;
+        }
+        const source = fileArgument(reader.adapters, track.adapter);
+        if ('skipped' in source) {
+            notes.push(`${track.trackName}: ${source.skipped}`);
+            return;
+        }
+        const { heightMode, height } = track;
+        const display = reader.call === 'jbrowse_features'
+            ? {
+                ...track.display,
+                ...(heightMode === undefined ? {} : { heightMode }),
+                ...(height === undefined ? {} : { height }),
+            }
+            : track.display;
+        const width = viewPx !== undefined;
+        const args = [
+            ...(Object.keys(display).length ? [`display = ${rValue(display)}`] : []),
+            ...(width ? ['width = width'] : []),
+            ...(assemblyValue ? ['assembly = assembly'] : []),
+            ...(source.index ? [`index = ${rStr(source.index)}`] : []),
+        ];
+        const name = names[i];
+        if (width) {
+            widthReaders.push(name);
+        }
+        reads.push([
+            `# ${track.trackName}`,
+            `${name} <- ${reader.call}(${source.file},`,
+            `  ${['locus', ...args].join(',\n  ')})`,
+        ].join('\n'));
+        drawn.push(name);
+        if (reader.call === 'jbrowse_alignments') {
+            alignments ??= name;
+        }
+        notes.push(...[
+            ...(source.uris.some(u => u.includes('://') && u.includes('?'))
+                ? [
+                    'source: a URL carries its query string, credential included, so the script is not one to share',
+                ]
+                : []),
+            ...settingNotes(track),
+        ].map(n => `${track.trackName}: ${n}`));
+    });
+    if (drawn.length === 0) {
+        return { drawn: 0, script: undefined, notes };
+    }
+    const script = [
+        "# Generated by JBrowse 2: the view's tracks, read by ggjbrowse, JBrowse's",
+        '# own engine in R, and drawn as the view stacks them.',
+        `# Install ggjbrowse with ${INSTALL}`,
+        '#',
+        '# Each reader returns the tables its track draws; jbrowse_stack() draws',
+        '# them. Restyle every band with &, or draw one alone and add to it:',
+        '#   fig & ggplot2::theme_classic()',
+        `#   ${alignments ? `autoplot(${alignments}, "pileup")` : `autoplot(${drawn[0]})`} + ggplot2::theme_classic()`,
+        ...(notes.length
+            ? [
+                '#',
+                '# What this figure does not show:',
+                ...notes.map(n => `#   - ${n}`),
+            ]
+            : []),
+        '',
+        'if (',
+        '  !requireNamespace("ggjbrowse", quietly = TRUE) ||',
+        `    packageVersion("ggjbrowse") < ${rStr(GGJBROWSE_VERSION)}`,
+        ') {',
+        `  stop("this script needs ggjbrowse ${GGJBROWSE_VERSION} or later: ${INSTALL.replaceAll('"', '\\"')}")`,
+        '}',
+        'library(ggjbrowse)',
+        '',
+        `locus <- ${lociLiteral(loci)}`,
+        ...(assemblyValue
+            ? [
+                "# The view's assembly: the reference every reader reads against, and",
+                '# the aliases that name each contig as each file spells it.',
+                `assembly <- ${assemblyValue}`,
+            ]
+            : []),
+        ...(widthReaders.length
+            ? [
+                "# The view's pixels across its regions. A smaller number lays the tracks",
+                '# out as a narrower browser window would, for a narrower figure with',
+                '# fewer labels at the same size.',
+                `width <- ${viewPx}`,
+            ]
+            : []),
+        '',
+        reads.join('\n\n'),
+        '',
+        `fig <- jbrowse_stack(${drawn.join(', ')})`,
+        'print(fig)',
+        `ggplot2::ggsave(${rStr(out)}, fig, width = jbrowse_width(fig), height = jbrowse_height(fig))`,
+        '',
+    ].join('\n');
+    return { drawn: drawn.length, script, notes };
+}

package/esm/LinearGenomeView/svgcomponents/SVGLinearGenomeView.js

@@ -27,8 +27,8 @@ export async function renderToSvg(model, opts) {
     textHeight = defaultTextHeight(fontSize), rulerHeight = 34, trackLabels = 'offset', themeName, fontFamily, showGridlines = false, Wrapper, } = opts;
     const session = getSession(model);
     const theme = session.getActiveThemeOptions?.(themeName);
-    // owns the two orderings this used to spell out by hand: legendWidth before
-    // the awaits, tracksHeight after them. Every display's `renderSvg` owns its
+    // owns the ordering this used to spell out by hand: the stack's height and
+    // legend gutter measured after the awaits. Every display's `renderSvg` owns its
     // own readiness wait — an LGV display through `renderDisplaySvg`'s
     // `awaitSvgReady`, a non-LGV one (dotplot, synteny, circular) by calling that
     // itself.
@@ -38,9 +38,6 @@ export async function renderToSvg(model, opts) {
         theme,
         textHeight,
         trackLabels,
-        // the standalone export is the one with room to give: it widens its
-        // canvas below so a legend sits beside the plot rather than over it
-        reserveLegendWidth: true,
     });
     notifySkippedSvgTracks(session, skippedTracks);
     // read after the displays' waits, and handed to SVGHeader rather than read
@@ -72,6 +69,6 @@ export async function renderToSvg(model, opts) {
                 // header is the full one: cytoband overview and total-bp scalebar as
                 // well as the assembly name and ruler. `tracksTop` is the height
                 // getHeaderLayout gave it.
-                header: _jsx(SVGHeader, { model: model, fontSize: fontSize, rulerHeight: rulerHeight, layout: headerLayout, showCytobands: effectiveShowCytobands }), fontSize: fontSize, textHeight: textHeight, trackLabels: trackLabels, trackLabelOffset: trackLabelOffset, contentTop: tracksTop, tracksHeight: tracksHeight, showGridlines: showGridlines, leftBuffer: exportMargin, legendWidth: legendWidth }) })),
+                header: _jsx(SVGHeader, { model: model, fontSize: fontSize, rulerHeight: rulerHeight, layout: headerLayout, showCytobands: effectiveShowCytobands }), fontSize: fontSize, textHeight: textHeight, trackLabels: trackLabels, trackLabelOffset: trackLabelOffset, contentTop: tracksTop, tracksHeight: tracksHeight, showGridlines: showGridlines, leftBuffer: exportMargin }) })),
     });
 }