jbrowse-plugin-graphgenomeviewer 7.1.0 → 7.1.2

package/src/GraphGenomeView/pane/tubeMapViews.ts

@@ -0,0 +1,445 @@
+import { formatBp } from '@jbrowse/bandage-core/graphLabels'
+import { getDpr } from '@jbrowse/bandage-core/renderer/canvas'
+import { referenceBoxes, rulerBoxes } from '@jbrowse/bandage-core/tubeMap/axis'
+import {
+  connectorAt,
+  drawLitConnector,
+  tubeMapConnectors,
+} from '@jbrowse/bandage-core/tubeMap/connectors'
+import { deviationMarks } from '@jbrowse/bandage-core/tubeMap/deviations'
+import {
+  drawTubeMapHighlight,
+  mismatchOnScreen,
+  mismatchesLegible,
+  tubeMapMismatchAt,
+  tubeMapPicture,
+  tubeMapTrackAt,
+} from '@jbrowse/bandage-core/tubeMap/draw'
+import {
+  tubeMapFrame,
+  tubeMapNodeAt,
+} from '@jbrowse/bandage-core/tubeMap/frame'
+import { tubeMapNodeColors } from '@jbrowse/bandage-core/tubeMap/nodeColors'
+import { computed } from 'mobx'
+
+import {
+  NO_VALUE_TUBE,
+  PANEL_GAP,
+  PANEL_TUBE,
+  TINTED_TUBES,
+  boxOf,
+  memberAt,
+  paintPanelHover,
+  walksThrough,
+} from '../tubeMapPanels'
+import { withFitViews } from './fitViews'
+import { HOVER_BRIGHTEN } from './paneBase'
+
+import type { HoveredTube } from './paneBase'
+import type { Canvas2DRenderer } from '@jbrowse/bandage-core/renderer/Canvas2DRenderer'
+import type { RenderBatch } from '@jbrowse/bandage-core/renderer/types'
+import type { TubeMapPicture } from '@jbrowse/bandage-core/tubeMap/draw'
+import type { TubeMapTransform } from '@jbrowse/bandage-core/tubeMap/frame'
+import type { TubeMapMismatch } from '@jbrowse/bandage-core/tubeMap/mismatches'
+
+const MAX_SHOWN_BASES = 20
+// a squeezed stack of panels thins no further, as one tube map does
+const MIN_PANEL_Y_SCALE = 0.05
+
+const MAX_LISTED = 6
+
+function listed(names: string[]) {
+  const more = names.length - MAX_LISTED
+  return more > 0
+    ? `${names.slice(0, MAX_LISTED).join(', ')} and ${more} more`
+    : names.join(', ')
+}
+
+function mismatchText(m: TubeMapMismatch) {
+  if (m.kind === 'deletion') {
+    return `deletion of ${formatBp(m.length)}`
+  }
+  if (m.kind === 'substitution') {
+    return `substitution ${m.seq}`
+  }
+  const seq = m.seq ?? ''
+  const shown =
+    seq.length > MAX_SHOWN_BASES ? `${seq.slice(0, MAX_SHOWN_BASES)}…` : seq
+  return `insertion of ${formatBp(seq.length)} ${shown}`.trim()
+}
+
+// Which kinds of read mark are on screen, stopping once all three are found
+function mismatchKindsShown(
+  picture: TubeMapPicture | undefined,
+  frame: TubeMapTransform | undefined,
+  width: number,
+) {
+  const kinds = { substitution: false, insertion: false, deletion: false }
+  if (picture && frame && mismatchesLegible(frame.yScale)) {
+    let missing = 3
+    for (const m of picture.mismatches) {
+      if (!kinds[m.kind] && mismatchOnScreen(m, { x: frame.x, width })) {
+        kinds[m.kind] = true
+        if (--missing === 0) {
+          break
+        }
+      }
+    }
+  }
+  return kinds
+}
+
+export const withTubeMapViews = withFitViews
+  .views(self => ({
+    get tubeMapFrame() {
+      const drawing = self.layoutResult?.tubeMap
+      return drawing
+        ? tubeMapFrame(drawing, {
+            ...self.screenTransform,
+            usableHeight: self.usableHeight,
+          })
+        : undefined
+    },
+    // the reference ruler under the tubes, unless the linear view's ruler
+    // is already the axis
+    get tubeMapRulerBoxes() {
+      const reference = self.tubeMapReference
+      return reference && !self.hostPlacesX && !self.layoutResult?.tubeMapPanels
+        ? rulerBoxes(reference)
+        : undefined
+    },
+    // Split on the reference axis, the panels share x, so one ruler under
+    // the last reads for them all; on the own axis each panel has its own
+    get tubeMapPanelRulerBoxes() {
+      const { layoutResult } = self
+      const last = layoutResult?.tubeMapPanels?.at(-1)
+      return last && layoutResult?.referenceAxis && !self.hostPlacesX
+        ? rulerBoxes(referenceBoxes(last.result.tubeMap))
+        : undefined
+    },
+    // The connectors run from the top of the pane down to the tubes' top
+    get connectorZoneBottom() {
+      const picture = self.tubeMapPicture
+      const frame = this.tubeMapFrame
+      return picture && frame ? frame.y(picture.bounds.minY) - 2 : 0
+    },
+    // The bands' tops follow every frame of a pan in the linear view and
+    // their bottoms every pan of the tubes
+    get tubeMapConnectors() {
+      const boxes = self.tubeMapConnectedBoxes
+      const frame = this.tubeMapFrame
+      const bp = boxes && frame ? self.hostBpFrame : undefined
+      return boxes && frame && bp
+        ? tubeMapConnectors(
+            boxes,
+            b => b * bp.scale + bp.translateX,
+            frame.x,
+            self.paneWidth,
+          )
+        : []
+    },
+    // What each panel of a split tube map draws, which no pan or hover
+    // changes: its picture, its tubes, its boxes' tints and its folded
+    // variants
+    get tubeMapPanelPictures() {
+      const panels = self.layoutResult?.tubeMapPanels
+      if (!panels) {
+        return undefined
+      }
+      const { field } = self.facetSetting
+      return panels.map(panel => {
+        const drawing = panel.result.tubeMap
+        const { graph, coarse } = drawing
+        return {
+          panel,
+          label:
+            panel.label ??
+            (field === 'walk' ? self.walkLabel(panel.paths[0]!) : panel.key),
+          picture: tubeMapPicture(drawing),
+          tubeColors: self.tubeColorsOf(graph, drawing.pathColors),
+          nodeColors: self.tubeMapNodeColors
+            ? tubeMapNodeColors(
+                graph,
+                self.effectiveColorScheme,
+                self.referenceRamp,
+              )
+            : undefined,
+          deviations: coarse ? deviationMarks(drawing, coarse.deviations) : [],
+        }
+      })
+    },
+  }))
+  .views(self => ({
+    // The node the pointer is on: inside a merged run, the member at the
+    // pointer's bp, so a run spanning the window counts what is under it
+    get hoveredMember() {
+      const id = self.hoveredNode
+      const members =
+        id === null ? undefined : self.hoverDrawing?.members.get(id)
+      if (!members) {
+        return id
+      }
+      const at = self.hoveredAt
+      const i = self.hoveredPanel
+      const under = i === null ? undefined : this.tubeMapPanelViews?.[i]
+      // sparse, so forEach, which skips its holes, as tubeMapNodeAt does
+      let box: { x: number; pixelWidth: number } | undefined
+      under?.panel.result.tubeMap.layout.nodes.forEach(n => {
+        if (n.name === id) {
+          box = n
+        }
+      })
+      const member =
+        at && under && box
+          ? memberAt(
+              members,
+              m => self.nodeSpan(m),
+              under.frame.x(box.x),
+              under.frame.x(box.x + box.pixelWidth),
+              at.x,
+            )
+          : undefined
+      return member ?? members[0]
+    },
+    // For the hovered box, the box each panel draws it in and how many of
+    // that panel's haplotypes pass through it: a frequency per group
+    get tubeMapPanelHover() {
+      const id = self.hoveredNode
+      const pictures = self.tubeMapPanelPictures
+      if (id === null || !pictures) {
+        return undefined
+      }
+      const node = this.hoveredMember ?? id
+      return pictures.map(({ panel }) => {
+        const drawing = panel.result.tubeMap
+        const box = boxOf(drawing, node)
+        return box ? { box, ...walksThrough(drawing.graph, box) } : undefined
+      })
+    },
+    // apart from the pictures, so a lane row's hover redraws no panel
+    get tubeMapPanelTubeColors() {
+      return self.tubeMapPanelPictures?.map(({ panel, tubeColors }) => {
+        const { graph } = panel.result.tubeMap
+        return self.fadeUnhovered(
+          tubeColors,
+          graph.paths ?? [],
+          graph.referencePath,
+        )
+      })
+    },
+    // Each panel through the pane's transform at its place down the stack.
+    // On the reference axis the stack squeezes into the pane as one map does.
+    get tubeMapPanelViews() {
+      const pictures = self.tubeMapPanelPictures
+      const tubeColors = this.tubeMapPanelTubeColors
+      const layout = self.layoutResult
+      if (!pictures || !tubeColors || !layout) {
+        return undefined
+      }
+      // the titles keep their px and the drawings squeeze into the rest
+      const titles = pictures.length * PANEL_GAP
+      const drawings = pictures.reduce((h, p) => h + p.panel.height, 0)
+      const usable = self.usableHeight - titles
+      const yScale =
+        self.scaleY *
+        (layout.referenceAxis && drawings > 0
+          ? Math.max(MIN_PANEL_Y_SCALE, Math.min(1, usable / drawings))
+          : 1)
+      let y = self.translateY
+      return pictures.map((p, i) => {
+        const { panel } = p
+        const minY = panel.result.extent?.minY ?? 0
+        const titleTop = y
+        const top = titleTop + PANEL_GAP
+        y = top + panel.height * yScale
+        return {
+          ...p,
+          tubeColors: tubeColors[i]!,
+          frame: tubeMapFrame(panel.result.tubeMap, {
+            scaleX: self.scaleX,
+            translateX: self.translateX,
+            scaleY: yScale,
+            translateY: top - minY * yScale,
+            usableHeight: Infinity,
+          }),
+          titleTop,
+          top,
+          bottom: y,
+        }
+      })
+    },
+    // the panel a pane y falls in, its title's gap included
+    tubeMapPanelAt(sy: number) {
+      const i =
+        this.tubeMapPanelViews?.findIndex(
+          v => v.titleTop <= sy && sy <= v.bottom,
+        ) ?? -1
+      return i < 0 ? null : i
+    },
+  }))
+  .views(self => ({
+    // The hover alone, onto a transparent canvas over the drawing, so a
+    // pointer move repaints what it lights rather than every stroke under
+    // it. `batch` is what the canvas below holds.
+    paintHover(r: Canvas2DRenderer, batch: RenderBatch) {
+      const picture = self.tubeMapPicture
+      const frame = self.tubeMapFrame
+      const node = self.hoverLayerNode
+      if (picture && frame) {
+        const { ctx, canvas } = r
+        const dpr = getDpr()
+        ctx.setTransform(1, 0, 0, 1, 0, 0)
+        ctx.clearRect(0, 0, canvas.width, canvas.height)
+        ctx.setTransform(dpr, 0, 0, dpr, 0, 0)
+        const panels = self.tubeMapPanelViews
+        if (panels) {
+          paintPanelHover(ctx, panels, self.tubeMapPanelHover, {
+            width: self.paneWidth,
+            lit: node !== null,
+          })
+        } else {
+          drawTubeMapHighlight(ctx, picture, {
+            ...frame,
+            width: self.paneWidth,
+            highlightNode: node,
+          })
+        }
+        drawLitConnector(
+          ctx,
+          self.tubeMapConnectors,
+          self.connectorZoneBottom,
+          node,
+        )
+        ctx.setTransform(1, 0, 0, 1, 0, 0)
+      } else {
+        r.uploadGeometry(batch)
+        r.setNodeHighlights(
+          node === null ? new Map() : new Map([[node, HOVER_BRIGHTEN]]),
+        )
+        r.setEdgeHighlight(self.hoveredEdge, HOVER_BRIGHTEN)
+        r.updateTransform(self.paintTransform)
+        r.renderHighlights()
+      }
+    },
+  }))
+  .views(self => {
+    // Compared by value: the marks in view are read off the transform, and
+    // the legend should redraw when a kind comes or goes, not every pan frame
+    const keys = computed(
+      () => {
+        const layout = self.layoutResult
+        const split = layout?.tubeMapPanels !== undefined
+        const reads = split ? [] : (layout?.tubeMap?.layout.reads ?? [])
+        const paths = self.drawnGraph?.paths ?? []
+        const coloring = self.tubeMapColoring
+        const kind = self.tubeColorKind
+        return {
+          bundled: paths.some(p => p.members),
+          // tubes in a column's hues, keyed value by value
+          values:
+            kind === 'value' && coloring
+              ? [
+                  ...[...coloring.palette].map(([value, color]) => ({
+                    value,
+                    color,
+                  })),
+                  ...(coloring.unvalued
+                    ? [
+                        {
+                          value: `${coloring.field}: none`,
+                          color: NO_VALUE_TUBE,
+                        },
+                      ]
+                    : []),
+                ]
+              : undefined,
+          // tubes coloured reference and haplotype rather than per walk
+          roles: kind === 'role' || kind === 'tinted',
+          haplotypeTube: kind === 'tinted' ? TINTED_TUBES[0]! : PANEL_TUBE,
+          logWidths: layout?.tubeMap !== undefined && !layout.referenceAxis,
+          foldBp:
+            self.tubeMapDeviations.length > 0 ? self.tubeMapFold : undefined,
+          forwardReads: reads.some(r => !r.is_reverse),
+          reverseReads: reads.some(r => r.is_reverse),
+          ...mismatchKindsShown(
+            split ? undefined : self.tubeMapPicture,
+            self.tubeMapFrame,
+            self.paneWidth,
+          ),
+        }
+      },
+      { equals: (a, b) => JSON.stringify(a) === JSON.stringify(b) },
+    )
+    return {
+      // What the tube map's legend has to explain: that on the own axis a
+      // box is as wide as the log of its length, the fold its walks' ticks
+      // stand for, the reads' strands, and the marks on the reads in view
+      get tubeMapKeys() {
+        return keys.get()
+      },
+    }
+  })
+  .views(self => ({
+    // The drawing under a pane y: its panel's while the map is split
+    tubeMapUnder(sy: number) {
+      const views = self.tubeMapPanelViews
+      if (views) {
+        const i = self.tubeMapPanelAt(sy)
+        const v = i === null ? undefined : views[i]
+        return v && { drawing: v.panel.result.tubeMap, ...v }
+      }
+      const drawing = self.layoutResult?.tubeMap
+      const picture = self.tubeMapPicture
+      const frame = self.tubeMapFrame
+      return drawing && picture && frame
+        ? { drawing, picture, frame }
+        : undefined
+    },
+    tubeMapNodeAt(sx: number, sy: number) {
+      const under = this.tubeMapUnder(sy)
+      return (
+        (under ? tubeMapNodeAt(under.drawing, under.frame, sx, sy) : null) ??
+        connectorAt(self.tubeMapConnectors, self.connectorZoneBottom, sx, sy) ??
+        null
+      )
+    },
+    // The tube under a pane point, and the mismatch mark on it if any
+    tubeAt(sx: number, sy: number): HoveredTube | null {
+      const under = this.tubeMapUnder(sy)
+      if (!under) {
+        return null
+      }
+      const { picture, frame } = under
+      const mismatch = tubeMapMismatchAt(picture, frame, sx, sy)
+      const track = mismatch?.readId ?? tubeMapTrackAt(picture, frame, sx, sy)
+      return track === undefined ? null : { track, mismatch }
+    },
+    // A tube names its haplotype; a read its MAPQ and strand, and the
+    // mismatch under the pointer
+    get hoveredTubeText() {
+      const tube = self.hoveredTube
+      const layout = self.layoutResult?.tubeMap?.layout
+      const read = tube && layout?.reads.find(r => r.id === tube.track)
+      if (tube && read) {
+        const mapq = read.mapping_quality
+        return {
+          label: read.name ?? 'read',
+          readout: [
+            `MAPQ ${mapq ?? 'unknown'}`,
+            `${read.is_reverse ? 'reverse' : 'forward'} strand`,
+            ...(tube.mismatch ? [mismatchText(tube.mismatch)] : []),
+          ].join(', '),
+        }
+      }
+      const path = tube ? self.hoverGraph?.paths?.[tube.track] : undefined
+      const members = path?.members
+      return members
+        ? {
+            label: `${members.length} haplotypes`,
+            readout: `one route: ${listed(members.map(m => self.walkLabel(m)))}`,
+          }
+        : path
+          ? { label: self.walkLabel(path.name), readout: 'haplotype' }
+          : undefined
+    },
+  }))

