@@ -9,7 +9,23 @@ version lines would multiply into combinations nobody tests.
 
 ## [Unreleased]
 
-Nothing since 0.1.0.
+### Fixed
+
+- **A range covering no byte no longer breaks the decoration indexes.** One zero-length
+  range was enough to make `new IntervalIndex(...)` exhaust the stack: a range with
+  `start === end` cannot satisfy the centre test the build sorts on, so it was handed
+  down a level at every step and, once alone in a list, split into itself for ever. A
+  parser produces such ranges — a zero-length record is a fact about the file — so a
+  consumer lost the whole view over one of them. `IntervalColumns` did not hang, but it
+  reported an empty range as overlapping any query that contained it, which
+  `DecorationStore.between` passed on to the renderer. Both indexes now leave out a range
+  with `end <= start`, which is what half-open already means and what
+  `DecorationStore.map` already did with a range an edit had emptied.
+- **A range reaching to infinity is indexed instead of hanging.** Its midpoint is not
+  finite, and a centre of `Infinity` pushes every range into one child — the same
+  non-terminating split by another route. The centre falls back to a median start, which
+  a range always covers, so the build makes progress whatever the bounds are. Finite
+  ranges take the measured midpoint heuristic as before.
 
 ## [0.1.0] — 2026-08-08
 
 
@@ -153,8 +153,7 @@ so a change that makes one of them wrong has to say what replaced it — otherwi
 next reader trusts a comment that is no longer true.
 
 **An entry in `CHANGELOG.md`** under `[Unreleased]` if the change is one a consumer would
-notice. `0.1.0-next.0` is published, so there is a released version to describe changes
-against.
+notice. `0.1.0` is released, so there is a stable version to describe changes against.
 
 ## Releasing
 
 
