@torrent-tv/proxy 2.80.15 → 2.80.16

package/CHANGELOG.md

@@ -1,14 +1,15 @@
+## 2.80.16
+
+- **Fix**: THE SPINNER CARAVAN, by arithmetic alone, and the two props 2.80.15 carried are gone with it — the threshold that made a move pay for itself, and the exclusion that kept a live run off a deadline-less zone. Both were propping up a comparison that was wrong rather than indifferent. Three quantities were computed wrongly:
+  1. **A body was charged a whole piece for the one it was already making.** `arrival = delay + (index - at + 1) / rate` is right for a body that does not exist yet and wrong for a run 0.8 s into a 0.9 s piece. `delaySec` is now when a body finishes the piece it STANDS ON — for a run that has produced something, one piece; for one still warming up, the measured time to a first piece less the time it has been alive. From #58, reaching #59 costs 0.14 + 0.94 = 1.08 s against 1.88 s for a kill and a cold start: a decision by eight hundred milliseconds, where the double charge had made it a coin flip lost by ten.
+  2. **The piece was priced at the unpenalised rate** while arrivals used the penalised one, so every extra body looked cheaper than it is and the plan bought a second encoder where one served. One rate now, the one the arrangement itself puts in force, and each body states its own debt as a function of it — so there is nothing to dispatch on.
+- **Fix**: What a move costs is `Infinity` until something has been measured, because a move is irreversible while leaving the encoder alone is always available; placing one where there is none takes the unknown the other way, since the film gets made or it does not. And a run killed before producing anything is a measurement too — a lower bound on the first output — which is the only reading a thrash can supply, since every run in one is killed before it finishes anything.
+- **Chore**: Verified by simulation over sixty ticks against the map's real shape — one encoder placed, left alone, and moved exactly once, at the viewer's own seek. NOT yet seen in the field.
+
 ## 2.80.15
 
-- **Fix**: THE SPINNER CARAVAN, and its cause was one coercion. The priority map states `withinSeconds: null` for the film BEHIND the viewers — nobody is waiting there — and `deadlineReaderFor` read it through `Number()`, where `null` is 0. So the film a viewer had already passed was due IMMEDIATELY and was the most urgent material in the file. It bought encoders, and it took the run standing in front of the viewer because that run was the nearest body to it, and it did so again on every pass. Field 2026-09-08: 39 moves in one session, 24 of them between three adjacent numbers about 0.8 s apart, one viewer on a host affording three runs got three, and the picture stood still for 116.7 s in three interruptions, the worst 91.8 s. The map has said it plainly in every session's log; this line turned it into its opposite. Fourth time in this repository that the input to a calculation was not what the calculation assumed.
-- **Fix**: The objective is the map's OWN rank order, as a vector compared position by position — one pair per rank the map states, most urgent first: how long anybody waits at that rank, then when the last number of it is made. It was three seconds-valued terms with the ten ranks collapsed into two buckets, and "never" for the film behind is the film's own length — 2024 s on a 48-minute file — which outvotes everything above it. No weights, and none possible: a weight would let seconds at one rank buy seconds at another and would be a number nobody measured. The map is the source of truth about what matters and it already says so.
-- **Fix**: Residual work takes only spare capacity. A zone stating no deadline has nobody waiting in it, so a live run already standing in front of a viewer is never taken for it — taking it there means killing it, and the viewer waits out a cold start for film nobody asked for.
-- **Fix**: An act must pay for itself. Where an arrangement is only reachable by killing a running encoder, a gain smaller than what that killing costs is not a gain. The field numbers are that close: driving from #58 to #59 means making two pieces, 1.89 s at 4.45x on a 4.2 s grid, against a cold start and one piece, 1.88 s — the move was faster by ten milliseconds, and every one of the 39 was individually correct. The margin is the measured cost of the act, never a chosen figure.
-- **Fix**: The plan remembers what it is already carrying out. A staying run was priced as producing instantly however recently it had started; it is now priced at what it still has to go — the measured time to a first piece less the time it has been alive. A run 0.8 s old has 0.14 s left against 0.94 s to move it. One measured figure minus elapsed time, no state to keep.
-- **Fix**: What a move costs is `Infinity` until something has been measured, because a move is irreversible and leaving the encoder alone is always available; placing one where there is none takes the unknown the other way, since the film gets made or it does not. And a run killed before producing anything is a measurement too — a lower bound on the first output — which is the only reading a thrash can supply, since every run in one is killed before it finishes anything.
-- **Fix**: The average bitrate declared in the master came from a field that does not exist on a source file, so every variant was declared at the 400 kbit/s floor in 2.80.14 — nine times worse than the rule of thumb it replaced. It is read from where it is known: the torrent's own report of the file's length, with the probe's reading of the video stream covering the gap before that arrives.
-- **New**: The piece store's own line names its holders, and `AHEAD` no longer reaches memory.
-- **Chore**: `hls-session-manager.js` grew by four lines of wiring in its constructor, which the rule for that file does not allow. Stated rather than shuffled: the thing itself moved to `output/`, and what is left is two accessors handed over where wiring belongs.
+- **Fix**: THE SPINNER CARAVAN, first attempt. Field 2026-09-08: 39 encoder moves in one session, 24 of them between three adjacent numbers about 0.8 s apart, one viewer on a host affording three runs got three, and the picture stood still for 116.7 s in three interruptions, the worst 91.8 s. This release fixed the reading of `withinSeconds: null` — the map marks the film BEHIND the viewers with it, meaning nobody is waiting there, and `deadlineReaderFor` read it through `Number()`, where it is 0, so that film was due IMMEDIATELY and was the most urgent material in the file. It also made the objective the map's own rank order, as a vector compared position by position rather than three seconds-valued terms with ten ranks collapsed into two buckets.
+- **Chore**: It also carried two props that 2.80.16 removes — a threshold requiring a move to beat staying by what moving costs, and an exclusion keeping a live run off any zone with no deadline. Both were written while the arrival arithmetic was still wrong; neither belongs in a model.
 
 ## 2.80.14
 

