@torrent-tv/proxy 2.98.1 → 2.98.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.98.1",
+  "version": "2.98.3",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "repository": {

package/server.js

@@ -437,44 +437,55 @@ export async function startProxyServer({
   /** Source byte ranges of one segment interval, by file and interval; forgotten with the source. */
   const segmentSourceRanges = new Map();
   /**
-   * What one segment of an output reads — its tracks, its interval and the key
-   * its bytes are kept under — by output and segment, until the tracks, the
-   * file's start time, the segment's interval or the choices of the output
-   * change; forgotten with the source.
+   * WHAT ONE SEGMENT OF AN OUTPUT IS, kept from pass to pass: where it lies in
+   * the source, what it reads — its tracks and the key its bytes are kept under
+   * — and, once known, those bytes joined at the precision the torrent fetches,
+   * by output and segment. Worked out again only when the output's timeline,
+   * the tracks, the file's start time or the output's choices change; forgotten
+   * with the source. None of it depends on where a viewer stands, and a pass is
+   * made every time one moves: looked up, made and joined again for each of a
+   * film's 3500 segments on every pass, they were 6 s of the 40 s the passes
+   * cost the main thread in fifteen minutes on Home Assistant (r30,
+   * torrent-tv/meta#178).
    */
   const segmentReadings = new Map();
-  // Per output, then per segment: every segment of an output of one pass shares
-  // its list of track choices, so the output's key and the choices' key are
-  // worked out once for it. Built for each of a pass's segments, the two
-  // strings cost the main thread 13 s in ten minutes of a cold AVI on Home
-  // Assistant (torrent-tv/meta#178).
-  const readingsByChoices = new WeakMap();
-  const segmentReadingOf = (zone, trackList, shift, map) => {
-    let output = readingsByChoices.get(zone.tracks);
-    if (!output) {
-      const outputKey = `${map.sourceKey}:${map.fileIndex}:${zone.outputKey}`;
-      let byIndex = segmentReadings.get(outputKey);
-      if (!byIndex) segmentReadings.set(outputKey, byIndex = new Map());
-      output = { byIndex, choicesKey: zone.tracks.map(choice => `${choice.type}/${choice.index}/${choice.mode}`).join(",") };
-      readingsByChoices.set(zone.tracks, output);
-    }
-    const { byIndex, choicesKey } = output;
-    const kept = byIndex.get(zone.index);
-    if (kept && kept.trackList === trackList && kept.shift === shift && kept.choicesKey === choicesKey &&
-      kept.from === zone.sourceInterval.from && kept.to === zone.sourceInterval.to) return kept.reading;
-    const selected = zone.tracks.map(choice => ({ choice, track: choice.type === "video"
+  /** One output's segments, by index. */
+  const segmentRecordsOf = (map, output) => {
+    const key = `${map.sourceKey}:${map.fileIndex}:${output.outputKey}`;
+    let records = segmentReadings.get(key);
+    if (!records) segmentReadings.set(key, records = new Map());
+    return records;
+  };
+  /** The choices of one output's tracks as a key, worked out once for the list of them a pass shares. */
+  const choicesKeys = new WeakMap();
+  const choicesKeyOf = (choices) => {
+    let key = choicesKeys.get(choices);
+    if (key === undefined) choicesKeys.set(choices, key = choices.map(choice => `${choice.type}/${choice.index}/${choice.mode}`).join(","));
+    return key;
+  };
+  const segmentRecordOf = (records, demand, { timeline, trackList, shift, map }) => {
+    const choicesKey = choicesKeyOf(demand.tracks);
+    const kept = records.get(demand.index);
+    if (kept && kept.timeline === timeline && kept.trackList === trackList && kept.shift === shift && kept.choicesKey === choicesKey) return kept;
+    const sourceInterval = timeline.sourceInterval(demand.index, demand.index, shift);
+    const selected = demand.tracks.map(choice => ({ choice, track: choice.type === "video"
       ? ContainerTrack.firstUsable(trackList, "video")
       : trackList.filter(track => track.type === choice.type)[choice.index] }));
     let reading = null;
     if (!selected.some(({ track }) => !track)) {
       const wanted = selected.map(({ track }) => track);
       const modes = new Map(selected.map(({ choice, track }) => [track, choice.mode]));
-      const interval = { ...zone.sourceInterval, trackIds: wanted.map(track => track.trackNumber),
+      const interval = { ...sourceInterval, trackIds: wanted.map(track => track.trackNumber),
         modes: Object.fromEntries(wanted.map(track => [track.trackNumber, modes.get(track)])) };
       reading = { wanted, modes, interval, rangesKey: `${map.sourceKey}:${map.fileIndex}:${JSON.stringify(interval)}` };
     }
-    byIndex.set(zone.index, { trackList, shift, choicesKey, from: zone.sourceInterval.from, to: zone.sourceInterval.to, reading });
-    return reading;
+    // `joined` is the segment's ranges as the torrent is told them, made from
+    // the list `ranges` at `pieceLength`; `registered` is the list the input
+    // table was last given.
+    const record = { timeline, trackList, shift, choicesKey, sourceInterval, reading,
+      ranges: null, pieceLength: Number.NaN, joined: null, registered: null };
+    records.set(demand.index, record);
+    return record;
   };
   /**
    * The last complete pass over each file, by file: what it was worked out
@@ -508,15 +519,6 @@ export async function startProxyServer({
       `${passCosts.built} zone list(s) built for the map in ${Math.round(passCosts.buildMs)}ms`);
     Object.assign(passCosts, { since: now, reused: 0, worked: 0, incomplete: 0, segments: 0, ranges: 0, zones: 0, built: 0, buildMs: 0, ms: 0, maxMs: 0 });
   };
-  /** A segment's ranges joined at the precision the torrent fetches, once per kept list and piece length. */
-  const joinedRanges = new WeakMap();
-  const joinedRangesOf = (ranges, pieceLength) => {
-    const kept = joinedRanges.get(ranges);
-    if (kept && kept.pieceLength === pieceLength) return kept.joined;
-    const joined = joinedWithinPieces(ranges, pieceLength);
-    if (ranges !== null && typeof ranges === "object") joinedRanges.set(ranges, { pieceLength, joined });
-    return joined;
-  };
   const downloadMaps = new DownloadMaps({
     // The ranges a picture reads at open are named again by every segment;
     // only the zone the swarm would rank first is sent (torrent-tv/meta#166).
@@ -574,14 +576,22 @@ export async function startProxyServer({
         const links = consumers.map(viewer => viewer.linkReading()?.linkMbps)
           .filter(value => Number.isFinite(value) && value > 0);
         const encodeSpeed = outputParts.encodeCost.latestSpeedReadingOf(output)?.speed;
+        const linkMbps = links.length ? Math.min(...links) : null;
+        const records = segmentRecordsOf(map, output);
+        const facts = { timeline: output.timeline, trackList: tracks.value, shift, map };
+        // Each demand is this pass's own object (`segmentDemands`), so it is
+        // completed in place rather than copied.
         for (const demand of segmentDemands(output, map.fileIndex, map.zones)) {
           if (inventory.has(demand.index)) continue;
           const deadlineAt = sourceDeadline(demand, { encodeSpeed,
-            outputBytes: seconds > 0 ? bytes / seconds * (demand.to - demand.from) : null,
-            linkMbps: links.length ? Math.min(...links) : null });
-          const leadSeconds = Number.isFinite(demand.deadlineAt) ? Math.max(0, (demand.deadlineAt - deadlineAt) / 1000) : 0;
-          demands.push({ ...demand, deadlineAt, leadSeconds, outputKey: output.outputKey,
-            sourceInterval: output.timeline.sourceInterval(demand.index, demand.index, shift) });
+            outputBytes: seconds > 0 ? bytes / seconds * (demand.to - demand.from) : null, linkMbps });
+          const record = segmentRecordOf(records, demand, facts);
+          demand.leadSeconds = Number.isFinite(demand.deadlineAt) ? Math.max(0, (demand.deadlineAt - deadlineAt) / 1000) : 0;
+          demand.deadlineAt = deadlineAt;
+          demand.outputKey = output.outputKey;
+          demand.sourceInterval = record.sourceInterval;
+          demand.record = record;
+          demands.push(demand);
         }
       }
       demands.sort((left, right) => left.deadlineAt - right.deadlineAt || right.priority - left.priority || left.index - right.index);
@@ -618,24 +628,37 @@ export async function startProxyServer({
       // two-hour AVI (torrent-tv/meta#178).
       const waiting = new Set();
       const turn = takeTurns();
+      /** One download interval per map zone, shared by the segments it owns: read, never changed. */
+      const downloadIntervals = new Map();
+      const downloadIntervalOf = (owner) => {
+        let interval = downloadIntervals.get(owner);
+        if (!interval) downloadIntervals.set(owner, interval = { from: owner.from, to: owner.to });
+        return interval;
+      };
       for (const zone of demands) {
         if (!map.isCurrent()) return [];
-        // WHAT A SEGMENT READS IS WORKED OUT ONCE, not on every publication: its
-        // tracks, its interval and the key its bytes are kept under depend on
-        // the output, the segment and the file's start time, none of which a
-        // new map changes. Rebuilt for every segment of the film on every map,
-        // this pass held the main thread up to 1.5 s at a time on Home
+        // WHAT A SEGMENT READS IS WORKED OUT ONCE, not on every publication
+        // (`segmentRecordOf`). Rebuilt for every segment of the film on every
+        // map, this pass held the main thread up to 1.5 s at a time on Home
         // Assistant (torrent-tv/meta#178).
-        const reading = segmentReadingOf(zone, tracks.value, shift, map);
+        const { record } = zone;
+        const reading = record.reading;
         if (!reading) continue;
         const { wanted, modes, interval, rangesKey } = reading;
-        const { tracks: _choices, owner: _owner, sourceInterval: _sourceInterval, ...demand } = zone;
         const convert = ranges => {
-          const joined = joinedRangesOf(ranges, pieceLength);
+          if (record.ranges !== ranges || record.pieceLength !== pieceLength) {
+            record.ranges = ranges;
+            record.pieceLength = pieceLength;
+            record.joined = joinedWithinPieces(ranges, pieceLength);
+          }
+          const joined = record.joined;
           rangeCount += joined.length;
           // What the segment reads is kept for the forecast in a table of its
           // own, whatever form the torrent is told it in.
-          segmentInputs.set(map.sourceKey, map.fileIndex, zone.outputKey, zone.index, joined);
+          if (record.registered !== joined) {
+            segmentInputs.set(map.sourceKey, map.fileIndex, zone.outputKey, zone.index, joined);
+            record.registered = joined;
+          }
           // ONE ZONE FOR THE SEGMENT, its demand stated once for all the
           // ranges it reads. The demand — level, priority, deadline, the map
           // zone it belongs to — is this pass's; the ranges are the list kept
@@ -643,14 +666,16 @@ export async function startProxyServer({
           // range copied the demand into every one: ten thousand objects a
           // pass over a two-hour AVI, made again 21-61 times a minute on Home
           // Assistant (r26, torrent-tv/meta#178).
-          converted.push({ ...demand, downloadInterval: { from: zone.owner.from, to: zone.owner.to }, ranges: joined });
+          converted.push({ index: zone.index, from: zone.from, to: zone.to, priority: zone.priority, urgent: zone.urgent,
+            behind: zone.behind, deferred: zone.deferred, deadlineAt: zone.deadlineAt, leadSeconds: zone.leadSeconds,
+            outputKey: zone.outputKey, downloadInterval: downloadIntervalOf(zone.owner), ranges: joined });
         };
         // The bytes one segment needs are a fact of the file and the output, so
         // they are worked out once. A whole film is thousands of segments and
         // the map changes every few seconds; worked out afresh on every change,
         // a pass over a two-hour AVI never finished and the next segment's bytes
         // were never asked for (Home Assistant 2026-10-08, torrent-tv/meta#151).
-        const known = segmentSourceRanges.get(rangesKey);
+        const known = record.ranges ?? segmentSourceRanges.get(rangesKey);
         if (known) { convert(known); continue; }
         if (waiting.has(zone.outputKey)) { complete = false; continue; }
         // What is resolved so far is stated before a lower zone is worked out

package/services/encode/MatroskaInput.js

@@ -54,20 +54,56 @@ export async function* matroskaInput({ tracks, readPacket, originSeconds = 0, in
       slices = avcPacketSlices(slices);
       payloadBytes = slices.reduce((sum, slice) => sum + slice.length, 0);
     }
-    const blockHeader = Buffer.concat([vint(selected + 1), Buffer.from([0, 0, 0])]);
+    // EVERY PACKET'S CLUSTER IS WRITTEN INTO ONE BUFFER, its sizes worked out
+    // first: an element at a time, each id parsed from hex, each number split
+    // into bytes through BigInt and every part joined again, this writer was
+    // 6 % of the main thread over a two-hour AVI on Home Assistant (r30,
+    // torrent-tv/meta#178). The bytes are the same.
     const duration = Math.round(packet.duration * 1e6);
-    const afterBlock = Buffer.concat([
-      ...(duration > 0 ? [uintElement("9b", duration)] : []),
-      ...(packet.discardPaddingSeconds ? [signedElement("75a2", Math.round(packet.discardPaddingSeconds * 1e9))] : []),
-      ...(packet.keyframe ? [] : [element("fb", Buffer.from([0]))])]);
-    const blockPrefix = prefix("a1", blockHeader.length + payloadBytes);
-    const groupPrefix = prefix("a0", blockPrefix.length + blockHeader.length + payloadBytes + afterBlock.length);
-    const timestamp = uintElement("e7", stamp);
-    const clusterPrefix = prefix("1f43b675", timestamp.length + groupPrefix.length + blockPrefix.length +
-      blockHeader.length + payloadBytes + afterBlock.length);
-    yield Buffer.concat([clusterPrefix, timestamp, groupPrefix, blockPrefix, blockHeader]);
+    const padding = packet.discardPaddingSeconds ? Math.round(packet.discardPaddingSeconds * 1e9) : null;
+    if (duration > 0 && !Number.isSafeInteger(duration)) throw new TypeError("EBML unsigned integer is invalid.");
+    if (padding !== null && !Number.isSafeInteger(padding)) throw new TypeError("EBML signed integer is outside its exact range.");
+    const blockHeaderBytes = vintWidth(selected + 1) + 3;
+    const durationWidth = duration > 0 ? uintWidth(duration) : 0;
+    const afterBytes = (duration > 0 ? 1 + vintWidth(durationWidth) + durationWidth : 0) +
+      (padding !== null ? 2 + 1 + 8 : 0) + (packet.keyframe ? 0 : 3);
+    const blockSize = blockHeaderBytes + payloadBytes;
+    const blockPrefixBytes = 1 + vintWidth(blockSize);
+    const groupSize = blockPrefixBytes + blockSize + afterBytes;
+    const groupPrefixBytes = 1 + vintWidth(groupSize);
+    const stampWidth = uintWidth(stamp);
+    const timestampBytes = 1 + vintWidth(stampWidth) + stampWidth;
+    const clusterSize = timestampBytes + groupPrefixBytes + groupSize;
+    const head = Buffer.allocUnsafe(4 + vintWidth(clusterSize) + timestampBytes + groupPrefixBytes + blockPrefixBytes + blockHeaderBytes);
+    let at = head.writeUInt32BE(0x1f43b675, 0);
+    at = writeVint(head, at, clusterSize);
+    head[at++] = 0xe7;
+    at = writeVint(head, at, stampWidth);
+    at = writeUint(head, at, stamp, stampWidth);
+    head[at++] = 0xa0;
+    at = writeVint(head, at, groupSize);
+    head[at++] = 0xa1;
+    at = writeVint(head, at, blockSize);
+    at = writeVint(head, at, selected + 1);
+    head[at++] = 0; head[at++] = 0; head[at++] = 0;
+    yield head;
     for (const slice of slices) yield slice;
-    if (afterBlock.length) yield afterBlock;
+    if (afterBytes > 0) {
+      const after = Buffer.allocUnsafe(afterBytes);
+      let offset = 0;
+      if (duration > 0) {
+        after[offset++] = 0x9b;
+        offset = writeVint(after, offset, durationWidth);
+        offset = writeUint(after, offset, duration, durationWidth);
+      }
+      if (padding !== null) {
+        offset = after.writeUInt16BE(0x75a2, offset);
+        offset = writeVint(after, offset, 8);
+        offset = after.writeBigInt64BE(BigInt(padding), offset);
+      }
+      if (!packet.keyframe) { after[offset++] = 0xfb; after[offset++] = 0x81; after[offset++] = 0; }
+      yield after;
+    }
   }
 }
 
@@ -128,31 +164,52 @@ function matroskaCodec(codec) {
   return declared;
 }
 
-function vint(value) {
+/** How many bytes an EBML size of this value takes: the narrowest whose all-ones value it is below. */
+function vintWidth(value) {
   if (!Number.isSafeInteger(value) || value < 0) throw new TypeError("EBML value is outside its integer range.");
-  for (let width = 1; width <= 8; width++) {
-    if (BigInt(value) >= (1n << BigInt(7 * width)) - 1n) continue;
-    const encoded = Buffer.alloc(width);
-    let bits = BigInt(value) | (1n << BigInt(7 * width));
-    for (let at = width - 1; at >= 0; at--) { encoded[at] = Number(bits & 255n); bits >>= 8n; }
-    return encoded;
+  // 2 ** 56 - 1 is above every safe integer, so eight bytes always hold one.
+  for (let width = 1; width < 8; width++) if (value < 2 ** (7 * width) - 1) return width;
+  return 8;
+}
+
+/** The value as an EBML size at `at`, its width's marker bit set; the next offset. */
+function writeVint(target, at, value) {
+  const width = vintWidth(value);
+  writeUint(target, at, value, width);
+  target[at] |= 1 << (8 - width);
+  return at + width;
+}
+
+/** How many bytes an unsigned integer takes, one at least. */
+function uintWidth(value) {
+  let width = 1;
+  for (let rest = Math.floor(value / 256); rest > 0; rest = Math.floor(rest / 256)) width += 1;
+  return width;
+}
+
+/** The value big-endian in `width` bytes at `at`; the next offset. */
+function writeUint(target, at, value, width) {
+  let rest = value;
+  for (let index = width - 1; index >= 0; index--) {
+    target[at + index] = rest % 256;
+    rest = Math.floor(rest / 256);
   }
-  throw new TypeError("EBML value has no valid width.");
+  return at + width;
+}
+
+function vint(value) {
+  const encoded = Buffer.alloc(vintWidth(value));
+  writeVint(encoded, 0, value);
+  return encoded;
 }
 
 function prefix(id, size) { return Buffer.concat([Buffer.from(id, "hex"), vint(size)]); }
 function element(id, payload) { return Buffer.concat([prefix(id, payload.length), payload]); }
 function textElement(id, text) { return element(id, Buffer.from(text, "utf8")); }
-function signedElement(id, value) {
-  if (!Number.isSafeInteger(value)) throw new TypeError("EBML signed integer is outside its exact range.");
-  const bytes = Buffer.alloc(8);
-  bytes.writeBigInt64BE(BigInt(value));
-  return element(id, bytes);
-}
 function uintElement(id, value) {
   if (!Number.isSafeInteger(value) || value < 0) throw new TypeError("EBML unsigned integer is invalid.");
-  let bits = BigInt(value);
-  const bytes = [];
-  do { bytes.unshift(Number(bits & 255n)); bits >>= 8n; } while (bits > 0n);
-  return element(id, Buffer.from(bytes));
+  const width = uintWidth(value);
+  const bytes = Buffer.alloc(width);
+  writeUint(bytes, 0, value, width);
+  return element(id, bytes);
 }

package/services/viewer/playback-pass.js

@@ -22,18 +22,30 @@
  *   behind?: boolean, deferred?: boolean, from: number, to: number,
  *   sourceInterval?: { from: number, to: number } }>} params.demands - In the
  *   order of their deadlines.
- * @returns {{ outputs: string[], inputs: number[] }}
+ * @returns {{ outputs: string[], inputs: Float64Array }}
  */
 export function passInputs({ pieceLength, shift, targets, demands }) {
   const outputs = [...targets.keys()];
-  const inputs = [pieceLength, shift];
-  for (const target of targets.values()) inputs.push(target ?? -1);
+  const position = new Map(outputs.map((outputKey, at) => [outputKey, at]));
+  // Numbers in a list made to its length: grown a value at a time, eight for
+  // each of a film's 3500 segments, it was most of what comparing a pass cost
+  // (r30, torrent-tv/meta#178).
+  const inputs = new Float64Array(2 + targets.size + demands.length * 8);
+  let at = 0;
+  inputs[at++] = pieceLength;
+  inputs[at++] = shift;
+  for (const target of targets.values()) inputs[at++] = target ?? -1;
   for (const demand of demands) {
     // The segment's own interval too: a cut grid read again can give one
     // number other bytes.
-    inputs.push(outputs.indexOf(demand.outputKey), demand.index, demand.priority,
-      (demand.urgent ? 1 : 0) + (demand.behind ? 2 : 0) + (demand.deferred ? 4 : 0),
-      demand.from, demand.to, demand.sourceInterval?.from ?? -1, demand.sourceInterval?.to ?? -1);
+    inputs[at++] = position.get(demand.outputKey) ?? -1;
+    inputs[at++] = demand.index;
+    inputs[at++] = demand.priority;
+    inputs[at++] = (demand.urgent ? 1 : 0) + (demand.behind ? 2 : 0) + (demand.deferred ? 4 : 0);
+    inputs[at++] = demand.from;
+    inputs[at++] = demand.to;
+    inputs[at++] = demand.sourceInterval?.from ?? -1;
+    inputs[at++] = demand.sourceInterval?.to ?? -1;
   }
   return { outputs, inputs };
 }
@@ -41,8 +53,8 @@ export function passInputs({ pieceLength, shift, targets, demands }) {
 /**
  * Whether a pass is worked out from what an earlier one was.
  *
- * @param {{ tracks: unknown, outputs: string[], inputs: number[] } | undefined} last
- * @param {{ tracks: unknown, outputs: string[], inputs: number[] }} next
+ * @param {{ tracks: unknown, outputs: string[], inputs: ArrayLike<number> } | undefined} last
+ * @param {{ tracks: unknown, outputs: string[], inputs: ArrayLike<number> }} next
  * @returns {boolean}
  */
 export function samePass(last, next) {

package/services/viewer/segment-demands.js

@@ -22,28 +22,27 @@ export function segmentDemands(output, fileIndex, zones) {
   for (let index = 0; index + 1 < grid.length; index++) {
     const from = grid[index], to = grid[index + 1];
     if (!Number.isFinite(from) || !Number.isFinite(to) || !(to > from)) throw new Error("An output segment needs a valid interval.");
-    let overlapping;
-    if (ordered) {
-      while (first < zones.length && zones[first].to <= from) first += 1;
-      overlapping = [];
-      for (let at = first; at < zones.length && zones[at].from < to; at += 1) {
-        if (zones[at].priority > 0) overlapping.push(zones[at]);
-      }
-    } else {
-      overlapping = zones.filter(zone => zone.priority > 0 && zone.from < to && zone.to > from);
+    if (ordered) while (first < zones.length && zones[first].to <= from) first += 1;
+    // The zones a segment overlaps are folded as they are met, into numbers:
+    // a list of them, and the lists made of it for each field, were five
+    // arrays for every segment of a film on every pass (r30,
+    // torrent-tv/meta#178).
+    let owner = null, ownerDeadline = Infinity, priority = 0, urgent = false, behind = true, deferred = true;
+    for (let at = ordered ? first : 0; at < zones.length; at += 1) {
+      const zone = zones[at];
+      if (ordered && !(zone.from < to)) break;
+      if (!(zone.priority > 0) || !(zone.from < to && zone.to > from)) continue;
+      // A zone states the deadline of its near edge. A later segment within it
+      // is reached later, at one second of film per second of playback.
+      const deadline = Number.isFinite(zone.deadlineAt) ? zone.deadlineAt + Math.max(0, from - zone.from) * 1000 : Infinity;
+      if (owner === null || deadline < ownerDeadline) { owner = zone; ownerDeadline = deadline; }
+      if (zone.priority > priority) priority = zone.priority;
+      if (zone.urgent) urgent = true;
+      if (!zone.behind) behind = false;
+      if (!zone.deferred) deferred = false;
     }
-    if (!overlapping.length) continue;
-    // A zone states the deadline of its near edge. A later segment within it
-    // is reached later, at one second of film per second of playback.
-    const deadlineOf = zone => Number.isFinite(zone.deadlineAt)
-      ? zone.deadlineAt + Math.max(0, from - zone.from) * 1000 : Infinity;
-    const owner = overlapping.reduce((first, zone) => deadlineOf(zone) < deadlineOf(first) ? zone : first);
-    demands.push({ index, from, to, tracks, owner,
-      priority: Math.max(...overlapping.map(zone => zone.priority)),
-      urgent: overlapping.some(zone => zone.urgent),
-      behind: overlapping.every(zone => zone.behind),
-      deferred: overlapping.every(zone => zone.deferred),
-      deadlineAt: Math.min(...overlapping.map(deadlineOf)) });
+    if (owner === null) continue;
+    demands.push({ index, from, to, tracks, owner, priority, urgent, behind, deferred, deadlineAt: ownerDeadline });
   }
   return demands.sort((left, right) => left.deadlineAt - right.deadlineAt || right.priority - left.priority || left.index - right.index);
 }