@@ -52,7 +52,10 @@ export class IntervalColumns {
   private collect(node: number, low: number, high: number, from: number, limit: number, out: number[]): void {
     if (low >= limit || this.tree[node]! <= from) return;
     if (high - low === 1) {
-      out.push(low);
+      // A range covering no byte overlaps nothing, but the two bounds this walk checks
+      // are met when the query contains it — `start` before `to`, `end` after `from` —
+      // so it has to be excluded here rather than left to them.
+      if (this.ends[low]! > this.starts[low]!) out.push(low);
       return;
     }
     const middle = (low + high) >> 1;
 
@@ -32,12 +32,16 @@ interface Node<T extends Interval> {
  *
  * Rebuilt whole rather than mutated: decorations arrive in bulk and are queried
  * once per row per frame, so the cost belongs on the write.
+ *
+ * Ranges that cover no byte are not indexed. A parser produces them — a zero-length
+ * record is a fact about the file, not a mistake — and they would otherwise be carried
+ * through a tree that can never answer with them.
  */
 export class IntervalIndex<T extends Interval> {
   private readonly root: Node<T> | undefined;
 
   constructor(items: readonly T[]) {
-    this.root = build([...items]);
+    this.root = build(items.filter(coversAByte));
   }
 
   /** Ranges overlapping `[from, to)`, in no particular order. */
@@ -53,12 +57,22 @@ export class IntervalIndex<T extends Interval> {
   }
 }
 
+/**
+ * Whether a range covers a byte at all. `end > start` is the whole test: it excludes
+ * the empty range, the inverted one, and a bound that is not a number, none of which a
+ * half-open query can ever overlap — so leaving them out changes no answer, and
+ * `IntervalColumns` and `DecorationStore.map` already treat them the same way.
+ *
+ * It is also what makes `build` terminate. `here` asks for `start <= centre < end`,
+ * which an empty range cannot satisfy at any centre: it goes to a child every time, and
+ * alone in a list it splits into itself for ever. One such range used to cost the whole
+ * index a stack overflow at construction.
+ */
+const coversAByte = <T extends Interval>(item: T): boolean => item.end > item.start;
+
 function build<T extends Interval>(items: T[]): Node<T> | undefined {
   if (items.length === 0) return undefined;
-  // The median of the midpoints, so a run of ranges in one place does not tip
-  // every level to one side.
-  const midpoints = items.map((item) => (item.start + item.end) / 2).sort((left, right) => left - right);
-  const center = midpoints[midpoints.length >> 1]!;
+  const center = centerOf(items);
   const left: T[] = [];
   const right: T[] = [];
   const here: T[] = [];
@@ -80,6 +94,26 @@ function build<T extends Interval>(items: T[]): Node<T> | undefined {
   };
 }
 
+/**
+ * The median of the midpoints, so a run of ranges in one place does not tip every level
+ * to one side.
+ *
+ * A range reaching to infinity has no midpoint to offer, and a centre that is not finite
+ * sits inside nothing: every range would be handed to one child and the build would
+ * recurse on the same list for ever. The median start is the fallback, because a range
+ * covers its own start — so whichever range the median picks stays here, and both
+ * children come out strictly smaller. Finite ranges never reach it.
+ */
+function centerOf<T extends Interval>(items: T[]): number {
+  const midpoints = items.map((item) => (item.start + item.end) / 2).sort(ascending);
+  const center = midpoints[midpoints.length >> 1]!;
+  if (Number.isFinite(center)) return center;
+  const starts = items.map((item) => item.start).sort(ascending);
+  return starts[starts.length >> 1]!;
+}
+
+const ascending = (left: number, right: number): number => left - right;
+
 const sortByStart = <T extends Interval>(items: T[]): T[] => [...items].sort((left, right) => left.start - right.start);
 const sortByEnd = <T extends Interval>(items: T[]): T[] => [...items].sort((left, right) => right.end - left.end);
 
 
@@ -48,6 +48,21 @@ describe("DecorationStore", () => {
     expect(labels(nested().between(20, 32))).toEqual(["record"]);
   });
 
+  it("does not report a range that covers no byte", () => {
+    // A parse result carries them — a zero-length record is a fact about the file — and a
+    // row query contains one rather than touching its bounds, which is the case that used
+    // to hand it to the renderer as if it overlapped.
+    const store = new DecorationStore();
+    store.addAll([{ start: 0, end: 48, label: "record" }, { start: 16, end: 16, label: "empty" }]);
+    expect(labels(store.between(0, 32))).toEqual(["record"]);
+    expect(labels(store.between(16, 17))).toEqual(["record"]);
+    expect(labels(store.allAt(16))).toEqual(["record"]);
+    expect(store.at(16, "structure")).toBeUndefined();
+    // Still held and still reported as a range: the store does not decide it is a mistake.
+    expect(store.size).toBe(2);
+    expect(labels(store.all)).toEqual(["record", "empty"]);
+  });
+
   it("filters by kind", () => {
     const store = new DecorationStore();
     store.addAll([{ start: 0, end: 1, kind: "bookmark" }, { start: 0, end: 8, kind: "structure" }]);
 
@@ -5,9 +5,13 @@ import { IntervalIndex, type Interval } from "../src/interval-index";
 const range = (start: number, end: number): Interval => ({ start, end });
 const starts = (found: Interval[]) => found.map((item) => item.start).sort((left, right) => left - right);
 
-/** The answer a full pass would give, which the index has to match exactly. */
+/**
+ * The answer a full pass would give, which the index has to match exactly. The pair of
+ * comparisons is the usual overlap test but it only holds for a range that covers a
+ * byte: an empty range sitting inside the query passes both and intersects nothing.
+ */
 const byScan = (items: Interval[], from: number, to: number) =>
-  starts(items.filter((item) => item.start < to && item.end > from));
+  starts(items.filter((item) => item.end > item.start && item.start < to && item.end > from));
 
 describe("IntervalIndex", () => {
   it("finds what overlaps a range and nothing else", () => {
@@ -40,13 +44,53 @@ describe("IntervalIndex", () => {
     expect(starts(index.covering(95))).toEqual([0]);
   });
 
+  it("leaves out a range that covers no byte", () => {
+    // A zero-length range cannot satisfy `start <= centre < end` at any centre, so the
+    // build used to hand it to a child at every level and, alone in a list, split it
+    // into itself until the stack ran out. One of them cost a consumer the whole index.
+    const empty = range(10, 10);
+    expect(new IntervalIndex([empty]).covering(10)).toEqual([]);
+    expect(new IntervalIndex([empty]).overlapping(0, 100)).toEqual([]);
+
+    // Wherever it sits among ranges that do cover bytes, and however many there are.
+    const among: Interval[] = [range(0, 100), empty, range(20, 24), range(96, 400)];
+    expect(starts(new IntervalIndex(among).overlapping(0, 500))).toEqual([0, 20, 96]);
+    expect(starts(new IntervalIndex(among).covering(10))).toEqual([0]);
+
+    // The shape that found this: a 0-byte record's payload inside a parsed file.
+    const parsed = [range(0, 5309808), range(5309808, 5309816), range(5309808, 5309808)];
+    expect(starts(new IntervalIndex(parsed).covering(5309808))).toEqual([5309808]);
+  });
+
+  it("leaves out a range whose bounds are not ordered numbers", () => {
+    // Inverted and not-a-number fail `end > start` the same way an empty range does, and
+    // a full pass drops them too — `end > from` is false for NaN.
+    expect(new IntervalIndex([range(20, 10)]).overlapping(0, 100)).toEqual([]);
+    expect(new IntervalIndex([range(0, Number.NaN)]).overlapping(0, 100)).toEqual([]);
+    expect(new IntervalIndex([range(Number.NaN, 10)]).overlapping(0, 100)).toEqual([]);
+  });
+
+  it("indexes a range that reaches to infinity rather than dropping it", () => {
+    // It covers bytes, so it belongs in the answer. Its midpoint is not finite, though,
+    // and a centre of `Infinity` puts every range in one child — which is the same
+    // non-terminating split by another route, so the centre falls back to a median start.
+    const items = [range(0, Number.POSITIVE_INFINITY), range(10, 20)];
+    const index = new IntervalIndex(items);
+    expect(starts(index.covering(5))).toEqual([0]);
+    expect(starts(index.covering(15))).toEqual([0, 10]);
+    expect(starts(index.covering(1e12))).toEqual([0]);
+  });
+
   it("agrees with a full pass over awkward data", () => {
     // A document-spanning outer range plus clusters, which is what a parsed
-    // structure looks like and what the naive index gets wrong.
+    // structure looks like and what the naive index gets wrong. Every cluster carries a
+    // zero-length range as well, because a parse result carries them and the fuzz that
+    // missed the hang above could not produce one.
     const items: Interval[] = [range(0, 4096)];
     for (let cluster = 0; cluster < 40; cluster++) {
       const base = cluster * 100;
       items.push(range(base, base + 64), range(base + 8, base + 16), range(base + 8, base + 9));
+      items.push(range(base + 32, base + 32), range(base + 64, base + 64));
     }
     const index = new IntervalIndex(items);
     for (let from = 0; from < 4200; from += 7) {
@@ -83,13 +127,13 @@ describe("IntervalColumns", () => {
     for (let cluster = 0; cluster < 40; cluster++) {
       const base = cluster * 100;
       items.push(range(base, base + 64), range(base + 8, base + 16), range(base + 8, base + 9));
+      items.push(range(base + 32, base + 32), range(base + 64, base + 64));
     }
     for (let sibling = 0; sibling < 200; sibling++) items.push(range(5000 + sibling * 16, 5000 + sibling * 16 + 12));
 
     for (let from = 0; from < 8400; from += 13) {
       const to = from + (from % 3 === 0 ? 1 : 16);
-      const expected = starts(items.filter((item) => item.start < to && item.end > from));
-      expect(found(items, from, to), `overlapping(${from}, ${to})`).toEqual(expected);
+      expect(found(items, from, to), `overlapping(${from}, ${to})`).toEqual(byScan(items, from, to));
     }
   });
 
@@ -107,6 +151,15 @@ describe("IntervalColumns", () => {
     expect(found(items, 0, 1000)).toEqual([0, 400]);
   });
 
+  it("answers without a range that covers no byte, as the tree does", () => {
+    // The store's index reaches this case by construction, and both indexes have to give
+    // the same answer for the same ranges or a host cannot swap one for the other.
+    const items = [range(0, 200), range(100, 100), range(150, 160)];
+    expect(found(items, 100, 101)).toEqual([0]);
+    expect(found(items, 99, 102)).toEqual([0]);
+    expect(found(items, 0, 200)).toEqual([0, 150]);
+  });
+
   it("reuses the array it is handed", () => {
     const { index } = columns([range(0, 4), range(8, 12)]);
     const out: number[] = [];