@jbrowse/core 4.3.0 → 5.0.0-beta.2

package/esm/pluggableElementTypes/models/migrateTrackConfig.js

@@ -0,0 +1,54 @@
+// Back-compat migration for track config snapshots. Kept out of
+// baseTrackConfig.ts so the schema definition stays free of legacy-format
+// handling.
+// #endregion
+// Registers a back-compat migration for a display's CONFIG snapshot that runs
+// BEFORE the display `types.union` validates it.
+//
+// Use this — NOT a config-schema `preProcessSnapshot` — whenever the migration
+// rewrites the VALUE of an existing constrained slot (enum rename, type narrow).
+// A config-schema `preProcessSnapshot` does not run during union validation
+// (the union tests the raw snapshot), so the union rejects the legacy value
+// first and the migration never fires. A slot add/remove/rename, where the old
+// data becomes an unknown extra prop, does NOT need this — the union ignores
+// unknown props, so a config-schema `preProcessSnapshot` is fine there.
+//
+// Pass every type name the display answers to (canonical + aliases); this runs
+// before alias normalization. `migrate` must be idempotent (it also fires via
+// the config-schema `preProcessSnapshot` on a direct create).
+export function addDisplayConfigMigration(pluginManager, displayTypes, migrate) {
+    const match = new Set(displayTypes);
+    const matches = (d) => typeof d.type === 'string' && match.has(d.type);
+    pluginManager.addToExtensionPoint('Core-preProcessTrackConfig', snap => {
+        const { displays } = snap;
+        return Array.isArray(displays) && displays.some(matches)
+            ? {
+                ...snap,
+                displays: displays.map(d => (matches(d) ? migrate(d) : d)),
+            }
+            : snap;
+    });
+}
+// The GPU rewrite removed the per-display `renderer` sub-config (which carried
+// color/height/etc.). Old configs still nest those values under `renderer`, so
+// lift the renderer's props up onto the display, with `renderer.height`
+// becoming the display's `featureHeight`. Also injects the `${trackId}-${type}`
+// displayId fallback for displays that predate the identifier.
+export function liftLegacyRendererConfig(d, trackId) {
+    const displayId = d.displayId ?? `${trackId}-${d.type}`;
+    const { renderer, ...rest } = d;
+    if (renderer) {
+        const { type: _rendererType, height: rendererHeight, ...rendererProps } = renderer;
+        return {
+            ...rendererProps,
+            ...(rendererHeight !== undefined
+                ? { featureHeight: rendererHeight }
+                : undefined),
+            ...rest,
+            displayId,
+        };
+    }
+    else {
+        return { ...rest, displayId };
+    }
+}

package/esm/pluggableElementTypes/models/saveTrackFileTypes/bed.js