package/docs/encode-architecture.md

@@ -214,44 +214,58 @@ tail, p1 for what lies behind them.
 encoder where the map is indifferent. `wasted` is the swarm's bill for anything
 fetched twice.
 
-## Three rules that stop an encoder being moved for nothing
-
-**A zone with no deadline never takes a live run.** Residual work — the film
-behind the viewers, kept in case somebody seeks back — is done with capacity
-that is left over, and a run already standing in front of a viewer is not left
-over.
-
-**An act must pay for itself.** Where an arrangement is only reachable by killing
-a running encoder, a gain smaller than what the killing costs is not a gain. The
-margin is the measured cost of the act.
-
-**The plan remembers what it is already carrying out.** A staying run is priced
-at what it still has to go — the measured time to a first piece less the time it
-has been alive — not at zero. A run 0.8 s old has 0.14 s left against 0.94 s to
-move it; one working half a minute has nothing left, and a move then happens
-exactly when the film it would reach sooner is worth the restart.
-
-And what a move costs is `Infinity` until something has been measured: a move is
-irreversible and leaving the encoder alone is always available. Placing one where
-there is none takes the unknown the other way, because the film gets made or it
-does not.
-
-### What all three were for
-
-Field 2026-09-08. The map states `withinSeconds: null` for the film behind the
-viewers; `deadlineReaderFor` read it through `Number()`, where `null` is 0, so
-that film was due IMMEDIATELY and was the most urgent material in the file. It
-bought encoders and it took the run standing in front of the viewer, because
-that run was the nearest body to it — 39 moves in one session, 24 of them between
-three adjacent numbers about 0.8 s apart. One viewer on a host affording three
-runs got three. The picture stood still for 116.7 s in three interruptions, the
-worst of them 91.8 s.
-
-The numbers are worth keeping because they are so close: driving from #58 to #59
-means making TWO pieces, 1.89 s at 4.45x on a 4.2 s grid, against a cold start
-and ONE piece, 0.94 + 0.94 = 1.88 s. Every one of those 39 moves was
-individually the cheapest arrangement it was offered. That is the signature of an
-optimiser with no memory, and the three rules above are what give it one.
+## Why an encoder is not moved for nothing, and it is not a rule
+
+There is no threshold here, and there must not be one. What kept an encoder
+moving was three quantities computed wrongly, not a policy that needed tuning.
+
+**`delaySec` is when a body finishes the piece it STANDS ON.** For a run that has
+produced something, one piece at the rate in force; for one still warming up, the
+measured time to a first piece less the time it has already been alive. The
+arrival of anything further on is that plus the pieces between, and nothing else.
+
+It used to be `delay + (index - at + 1) / rate`, which charges every body a whole
+piece for the one it is already making. That is right for a body that does not
+exist yet and wrong for a run 0.8 s into a 0.9 s piece — and the difference is
+the whole fault: from #58, reaching #59 was priced at 1.89 s against 1.88 s for a
+kill and a cold start, a coin flip lost by ten milliseconds. Priced correctly it
+is 1.08 s against 1.88 s.
+
+**One rate, the one the arrangement puts in force.** Concurrent encoders slow
+each other, measured on this host, so a piece costs what it costs at the body
+count the arrangement has. Taken from the unpenalised rate while arrivals used
+the penalised one, an extra body looked cheaper than it is and the plan bought a
+second encoder where one served.
+
+**Each body states its own debt** where it is created, as a function of what one
+piece costs — because only there is it known what the body IS, and at the point
+of pricing only how many there are. So there is no kind, no tag and no case
+analysis.
+
+**What a move costs is `Infinity` until something has been measured**, because a
+move is irreversible while leaving the encoder alone is always available. Placing
+one where there is none takes the unknown the other way: the film gets made or it
+does not. And a run killed before producing anything is a measurement too — a
+lower bound on the first output, and the only reading a thrash can supply, since
+every run in one is killed before it finishes anything.
+
+### What that was for
+
+Field 2026-09-08: 39 moves in one session, 24 of them between three adjacent
+numbers about 0.8 s apart. One viewer on a host affording three runs got three.
+The picture stood still for 116.7 s in three interruptions, the worst 91.8 s.
+
+Compounding it, the map states `withinSeconds: null` for the film behind the
+viewers — nobody is waiting there — and `deadlineReaderFor` read that through
+`Number()`, where `null` is 0. So the film a viewer had already passed was due
+IMMEDIATELY and was the most urgent material in the file: it bought encoders, and
+it took the run standing in front of the viewer because that run was the nearest
+body to it.
+
+Checked by simulation over sixty ticks against the map's real shape — ten zones
+doubling ahead of the viewer, one behind — at both one and three runs: the
+encoder is placed once, left alone, and moved exactly once, at the viewer's own
+seek.
 
 ## What is checked
 

package/package.json

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