package/src/GraphGenomeView/pane/walkRowViews.ts

@@ -17,6 +17,7 @@ import { WALK_GENE_ROWS } from './paneBase'
 import { resolveLocationAssembly } from '../../launchFromGraph/contributors'
 
 import type { SubgraphRegion } from '../../GetSubgraph'
+import type { WalkAxis, WalkRow } from '@jbrowse/bandage-core/layout/walkRows'
 
 export const withWalkRowViews = withLaunchViews
   .views(self => ({
@@ -63,16 +64,29 @@ export const withWalkRowViews = withLaunchViews
         ? stripMarks(self.graph, [bars.reference, ...bars.rows], node)
         : []
     },
+    // Where a row's bar lies on its contig, and the session assembly its
+    // haplotype (`HG00097#1`) or else its sample names
+    rowLocation(row: WalkRow, axis: WalkAxis) {
+      const named = {
+        sample: row.sample,
+        haplotype:
+          row.haplotype === undefined
+            ? undefined
+            : `${row.sample}#${row.haplotype}`,
+      }
+      return {
+        ...named,
+        assembly: resolveLocationAssembly(self.assemblyResolver, named),
+        span: { refName: axis.contig, ...rowSpan(axis, row.bp) },
+      }
+    },
     // Where the drawing has the node a strip point lights, for the ring
     // that finds it in a hairball
     get walkStripLocator() {
       const id = self.stripHover ? self.hoveredNode : null
       return id === null
         ? undefined
-        : nodeAnchor(self.nodePositions?.[id], p => ({
-            x: p.x * self.scaleX + self.translateX,
-            y: p.y * self.scaleY + self.translateY,
-          }))
+        : nodeAnchor(self.nodePositions?.[id], self.toScreen)
     },
   }))
   .views(self => ({
@@ -97,28 +111,18 @@ export const withWalkRowViews = withLaunchViews
           unplaced++
           continue
         }
-        const assemblyName = resolveLocationAssembly(self.assemblyResolver, {
-          sample: row.sample,
-          haplotype:
-            row.haplotype === undefined
-              ? undefined
-              : `${row.sample}#${row.haplotype}`,
-        })
-        const track = assemblyName
-          ? self.geneTracksByAssembly.get(assemblyName)
+        const { assembly, span } = self.rowLocation(row, row.axis)
+        const track = assembly
+          ? self.geneTracksByAssembly.get(assembly)
           : undefined
-        if (!assemblyName || !track) {
+        if (!assembly || !track) {
           untrackedRows++
           continue
         }
         reads.push({
           row: row.name,
           trackId: track.trackId,
-          region: {
-            assemblyName,
-            refName: row.axis.contig,
-            ...rowSpan(row.axis, row.bp),
-          },
+          region: { assemblyName: assembly, ...span },
         })
       }
       return {
@@ -142,26 +146,14 @@ export const withWalkRowViews = withLaunchViews
       if (!row?.axis) {
         return undefined
       }
-      const haplotype =
-        row.haplotype === undefined
-          ? undefined
-          : `${row.sample}#${row.haplotype}`
-      const assembly =
-        index === 0
-          ? self.graphRegion?.assemblyName
-          : resolveLocationAssembly(self.assemblyResolver, {
-              sample: row.sample,
-              haplotype,
-            })
+      const { sample, haplotype, assembly, span } = self.rowLocation(
+        row,
+        row.axis,
+      )
       return {
         label: row.label,
-        assembly,
-        location: {
-          sample: row.sample,
-          haplotype,
-          refName: row.axis.contig,
-          ...rowSpan(row.axis, row.bp),
-        },
+        assembly: index === 0 ? self.graphRegion?.assemblyName : assembly,
+        location: { sample, haplotype, ...span },
       }
     },
     // Each row's genes as offsets along its bar: the reference row's from

package/src/GraphGenomeView/renderPipeline.test.ts

@@ -225,7 +225,7 @@ async function pathModel(count: number) {
   )
   const model = stateModelFactory().create({ type: 'GraphGenomeView' })
   await model.loadGFA(pathGFA(count), 'paths')
-  model.setDrawPaths(true)
+  model.setLayer('paths', true)
   return model
 }
 

package/src/GraphGenomeView/repeats/repeatFeatures.test.ts

@@ -68,6 +68,18 @@ test('vamos motifs and an unnamed array fall back to a motif or locus name', ()
   )
 })
 