@@ -1,12 +1,80 @@
+import { formatStrand } from './util.js';
+// name is the only free-text column, and a space or tab in it shifts every
+// column after it
+function formatName(name) {
+    const str = name === undefined || name === null ? '' : `${name}`.trim();
+    return str ? str.replaceAll(/\s+/g, '_') : '.';
+}
+function extent(feats) {
+    return {
+        start: Math.min(...feats.map(f => f.get('start'))),
+        end: Math.max(...feats.map(f => f.get('end'))),
+    };
+}
+// A gene arrives as gene -> mRNA -> exon/CDS, and BED has one line per
+// transcript rather than a nesting: descend to the level that owns exons (or
+// bare CDS), and emit that. A feature with no such children is its own single
+// block, which is what a flat BED/bigBed feature already was.
+function collectRows(feature) {
+    const subfeatures = feature.get('subfeatures') ?? [];
+    const exons = subfeatures.filter(f => f.get('type') === 'exon');
+    const cds = subfeatures.filter(f => f.get('type') === 'CDS');
+    if (exons.length === 0 && cds.length === 0 && subfeatures.length > 0) {
+        return subfeatures.flatMap(f => collectRows(f));
+    }
+    const segments = exons.length > 0 ? exons : cds;
+    const blocks = (segments.length > 0 ? segments : [feature])
+        .map(f => ({ start: f.get('start'), end: f.get('end') }))
+        .sort((a, b) => a.start - b.start);
+    // the row spans its blocks, not the parent's own bounds: blockStarts are
+    // relative to chromStart and the last block has to end at chromEnd
+    const start = blocks[0].start;
+    const end = Math.max(...blocks.map(b => b.end));
+    // the CDS extent is the thick part; a non-coding row marks that with an empty
+    // thick range at chromStart, per the spec
+    const cdsExtent = cds.length > 0 ? extent(cds) : undefined;
+    const thick = cdsExtent
+        ? {
+            start: Math.max(start, cdsExtent.start),
+            end: Math.min(end, cdsExtent.end),
+        }
+        : { start, end: start };
+    return [
+        {
+            refName: feature.get('refName'),
+            start,
+            end,
+            name: formatName(feature.get('name') ?? feature.get('id')),
+            // BED score is numeric (0-1000); the bedGraph writer makes the same
+            // choice for a feature with no score
+            score: feature.get('score') ?? 0,
+            strand: feature.get('strand') ?? 0,
+            thickStart: thick.start,
+            thickEnd: thick.end,
+            blocks,
+        },
+    ];
+}
+function formatRow(row, bed12) {
+    const { refName, start, end, name, score, strand, blocks } = row;
+    const cols = [
+        refName,
+        start,
+        end,
+        name,
+        score,
+        formatStrand(strand),
+    ];
+    if (bed12) {
+        cols.push(row.thickStart, row.thickEnd, '0', blocks.length, `${blocks.map(b => b.end - b.start).join(',')},`, `${blocks.map(b => b.start - start).join(',')},`);
+    }
+    return cols.join('\t');
+}
 export function stringifyBED({ features }) {
     if (features.length === 0) {
         return '';
     }
-    const fields = ['refName', 'start', 'end', 'name', 'score', 'strand'];
-    return `${features
-        .map(feature => fields
-        .map(field => feature.get(field) ?? '.')
-        .join('\t')
-        .trim())
-        .join('\n')}\n`;
+    const rows = features.flatMap(f => collectRows(f));
+    const bed12 = rows.some(row => row.blocks.length > 1 || row.thickStart !== row.thickEnd);
+    return rows.map(row => formatRow(row, bed12)).join('\n');
 }

package/esm/pluggableElementTypes/models/saveTrackFileTypes/genbank.d.ts

@@ -1,7 +1,13 @@
-import type { AbstractSessionModel, Feature } from '../../../util/index.ts';
-export declare function formatFeatWithSubfeatures(feature: Feature, min: number, parentId?: string, parentType?: string): string;
-export declare function stringifyGBK({ features, assemblyName, session, }: {
+import type { AbstractSessionModel, Feature, StatusCallback, StopToken } from '../../../util/index.ts';
+export declare function formatFeatWithSubfeatures({ feature, minPos, geneName, }: {
+    feature: Feature;
+    minPos: number;
+    geneName?: string;
+}): string;
+export declare function stringifyGBK({ features, assemblyName, session, stopToken, statusCallback, }: {
     assemblyName: string;
     session: AbstractSessionModel;
     features: Feature[];
+    stopToken?: StopToken;
+    statusCallback?: StatusCallback;
 }): Promise<string>;

package/esm/pluggableElementTypes/models/saveTrackFileTypes/genbank.js

@@ -1,104 +1,90 @@
-import { fetchSequence } from "./fetchSequence.js";
-import { max, min } from "../../../util/index.js";
-const coreFields = new Set([
-    'uniqueId',
-    'id',
-    'refName',
-    'source',
-    'type',
-    'start',
-    'end',
-    'strand',
-    'parent',
-    'parentId',
-    'score',
-    'subfeatures',
-    'phase',
-]);
-const TYPE_COLUMN_WIDTH = 16;
-const blank = '                     ';
-const retitle = {
-    name: 'Name',
-};
-function fmt(obj) {
-    if (obj === null || obj === undefined) {
-        return undefined;
-    }
-    if (Array.isArray(obj)) {
-        const items = obj.map(o => fmt(o)).filter(o => o !== undefined);
-        return items.length > 0 ? items.join(',') : undefined;
-    }
-    if (typeof obj === 'object') {
-        return JSON.stringify(obj);
-    }
-    return `${obj}`;
+import { fetchSeq } from '../../../util/fetchSeq.js';
+import { createStatusFanOut, groupBy, max, min } from '../../../util/index.js';
+import { coreFeatureFields, formatAttributeValue } from './util.js';
+// name becomes the /label qualifier rather than one of its own
+const coreFields = new Set([...coreFeatureFields, 'name']);
+// GenBank fixed-column layout: feature keys occupy cols 6-20, locations and
+// qualifiers start at col 22. See https://www.insdc.org/submitting-standards/feature-table/
+const TYPE_COLUMN_WIDTH = 15;
+const QUALIFIER_INDENT = ' '.repeat(21);
+const DATE = '10-JAN-1970';
+// Free-text qualifiers are wrapped in double quotes; literal quotes inside the
+// value are escaped by doubling them, per the GenBank spec.
+function qualifier(key, value) {
+    return `${QUALIFIER_INDENT}/${key}="${value.replaceAll('"', '""')}"`;
+}
+function loc(f, minPos) {
+    const start = f.get('start') - minPos + 1;
+    const end = f.get('end') - minPos;
+    return `${start}..${end}`;
+}
+// Build a (possibly spliced) location expression for a set of segments,
+// e.g. join(1..100,201..300) or complement(join(...)) for the minus strand.
+function joinLoc(feats, strand, minPos) {
+    const locs = feats
+        .toSorted((a, b) => a.get('start') - b.get('start'))
+        .map(f => loc(f, minPos));
+    const expr = locs.length === 1 ? locs.join(',') : `join(${locs.join(',')})`;
+    return strand === -1 ? `complement(${expr})` : expr;
+}
+function featureLine(type, location) {
+    return `     ${type.slice(0, TYPE_COLUMN_WIDTH).padEnd(TYPE_COLUMN_WIDTH)} ${location}`;
 }
-function formatTags(f, parentId, parentType) {
+function formatTags({ feature, gene }) {
     const tags = [];
-    if (parentId && parentType) {
-        tags.push(`${blank}/${parentType}="${parentId}"`);
+    // /gene ties gene/mRNA/CDS together; /label is what SnapGene/Geneious/ApE
+    // display as the feature name on the map
+    if (gene) {
+        tags.push(qualifier('gene', gene));
     }
-    const id = f.get('id');
-    if (id) {
-        tags.push(`${blank}/name="${id}"`);
+    const label = feature.get('name') ?? feature.get('id');
+    if (label) {
+        tags.push(qualifier('label', label));
     }
-    for (const key of Object.keys(f.toJSON())) {
-        if (!coreFields.has(key) && key !== parentType) {
-            const value = fmt(f.get(key));
+    for (const key of Object.keys(feature.toJSON())) {
+        if (!coreFields.has(key)) {
+            const value = formatAttributeValue(feature.get(key));
             if (value) {
-                tags.push(`${blank}/${retitle[key] || key}="${value}"`);
+                tags.push(qualifier(key, value));
             }
         }
     }
     return tags;
 }
-function relativeStart(f, min) {
-    return f.get('start') - min + 1;
-}
-function relativeEnd(f, min) {
-    return f.get('end') - min;
-}
-function loc(f, min) {
-    return `${relativeStart(f, min)}..${relativeEnd(f, min)}`;
-}
-function formatFeat(f, min, parentType, parentId) {
-    const type = `${f.get('type')}`.slice(0, TYPE_COLUMN_WIDTH);
-    const l = loc(f, min);
-    const locstrand = f.get('strand') === -1 ? `complement(${l})` : l;
-    return [
-        `     ${type.padEnd(TYPE_COLUMN_WIDTH)}${locstrand}`,
-        ...formatTags(f, parentType, parentId),
-    ];
-}
-function formatCDS(feats, parentId, parentType, strand, min) {
+function formatCDS({ feats, gene, strand, minPos, }) {
     if (feats.length === 0) {
         return [];
     }
-    const locs = feats.map(f => loc(f, min));
-    const locExpr = locs.length === 1 ? locs[0] : `join(${locs.join(',')})`;
-    const strandExpr = strand === -1 ? `complement(${locExpr})` : locExpr;
     return [
-        `     ${'CDS'.padEnd(TYPE_COLUMN_WIDTH)}${strandExpr}`,
-        `${blank}/${parentType}="${parentId}"`,
+        featureLine('CDS', joinLoc(feats, strand, minPos)),
+        ...(gene ? [qualifier('gene', gene), qualifier('label', gene)] : []),
+        `${QUALIFIER_INDENT}/codon_start=1`,
     ];
 }
-export function formatFeatWithSubfeatures(feature, min, parentId, parentType) {
-    const primary = formatFeat(feature, min, parentId, parentType);
-    const subfeatures = feature.get('subfeatures') || [];
-    const cds = subfeatures
-        .filter(f => f.get('type') === 'CDS')
-        .sort((a, b) => a.get('start') - b.get('start'));
+export function formatFeatWithSubfeatures({ feature, minPos, geneName, }) {
+    const subfeatures = feature.get('subfeatures') ?? [];
+    const strand = feature.get('strand') ?? 0;
+    const type = `${feature.get('type')}`;
+    const exons = subfeatures.filter(f => f.get('type') === 'exon');
+    // A top-level feature with children establishes the gene-group name, which is
+    // threaded down so every part of the gene shares one /gene qualifier.
+    const ownName = feature.get('name') ?? feature.get('id');
+    const gene = geneName ?? (subfeatures.length > 0 && ownName ? ownName : undefined);
+    // A spliced transcript is rendered as join() of its exons rather than a
+    // single span, so external tools see the correct intron/exon structure.
+    const segments = exons.length > 0 ? exons : [feature];
+    const location = joinLoc(segments, strand, minPos);
+    const primary = [
+        featureLine(type, location),
+        ...formatTags({ feature, gene }),
+    ];
+    const cds = subfeatures.filter(f => f.get('type') === 'CDS');
     const sansCDS = subfeatures.filter(f => f.get('type') !== 'CDS' && f.get('type') !== 'exon');
-    const newParentId = feature.get('id');
-    const newParentType = feature.get('type');
-    const newParentStrand = feature.get('strand');
-    const cdsLines = cds.length > 0 && newParentId && newParentType
-        ? formatCDS(cds, newParentId, newParentType, newParentStrand, min)
-        : [];
+    const cdsLines = cds.length > 0 ? formatCDS({ feats: cds, gene, strand, minPos }) : [];
     return [
         ...primary,
         ...cdsLines,
-        ...sansCDS.flatMap(sub => formatFeatWithSubfeatures(sub, min, newParentId, newParentType)),
+        ...sansCDS.flatMap(sub => formatFeatWithSubfeatures({ feature: sub, minPos, geneName: gene })),
     ].join('\n');
 }
 function formatOrigin(sequence) {
@@ -106,34 +92,98 @@ function formatOrigin(sequence) {
     for (let i = 0; i < sequence.length; i += 60) {
         const pos = String(i + 1).padStart(9);
         const chunk = sequence.slice(i, i + 60).toLowerCase();
-        const groups = chunk.match(/.{1,10}/g) || [];
+        const groups = chunk.match(/.{1,10}/g) ?? [];
         lines.push(`${pos} ${groups.join(' ')}`);
     }
     lines.push('//');
     return lines;
 }
-export async function stringifyGBK({ features, assemblyName, session, }) {
-    if (!features.length) {
-        return '';
-    }
-    const date = '10-JAN-1970';
-    const start = min(features.map(f => f.get('start')));
-    const end = max(features.map(f => f.get('end')));
-    const length = end - start;
-    const refName = features[0].get('refName') || '';
-    const l1 = [
+// LOCUS line column layout per the GenBank flat-file spec: name at col 13,
+// length right-justified ending at col 40, molecule/topology/division/date in
+// their fixed slots.
+//
+// The name is the 16-column locus field, so it is the refName rather than the
+// region: `chr17:7,668,402..7,687,550` sanitizes to 22 characters and pushed
+// every field after it 6 columns right, which is a length a positional parser
+// then reads out of the wrong slot. The coordinates are on DEFINITION, where
+// the line is free text.
+const LOCUS_NAME_WIDTH = 16;
+function formatLocus(refName, length) {
+    const name = refName.replaceAll(/[^\w.]/g, '_').slice(0, LOCUS_NAME_WIDTH);
+    return [
         'LOCUS'.padEnd(12),
-        `${refName}:${start + 1}..${end}`.padEnd(20),
-        ` ${length} bp`.padEnd(15),
-        ` ${'DNA'.padEnd(10)}`,
-        'linear'.padEnd(10),
-        `UNK ${date}`,
+        name.padEnd(LOCUS_NAME_WIDTH),
+        ' ',
+        String(length).padStart(11),
+        ' bp ',
+        '   ',
+        'DNA'.padEnd(6),
+        ' ',
+        'linear'.padEnd(9),
+        ' ',
+        'UNK'.padEnd(3),
+        ' ',
+        DATE,
     ].join('');
-    const l2 = 'FEATURES             Location/Qualifiers';
-    const contig = (await fetchSequence({
+}
+// Metadata header plus the whole-sequence `source` feature that every GenBank
+// record carries.
+function formatHeader({ refName, region, assemblyName, length, }) {
+    return [
+        formatLocus(refName, length),
+        `DEFINITION  ${region} from ${assemblyName}.`,
+        `ACCESSION   ${refName}`,
+        `VERSION     ${refName}`,
+        'KEYWORDS    .',
+        `SOURCE      ${assemblyName}`,
+        `  ORGANISM  ${assemblyName}`,
+        '            .',
+        'FEATURES             Location/Qualifiers',
+        featureLine('source', `1..${length}`),
+        qualifier('organism', assemblyName),
+        `${QUALIFIER_INDENT}/mol_type="genomic DNA"`,
+        qualifier('chromosome', refName),
+    ];
+}
+// One LOCUS..ORIGIN..// record, spanning the features on a single reference
+// sequence. GenBank has no way to express a span that crosses one, which is why
+// this takes a refName rather than deriving it.
+async function formatRecord({ refName, features, assemblyName, session, stopToken, statusCallback, }) {
+    const minPos = min(features.map(f => f.get('start')));
+    const maxPos = max(features.map(f => f.get('end')));
+    const length = maxPos - minPos;
+    const region = `${refName}:${minPos + 1}..${maxPos}`;
+    const contig = await fetchSeq({
+        session,
+        assemblyName,
+        start: minPos,
+        end: maxPos,
+        refName,
+        stopToken,
+        statusCallback,
+    });
+    const header = formatHeader({ refName, region, assemblyName, length });
+    const body = features.map(feat => formatFeatWithSubfeatures({ feature: feat, minPos }));
+    return [...header, ...body, ...formatOrigin(contig)].join('\n');
+}
+export async function stringifyGBK({ features, assemblyName, session, stopToken, statusCallback, }) {
+    // A record per reference sequence, which is what GenBank is: a multi-region
+    // view used to take min(start)/max(end) across every feature and label the
+    // result with the first one's refName, so two contigs on screen produced one
+    // record spanning a stretch of sequence that does not exist, with an ORIGIN
+    // fetched over it.
+    const byRefName = groupBy(features, f => f.get('refName'));
+    // the records fetch their ORIGIN concurrently and all report the same phase,
+    // so each gets its own fan-out slot rather than the caller's raw callback —
+    // otherwise the first contig to finish blanks the label for the rest
+    const slot = createStatusFanOut(statusCallback);
+    const records = await Promise.all(Object.entries(byRefName).map(([refName, feats]) => formatRecord({
+        refName,
+        features: feats,
+        assemblyName,
         session,
-        region: { assemblyName, start, end, refName },
-    })) ?? '';
-    const lines = features.map(feat => formatFeatWithSubfeatures(feat, start));
-    return `${[l1, l2, ...lines, ...formatOrigin(contig)].join('\n')}\n`;
+        stopToken,
+        statusCallback: slot(),
+    })));
+    return records.join('\n');
 }

package/esm/pluggableElementTypes/models/saveTrackFileTypes/gff3.d.ts

@@ -1,5 +1,10 @@
 import type { Feature } from '@jbrowse/core/util';
-export declare function formatMultiLevelFeat(feature: Feature, parentId?: string, parentRef?: string): string;
+export declare function formatMultiLevelFeat({ feature, parentId, parentRef, cdsPhase, }: {
+    feature: Feature;
+    parentId?: string;
+    parentRef?: string;
+    cdsPhase?: number;
+}): string;
 export declare function stringifyGFF3({ features }: {
     features: Feature[];
 }): string;

package/esm/pluggableElementTypes/models/saveTrackFileTypes/gff3.js

@@ -1,19 +1,4 @@
-const coreFields = new Set([
-    'uniqueId',
-    'id',
-    'refName',
-    'source',
-    'type',
-    'start',
-    'end',
-    'strand',
-    'parent',
-    'parentId',
-    'score',
-    'subfeatures',
-    'phase',
-    '_lineHash',
-]);
+import { coreFeatureFields, formatAttributeValue, formatStrand, } from './util.js';
 const retitle = {
     name: 'Name',
     alias: 'Alias',
@@ -26,85 +11,96 @@ const retitle = {
     ontology_term: 'Ontology_term',
     is_circular: 'Is_circular',
 };
+const gff3Escapes = {
+    '%': '%25',
+    ';': '%3B',
+    '=': '%3D',
+    '&': '%26',
+    ',': '%2C',
+    '\t': '%09',
+    '\n': '%0A',
+    '\r': '%0D',
+};
 function encodeGFF3Value(str) {
-    return str
-        .replace(/%/g, '%25')
-        .replace(/;/g, '%3B')
-        .replace(/=/g, '%3D')
-        .replace(/&/g, '%26')
-        .replace(/,/g, '%2C')
-        .replace(/\t/g, '%09')
-        .replace(/\n/g, '%0A')
-        .replace(/\r/g, '%0D');
-}
-function fmt(obj) {
-    if (obj === null || obj === undefined) {
-        return undefined;
-    }
-    if (Array.isArray(obj)) {
-        const items = obj.map(o => fmt(o)).filter(o => o !== undefined);
-        return items.length > 0 ? items.join(',') : undefined;
-    }
-    if (typeof obj === 'object') {
-        return encodeGFF3Value(JSON.stringify(obj));
-    }
-    return encodeGFF3Value(String(obj));
+    return str.replaceAll(/[%;=&,\t\n\r]/g, c => gff3Escapes[c]);
 }
-function formatAttributes(f, parentId) {
+function formatAttributes(f, { id, parentId }) {
     const attributes = [];
-    const id = f.get('id');
     if (id) {
-        attributes.push(`ID=${encodeGFF3Value(String(id))}`);
+        attributes.push(`ID=${encodeGFF3Value(id)}`);
     }
     if (parentId) {
-        attributes.push(`Parent=${encodeGFF3Value(String(parentId))}`);
+        attributes.push(`Parent=${encodeGFF3Value(parentId)}`);
     }
-    const tags = Object.keys(f.toJSON()).filter(tag => !coreFields.has(tag));
+    const tags = Object.keys(f.toJSON()).filter(tag => !coreFeatureFields.has(tag));
     const hasDescription = tags.includes('description');
-    const hasNote = tags.includes('note');
     for (const tag of tags) {
-        const val = f.get(tag);
-        const formattedVal = fmt(val);
+        const formattedVal = formatAttributeValue(f.get(tag), encodeGFF3Value);
         if (formattedVal) {
-            let key = retitle[tag] || tag;
-            if (tag === 'note' && hasDescription && hasNote) {
-                key = 'note2';
-            }
+            // both note and description map to Note; keep note as note2 so the
+            // description-derived Note isn't clobbered
+            const key = tag === 'note' && hasDescription ? 'note2' : retitle[tag] || tag;
             attributes.push(`${key}=${formattedVal}`);
         }
     }
     return attributes.join(';');
 }
-function formatFeat(f, parentId, parentRef) {
-    const strand = f.get('strand');
-    const score = f.get('score');
-    const phase = f.get('phase');
+// GFF3 requires a phase (0|1|2) on CDS features. When a non-GFF3 source omits
+// it, derive it from the cumulative CDS length in translation order (sort
+// ascending on +, descending on -), assuming the 5'-most CDS begins in frame.
+// https://github.com/The-Sequence-Ontology/Specifications/blob/master/gff3.md
+function computeCdsPhases(subfeatures, strand) {
+    const cds = subfeatures
+        .filter(f => f.get('type') === 'CDS')
+        .sort((a, b) => strand === -1
+        ? b.get('start') - a.get('start')
+        : a.get('start') - b.get('start'));
+    const phases = new Map();
+    let cumulative = 0;
+    for (const f of cds) {
+        phases.set(f, (3 - (cumulative % 3)) % 3);
+        cumulative += f.get('end') - f.get('start');
+    }
+    return phases;
+}
+function formatFeat({ feature, id, parentId, refName, cdsPhase, }) {
+    const score = feature.get('score');
+    const phase = feature.get('phase') ?? cdsPhase;
     return [
-        f.get('refName') || parentRef,
-        f.get('source') || '.',
-        f.get('type') || '.',
-        f.get('start') + 1,
-        f.get('end'),
-        score !== undefined && score !== null ? score : '.',
-        strand === 1 ? '+' : strand === -1 ? '-' : '.',
-        phase !== undefined && phase !== null ? phase : '.',
-        formatAttributes(f, parentId),
+        refName,
+        feature.get('source') || '.',
+        feature.get('type') || '.',
+        feature.get('start') + 1,
+        feature.get('end'),
+        score ?? '.',
+        formatStrand(feature.get('strand')),
+        phase ?? '.',
+        formatAttributes(feature, { id, parentId }),
     ].join('\t');
 }
-export function formatMultiLevelFeat(feature, parentId, parentRef) {
-    const featureRefName = parentRef || feature.get('refName');
-    const featureId = feature.get('id');
-    const primary = formatFeat(feature, parentId, featureRefName);
+export function formatMultiLevelFeat({ feature, parentId, parentRef, cdsPhase, }) {
+    const refName = parentRef ?? feature.get('refName');
+    const subfeatures = feature.get('subfeatures');
+    // non-GFF3 sources (e.g. BigBed aggregated genes) synthesize parents with no
+    // id attribute; manufacture one from the uniqueId so children can Parent= it
+    const id = feature.get('id') ?? (subfeatures?.length ? feature.id() : undefined);
+    // fill in CDS phase when missing; feature.get('phase') still wins per-feature
+    const childPhases = subfeatures?.some(f => f.get('type') === 'CDS' && f.get('phase') === undefined)
+        ? computeCdsPhases(subfeatures, feature.get('strand'))
+        : undefined;
     return [
-        primary,
-        ...(feature
-            .get('subfeatures')
-            ?.map(sub => formatMultiLevelFeat(sub, featureId, featureRefName)) || []),
+        formatFeat({ feature, id, parentId, refName, cdsPhase }),
+        ...(subfeatures?.map(sub => formatMultiLevelFeat({
+            feature: sub,
+            parentId: id,
+            parentRef: refName,
+            cdsPhase: childPhases?.get(sub),
+        })) ?? []),
     ].join('\n');
 }
 export function stringifyGFF3({ features }) {
-    return `${[
+    return [
         '##gff-version 3',
-        ...features.map(f => formatMultiLevelFeat(f)),
-    ].join('\n')}\n`;
+        ...features.map(f => formatMultiLevelFeat({ feature: f })),
+    ].join('\n');
 }