+test("an unnamed array's locus name reads the same in every locale", () => {
+  const format = Number.prototype.toLocaleString
+  const german = vi
+    .spyOn(Number.prototype, 'toLocaleString')
+    .mockImplementation(function (this: number, locales, options) {
+      return format.call(this, locales ?? 'de-DE', options)
+    })
+  const [array] = repeatArraysFrom([{ ...base, period: 5548 }])
+  german.mockRestore()
+  expect(array!.name).toBe('chr6:160,616,003-160,646,753')
+})
+
 test('a feature stating no unit is left out, and rows sort by start', () => {
   const arrays = repeatArraysFrom([
     { ...base, start: 5000, end: 6000, period: 2 },
@@ -150,6 +162,17 @@ test("VCF 4.5 <CNV:TR>: each allele's length is its runs' RB", () => {
   })
 })
 
+// a haploid chrX genotype is written '.', and a sample may have no GT at all
+test('a missing genotype calls no allele', () => {
+  const [array] = repeatArraysFrom([
+    {
+      ...tandem,
+      samples: { HG00097: { GT: ['.'] }, HG00099: {}, HG00128: { GT: ['1'] } },
+    },
+  ])
+  expect(array!.calls).toEqual({ HG00128: [{ bp: 49 }] })
+})
+
 test('a run stating only RUL and RUC is their product, and a summary record states no calls', () => {
   const [array] = repeatArraysFrom([
     {

package/src/GraphGenomeView/repeats/repeatFeatures.ts

@@ -1,4 +1,6 @@
-import type { Feature } from '@jbrowse/core/util'
+import { namedTrack, ownField, trackLabel } from '../trackFeatures'
+
+import type { FeatureLike, TrackChoice } from '../trackFeatures'
 
 export interface RepeatCall {
   bp: number
@@ -46,24 +48,15 @@ export const REPEAT_ADAPTER_TYPES = new Set([
 export const REPEAT_TRACK_HINT =
   /repeat|tandem|\bstr\b|vntr|trf|trgt|vamos|expansion|microsat/i
 
-export function pickRepeatTrack<
-  T extends { trackId: string; name?: string; adapterType: string },
->(tracks: T[], named: string) {
+export function pickRepeatTrack<T extends TrackChoice>(
+  tracks: T[],
+  named: string,
+) {
   if (named) {
-    return tracks.find(t => t.trackId === named)
+    return namedTrack(tracks, named)
   }
   const candidates = tracks.filter(t => REPEAT_ADAPTER_TYPES.has(t.adapterType))
-  return candidates.find(t =>
-    REPEAT_TRACK_HINT.test(`${t.trackId} ${t.name ?? ''}`),
-  )
-}
-
-type FeatureLike = Feature | Record<string, unknown>
-
-function own(f: FeatureLike, name: string): unknown {
-  return typeof (f as Feature).get === 'function'
-    ? (f as Feature).get(name)
-    : (f as Record<string, unknown>)[name]
+  return candidates.find(t => REPEAT_TRACK_HINT.test(trackLabel(t)))
 }
 
 // A TRGT repeat catalogue is a BED whose name column packs the record:
@@ -72,7 +65,7 @@ function own(f: FeatureLike, name: string): unknown {
 const PACKED_NAME = /^\w+=[^;]*(;\w+=[^;]*)*$/
 
 function packedName(f: FeatureLike) {
-  const name = own(f, 'name')
+  const name = ownField(f, 'name')
   if (typeof name !== 'string' || !PACKED_NAME.test(name)) {
     return undefined
   }
@@ -87,11 +80,11 @@ function packedName(f: FeatureLike) {
 // A field at the feature's top level, in a VCF record's INFO, or in a packed
 // name column, in that order.
 function field(f: FeatureLike, name: string): unknown {
-  const top = own(f, name)
+  const top = ownField(f, name)
   if (top !== undefined) {
     return top
   }
-  const info = own(f, 'INFO') as Record<string, unknown> | undefined
+  const info = ownField(f, 'INFO') as Record<string, unknown> | undefined
   return info?.[name] ?? packedName(f)?.[name]
 }
 
@@ -173,7 +166,7 @@ const TANDEM_REPEAT = '<CNV:TR>'
 // its runs' RB, or unit length times count where RB is missing. An allele that
 // is not <CNV:TR>, or has a run stating neither, has none.
 function tandemAlleleBp(f: FeatureLike) {
-  const alts = strings(own(f, 'ALT'))
+  const alts = strings(ownField(f, 'ALT'))
   if (!alts.includes(TANDEM_REPEAT)) {
     return undefined
   }
@@ -216,7 +209,7 @@ function genotyped(
 ) {
   const phased = gt?.includes('|')
   return (gt ?? '').split(/[/|]/).flatMap((index, k): RepeatCall[] => {
-    const i = Number(index)
+    const i = index === '' ? NaN : Number(index)
     const bp = i > 0 ? alleleBp[i - 1] : referenceBp
     if (!Number.isInteger(i) || bp === undefined) {
       return []
@@ -230,7 +223,7 @@ function callsOf(
   alleleBp: (number | undefined)[] | undefined,
   referenceBp: number,
 ) {
-  const samples = own(f, 'samples') as
+  const samples = ownField(f, 'samples') as
     Record<string, Record<string, unknown>> | undefined
   const called: Record<string, RepeatCall[]> = {}
   for (const [sample, fields] of Object.entries(samples ?? {})) {
@@ -280,7 +273,7 @@ export function repeatArraysFrom(features: FeatureLike[]): RepeatArray[] {
         (stated && !PACKED_NAME.test(stated) ? stated : undefined) ??
         (motif && motif.length <= 12
           ? `(${motif})n`
-          : `${refName}:${(start + 1).toLocaleString()}-${end.toLocaleString()}`),
+          : `${refName}:${(start + 1).toLocaleString('en-US')}-${end.toLocaleString('en-US')}`),
       refName,
       start,
       end,