dsh-fonttune 0.7.6 → 0.7.7

package/CHANGELOG.en.md

@@ -2,6 +2,15 @@
 
 All notable changes to **dsh-fonttune** are documented here. Chinese version: [CHANGELOG.md](CHANGELOG.md).
 
+## [0.7.7] - 2026-11-05
+
+### Fixed
+- **The stall when opening the font settings**: the weight notches are now measured in steps that stay out of the settings page's open and refresh, and a family is measured once — later opens read the result instead of measuring again.
+- **A long unresponsive page with some very large font collections**: when the font file is exceptionally large the measurement falls back to coarse notches after a time limit instead of holding the interface for a long time.
+
+### Changed
+- **DSH 0.2.2-rc.1 is supported**: the compatibility table in the README and the plugin manifest now list 0.2.1-rc.3, 0.2.1-rc.5 and 0.2.2-rc.1.
+
 ## [0.7.6] - 2026-11-04
 
 ### Fixed

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 **dsh-fonttune** 的重要变更都记录在这里。英文版见 [CHANGELOG.en.md](CHANGELOG.en.md)。
 
+## [0.7.7] - 2026-11-05
+
+### 修复
+- **打开字体设置时的卡顿**：字体档位的测量改为分步进行，并避开设置页面的打开与刷新；同一套字体只需测量一次，之后打开设置不再重新计算。
+- **部分超大字体集合下的长时间无响应**：字体文件特别大时，测量会在超时后改用粗略档位，不再长时间占住界面。
+
+### 变更
+- **兼容 DSH 0.2.2-rc.1**：README 的兼容表与插件清单同步补上 0.2.1-rc.3、0.2.1-rc.5 与 0.2.2-rc.1。
+
 ## [0.7.6] - 2026-11-04
 
 ### 修复

package/README.en.md

@@ -39,7 +39,7 @@ The floating tuning panel (left, with its "in force right now" readout) and the
 
 | Plugin version | Supported DSH versions |
 | --- | --- |
-| **0.7.x** (latest, 0.7.3) | 0.1.7-alpha.1, 0.1.7-alpha.2, 0.1.7-rc.1, 0.1.7-rc.2, 0.2.0-rc.1, 0.2.0-rc.2, 0.2.1-alpha.1, 0.2.1-alpha.2, 0.2.1-alpha.3, 0.2.1-alpha.4, 0.2.1-alpha.5, 0.2.1-rc.1, 0.2.1-rc.2, 0.2.1-rc.4, 0.2.2-alpha.2 |
+| **0.7.x** (latest, 0.7.7) | 0.1.7-alpha.1, 0.1.7-alpha.2, 0.1.7-rc.1, 0.1.7-rc.2, 0.2.0-rc.1, 0.2.0-rc.2, 0.2.1-alpha.1, 0.2.1-alpha.2, 0.2.1-alpha.3, 0.2.1-alpha.4, 0.2.1-alpha.5, 0.2.1-rc.1, 0.2.1-rc.2, 0.2.1-rc.4, 0.2.2-alpha.2, 0.2.1-rc.3, 0.2.1-rc.5, 0.2.2-rc.1 |
 | 0.6.x (0.6.2) | 0.1.7-alpha.1, 0.1.7-alpha.2, 0.1.7-rc.1, 0.1.7-rc.2, 0.2.0-rc.1, 0.2.0-rc.2, 0.2.1-alpha.1, 0.2.1-alpha.2, 0.2.1-alpha.3, 0.2.1-alpha.4, 0.2.1-alpha.5, 0.2.1-rc.1, 0.2.1-rc.2 |
 | 0.5.x (0.5.0) | 0.1.7-alpha.1, 0.1.7-alpha.2, 0.1.7-rc.1, 0.1.7-rc.2, 0.2.0-rc.1, 0.2.0-rc.2, 0.2.1-alpha.1, 0.2.1-alpha.2 |
 | 0.4.x (0.4.2) | 0.1.7-alpha.1, 0.1.7-alpha.2, 0.1.7-rc.1, 0.1.7-rc.2, 0.2.0-rc.1, 0.2.0-rc.2, 0.2.1-alpha.1, 0.2.1-alpha.2 |

package/README.md

@@ -39,7 +39,7 @@
 
 | 插件版本 | 支持的 DSH 版本 |
 | --- | --- |
-| **0.7.x**（最新，0.7.3） | 0.1.7-alpha.1、0.1.7-alpha.2、0.1.7-rc.1、0.1.7-rc.2、0.2.0-rc.1、0.2.0-rc.2、0.2.1-alpha.1、0.2.1-alpha.2、0.2.1-alpha.3、0.2.1-alpha.4、0.2.1-alpha.5、0.2.1-rc.1、0.2.1-rc.2、0.2.1-rc.4、0.2.2-alpha.2 |
+| **0.7.x**（最新，0.7.7） | 0.1.7-alpha.1、0.1.7-alpha.2、0.1.7-rc.1、0.1.7-rc.2、0.2.0-rc.1、0.2.0-rc.2、0.2.1-alpha.1、0.2.1-alpha.2、0.2.1-alpha.3、0.2.1-alpha.4、0.2.1-alpha.5、0.2.1-rc.1、0.2.1-rc.2、0.2.1-rc.4、0.2.2-alpha.2、0.2.1-rc.3、0.2.1-rc.5、0.2.2-rc.1 |
 | 0.6.x（0.6.2） | 0.1.7-alpha.1、0.1.7-alpha.2、0.1.7-rc.1、0.1.7-rc.2、0.2.0-rc.1、0.2.0-rc.2、0.2.1-alpha.1、0.2.1-alpha.2、0.2.1-alpha.3、0.2.1-alpha.4、0.2.1-alpha.5、0.2.1-rc.1、0.2.1-rc.2 |
 | 0.5.x（0.5.0） | 0.1.7-alpha.1、0.1.7-alpha.2、0.1.7-rc.1、0.1.7-rc.2、0.2.0-rc.1、0.2.0-rc.2、0.2.1-alpha.1、0.2.1-alpha.2 |
 | 0.4.x（0.4.2） | 0.1.7-alpha.1、0.1.7-alpha.2、0.1.7-rc.1、0.1.7-rc.2、0.2.0-rc.1、0.2.0-rc.2、0.2.1-alpha.1、0.2.1-alpha.2 |

package/lib/client.js

@@ -3476,6 +3476,70 @@ function balancedStackShape(entries, base, low, high, spread) {
   return best;
 }
 
+/**
+ * The FIRST weight of an arithmetic grid whose rendering matches a signature.
+ *
+ * The probe grid is monotone: below a family's lightest face every weight renders
+ * the same (the lightest face), above its heaviest face every weight renders the
+ * same (the heaviest face), and in between it walks the faces. So "renders like the
+ * ceiling" is a predicate that is false, then true, and its boundary is worth
+ * `log2` samples instead of one render per grid point — which is what the two
+ * horizon scans used to cost (eighty-one renders per family, issue #3).
+ * @param {(weight: number) => string|number} sample - renders a probe at one weight.
+ * @param {string|number} signature - the signature the boundary shares.
+ * @param {number} low - first weight of the grid.
+ * @param {number} high - last weight of the grid.
+ * @param {number} step - spacing of the grid.
+ * @param {number|null} fallback - returned when no grid weight matches.
+ * @returns {number|null} the weight, or the fallback.
+ */
+function firstGridWeight(sample, signature, low, high, step, fallback) {
+  var count = Math.floor((high - low) / step) + 1;
+  if (count < 1 || !(step > 0)) return fallback;
+  var at = function (index) {
+    return low + index * step;
+  };
+  if (sample(at(count - 1)) !== signature) return fallback;
+  var first = 0;
+  var last = count - 1;
+  while (first < last) {
+    var middle = (first + last) >> 1;
+    if (sample(at(middle)) === signature) last = middle;
+    else first = middle + 1;
+  }
+  return at(first);
+}
+
+/**
+ * The LAST weight of an arithmetic grid whose rendering matches a signature.
+ *
+ * The mirror of `firstGridWeight`: "renders like the floor" is true, then false,
+ * so the boundary is found from the other end.
+ * @param {(weight: number) => string|number} sample - renders a probe at one weight.
+ * @param {string|number} signature - the signature the boundary shares.
+ * @param {number} low - first weight of the grid.
+ * @param {number} high - last weight of the grid.
+ * @param {number} step - spacing of the grid.
+ * @param {number|null} fallback - returned when no grid weight matches.
+ * @returns {number|null} the weight, or the fallback.
+ */
+function lastGridWeight(sample, signature, low, high, step, fallback) {
+  var count = Math.floor((high - low) / step) + 1;
+  if (count < 1 || !(step > 0)) return fallback;
+  var at = function (index) {
+    return low + index * step;
+  };
+  if (sample(at(0)) !== signature) return fallback;
+  var first = 0;
+  var last = count - 1;
+  while (first < last) {
+    var middle = (first + last + 1) >> 1;
+    if (sample(at(middle)) === signature) first = middle;
+    else last = middle - 1;
+  }
+  return at(first);
+}
+
 /**
  * One slider shape for a stack whose text can land on more than one family.
  *
@@ -3637,30 +3701,38 @@ function weightProfileFrom(sample, options) {
   var top = typeof settings.top === "number" ? settings.top : WEIGHT_LADDER_STRONG;
   var topSignature = sample(WEIGHT_PROBE_HIGH);
   var bottomSignature = sample(WEIGHT_PROBE_LOW);
-  var heaviest = WEIGHT_PROBE_HIGH;
-  for (var weight = WEIGHT_PROBE_LOW; weight <= WEIGHT_PROBE_HIGH; weight += WEIGHT_PROBE_STEP) {
-    if (sample(weight) === topSignature) {
-      heaviest = weight;
-      break;
-    }
-  }
-  var lightest = WEIGHT_PROBE_LOW;
-  for (var back = WEIGHT_PROBE_HIGH; back >= WEIGHT_PROBE_LOW; back -= WEIGHT_PROBE_STEP) {
-    if (sample(back) === bottomSignature) {
-      lightest = back;
-      break;
-    }
-  }
+  // The two horizons used to be found by walking the whole probe grid from one end
+  // — eighty-one canvas renders per family, and on a font collection of a few
+  // hundred megabytes each render is the browser rasterizing a new weight (issue
+  // #3: seconds of blocked main thread). The grid is monotone in weight: everything
+  // from a family's heaviest face UP renders the same, so the horizon is a
+  // boundary, and a bisection finds it in seven samples instead of eighty-one.
+  var heaviest = firstGridWeight(
+    sample,
+    topSignature,
+    WEIGHT_PROBE_LOW,
+    WEIGHT_PROBE_HIGH,
+    WEIGHT_PROBE_STEP,
+    WEIGHT_PROBE_HIGH
+  );
+  var lightest = lastGridWeight(
+    sample,
+    bottomSignature,
+    WEIGHT_PROBE_LOW,
+    WEIGHT_PROBE_HIGH,
+    WEIGHT_PROBE_STEP,
+    WEIGHT_PROBE_LOW
+  );
   // How far the offset can go before NO layer that must move can move any more:
   // the widest horizon among those bases, since a layer that could still change
   // must not be cut off by one that already sits at its heaviest face.
   var headroom = Math.max(0, heaviest - WEIGHT_BASE);
   if (top !== WEIGHT_BASE) {
-    for (var up = top; up <= WEIGHT_PROBE_HIGH; up += WEIGHT_PROBE_STEP) {
-      if (sample(up) === topSignature) {
-        headroom = Math.max(headroom, up - top);
-        break;
-      }
+    // Same boundary, same bisection: the first weight at or above the heavy base
+    // that already renders at the ceiling.
+    var reached = firstGridWeight(sample, topSignature, top, WEIGHT_PROBE_HIGH, WEIGHT_PROBE_STEP, null);
+    if (reached !== null) {
+      headroom = Math.max(headroom, reached - top);
     }
   }
   var reachUp = Math.min(ceil, WEIGHT_DELTA_UP_LIMIT, headroom);
@@ -6483,6 +6555,18 @@ var weightProbeCanvas = null;
 /** Cache of measured slider shapes, keyed by the resolved family stack. */
 var weightProfileCache = {};
 
+/**
+ * How slow one canvas render may be before the font is treated as too heavy to
+ * sweep in detail (a few-hundred-megabyte collection answers in tens of ms).
+ */
+var SLOW_SAMPLE_MS = 40;
+
+/** How long after load the code axis is measured (the other two go first). */
+var WARM_CODE_DELAY_MS = 2500;
+
+/** Thrown by the guarded sampler to abandon the fine sweep on a slow font. */
+var WEIGHT_TOO_SLOW = { tooSlow: true };
+
 /**
  * The families a stack can actually render text with.
  *
@@ -6561,6 +6645,15 @@ function familyWeightProfile(family, base, alias, inkText) {
     return familyProfileCache[key];
   }
   var record = null;
+  // A font collection of a few hundred megabytes makes EVERY render expensive (the
+  // browser re-parses the collection for a weight it has not drawn yet), and the
+  // sweep asks for a dozen of them in a row — measured at 20-50 ms each on such a
+  // file, i.e. a second of blocked main thread per family (issue #3). One render
+  // that costs more than SLOW_SAMPLE_MS is enough evidence: abandon the fine sweep
+  // and answer with a coarse one, so the worst case stays bounded instead of
+  // growing with the file size.
+  var slow = false;
+  var guarded = null;
   try {
     var target = '"' + (alias === "" ? family : alias) + '"';
     var seen = {};
@@ -6570,10 +6663,16 @@ function familyWeightProfile(family, base, alias, inkText) {
       }
       return seen[weight];
     };
+    guarded = function (weight) {
+      var started = Date.now();
+      var signature = sample(weight);
+      if (Date.now() - started >= SLOW_SAMPLE_MS) throw WEIGHT_TOO_SLOW;
+      return signature;
+    };
     var shape =
       alias === ""
-        ? weightProfileFrom(sample, { top: base })
-        : weightProfileFrom(sample, { top: base, candidates: shared.CONTINUOUS_CANDIDATES });
+        ? weightProfileFrom(guarded, { top: base })
+        : weightProfileFrom(guarded, { top: base, candidates: shared.CONTINUOUS_CANDIDATES });
     record = { min: shape.min, max: shape.max, step: shape.step, inkOf: null };
     if (text !== null) {
       var inks = {};
@@ -6585,7 +6684,31 @@ function familyWeightProfile(family, base, alias, inkText) {
       };
     }
   } catch (error) {
-    record = null;
+    if (error !== WEIGHT_TOO_SLOW) {
+      record = null;
+    } else {
+      // Too slow for the fine sweep: nine renders on the hundred grid describe the
+      // family coarsely, which is still a control that moves in visible steps. No
+      // ink comparison — that would be a second sweep of the same price.
+      slow = true;
+    }
+  }
+  if (slow) {
+    try {
+      var coarseSeen = {};
+      var coarse = weightProfileFrom(
+        function (weight) {
+          if (!Object.prototype.hasOwnProperty.call(coarseSeen, weight)) {
+            coarseSeen[weight] = sampleWeightSignature(target, Math.round(weight / 100) * 100);
+          }
+          return coarseSeen[weight];
+        },
+        { top: base, candidates: [100] }
+      );
+      record = { min: coarse.min, max: coarse.max, step: coarse.step, inkOf: null };
+    } catch (error) {
+      record = null;
+    }
   }
   familyProfileCache[key] = record;
   return record;
@@ -6965,6 +7088,123 @@ function inkOfSignature(signature) {
   return isFinite(ink) ? ink : 0;
 }
 
+/**
+ * Where a measured slider shape survives a page reload.
+ *
+ * Measuring one axis is around eighty canvas renders per family, and the cost per
+ * render is the browser rasterizing a weight it has never drawn (measured: ~3 ms
+ * for an 18 MB family, ~6 ms for a 35 MB one, and seconds per render on a font
+ * collection of a few hundred megabytes — issue #3). The answer only changes when
+ * the reader changes the fonts, so it is kept: the first visit pays, every later
+ * one opens instantly. The TTL bounds how long a font file that was replaced
+ * under the same family name may go unnoticed.
+ */
+var SHAPE_STORE_KEY = "dsh-fonttune:weight-shapes:v1";
+var SHAPE_STORE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+var SHAPE_STORE_LIMIT = 32;
+
+/**
+ * What a slider shows while its measurement has not landed yet.
+ *
+ * The nominal offset window, unit one: the same answer the code already gives when
+ * a family cannot be measured at all, so nothing new appears in the document and a
+ * stored offset stays reachable. Rendering is what used to MEASURE (a cold cache at
+ * open = eighty canvas renders on the main thread), which is the "opening the
+ * settings freezes" of issue #3; the real counts replace these the moment the idle
+ * measurement finishes and the card redraws.
+ */
+var PENDING_WEIGHT_SHAPE = { min: WEIGHT_DELTA_MIN, max: WEIGHT_DELTA_MAX, step: 1 };
+
+/** The decoded store, or an empty one when storage is unavailable. */
+var shapeStore = null;
+
+/**
+ * The persistent shape store, read once.
+ * @returns {Object} key -> `{min, max, step, at}`.
+ */
+function readShapeStore() {
+  if (shapeStore !== null) return shapeStore;
+  shapeStore = {};
+  try {
+    var raw = globalThis.localStorage.getItem(SHAPE_STORE_KEY);
+    var parsed = raw === null ? null : JSON.parse(raw);
+    if (parsed !== null && typeof parsed === "object") {
+      for (var key in parsed) {
+        if (!Object.prototype.hasOwnProperty.call(parsed, key)) continue;
+        var entry = parsed[key];
+        if (entry === null || typeof entry !== "object") continue;
+        if (!isFinite(entry.min) || !isFinite(entry.max) || !isFinite(entry.step)) continue;
+        if (!(entry.step > 0) || !isFinite(entry.at)) continue;
+        shapeStore[key] = { min: entry.min, max: entry.max, step: entry.step, at: entry.at };
+      }
+    }
+  } catch (error) {
+    // Private mode, a disabled store, a corrupted value: measuring still works.
+  }
+  return shapeStore;
+}
+
+/**
+ * The stored shape for one cache key, when it is still fresh.
+ * @param {string} key - the same key the memory cache uses.
+ * @returns {{min: number, max: number, step: number}|null} the shape, or null.
+ */
+function storedWeightShape(key) {
+  var store = readShapeStore();
+  if (!Object.prototype.hasOwnProperty.call(store, key)) return null;
+  var entry = store[key];
+  if (Date.now() - entry.at > SHAPE_STORE_TTL_MS) return null;
+  return { min: entry.min, max: entry.max, step: entry.step };
+}
+
+/**
+ * Keep one measured shape for the next page load.
+ *
+ * Writes the whole (small) map back, dropping the oldest entries past the limit:
+ * a reader who tries many browsing fonts must not grow this without bound.
+ * @param {string} key - the same key the memory cache uses.
+ * @param {{min: number, max: number, step: number}} profile - what was measured.
+ */
+function rememberWeightShape(key, profile) {
+  var store = readShapeStore();
+  store[key] = { min: profile.min, max: profile.max, step: profile.step, at: Date.now() };
+  var keys = Object.keys(store);
+  if (keys.length > SHAPE_STORE_LIMIT) {
+    keys.sort(function (left, right) {
+      return store[left].at - store[right].at;
+    });
+    for (var index = 0; index < keys.length - SHAPE_STORE_LIMIT; index += 1) {
+      delete store[keys[index]];
+    }
+  }
+  try {
+    globalThis.localStorage.setItem(SHAPE_STORE_KEY, JSON.stringify(store));
+  } catch (error) {
+    // A full or disabled store only costs the next load the measurement again.
+  }
+}
+
+/**
+ * What to redraw when a measurement lands after the first paint.
+ *
+ * The card renders the count of positions, which is a property of the font: a
+ * shape that arrives later (the idle warm-up, a slower family) has to reach the
+ * mounted cards or they would keep showing the provisional counts.
+ */
+var shapeListeners = [];
+
+/** Ask every mounted card to re-read the shapes. */
+function notifyShapes() {
+  var pending = shapeListeners.slice();
+  for (var index = 0; index < pending.length; index += 1) {
+    try {
+      pending[index]();
+    } catch (error) {
+      // A listener must never break the measurement that notified it.
+    }
+  }
+}
+
 /**
  * The slider shape to use for one family: its range and its notch.
  *
@@ -6972,15 +7212,19 @@ function inkOfSignature(signature) {
  * range is measured rather than fixed (`weightProfileFrom`), which also makes
  * every notch a change — for every layer of the ladder, so the measurement is
  * told which base is the heaviest one the offset lands on. Measured once per
- * family and base and cached; any failure (no canvas, no 2D context) falls back
- * to the nominal window with single units.
+ * family and base and cached, in memory and across page loads; any failure (no
+ * canvas, no 2D context) falls back to the nominal window with single units.
  * @param {string} stack - resolved `font-family` value, "" for the page default.
  * @param {number} [top] - the heaviest base the offset is added to; the ladder's
  *   own top for the conversation and interface axes, the axis's base for code.
+ * @param {{peek?: boolean}} [options] - `peek: true` never measures: it answers
+ *   with the stored shape when there is one and the provisional shape otherwise,
+ *   so a render can never block on a canvas sweep (see `PENDING_WEIGHT_SHAPE`).
  * @returns {{min: number, max: number, step: number}} the slider shape.
  */
-function weightProfileFor(stack, top) {
+function weightProfileFor(stack, top, options) {
   var base = typeof top === "number" ? top : shared.WEIGHT_LADDER_TOP;
+  var peek = options !== null && typeof options === "object" && options.peek === true;
   var resolved = String(stack) === "" ? liveFamily() : String(stack);
   // `hasOwnProperty` rather than a truthiness test: the alias map is keyed by family
   // name, and a family called "constructor" must not read as promoted.
@@ -6994,6 +7238,15 @@ function weightProfileFor(stack, top) {
   if (Object.prototype.hasOwnProperty.call(weightProfileCache, key)) {
     return weightProfileCache[key];
   }
+  // Measured on a previous visit: use it and skip the sweep entirely.
+  var stored = storedWeightShape(key);
+  if (stored !== null) {
+    weightProfileCache[key] = stored;
+    return stored;
+  }
+  // A render must never wait for eighty canvas renders: answer with the
+  // provisional shape now, and let the idle warm-up measure and redraw.
+  if (peek) return PENDING_WEIGHT_SHAPE;
   var profile = promoted
     ? shared.continuousWeightProfile()
     : { min: WEIGHT_DELTA_MIN, max: WEIGHT_DELTA_MAX, step: 1 };
@@ -7034,6 +7287,20 @@ function weightProfileFor(stack, top) {
       : { min: WEIGHT_DELTA_MIN, max: WEIGHT_DELTA_MAX, step: 1 };
   }
   weightProfileCache[key] = profile;
+  // A measured answer is worth a reload's freedom from the sweep, and the count it
+  // changes has to reach whatever is already on screen with the provisional one.
+  // Only when it actually differs: a family nothing could measure (no canvas) lands
+  // on exactly the provisional window, and redrawing for that would be noise.
+  rememberWeightShape(key, profile);
+  // Nothing distinguishable measured (no canvas, a family the page cannot draw)
+  // leaves the degenerate shape, which is not worth a redraw.
+  var changed =
+    profile.min !== 0 || profile.max !== 0
+      ? profile.min !== PENDING_WEIGHT_SHAPE.min ||
+        profile.max !== PENDING_WEIGHT_SHAPE.max ||
+        profile.step !== PENDING_WEIGHT_SHAPE.step
+      : false;
+  if (changed) notifyShapes();
   return profile;
 }
 
@@ -7086,6 +7353,9 @@ function deferWeightWarm(job) {
  * @param {object} editing - the value set the axes read.
  */
 var warmSignature = null;
+
+/** The code stack the deferred slice was last scheduled for (scheduled once). */
+var codeWarmSignature = null;
 var scheduleWeightWarm = function (editing) {
   var stacks = weightAxisStacks(editing);
   var signature = stacks.dialog + "\u0000" + stacks.ui + "\u0000" + stacks.code;
@@ -7102,11 +7372,6 @@ var scheduleWeightWarm = function (editing) {
       weightProfileFor(stacks.ui, shared.WEIGHT_LADDER_STRONG);
       probeLog("weight-warm", { axis: "ui", stack: stacks.ui });
     },
-    function () {
-      probeContinuity(stacks.code);
-      weightProfileFor(stacks.code, shared.WEIGHT_BASE);
-      probeLog("weight-warm", { axis: "code", stack: stacks.code });
-    },
   ];
   var runNext = function () {
     var job = jobs.shift();
@@ -7115,6 +7380,20 @@ var scheduleWeightWarm = function (editing) {
     deferWeightWarm(runNext);
   };
   deferWeightWarm(runNext);
+  // The code axis is measured LAST and later still: its family is usually a
+  // monospace the reader rarely touches, and on a slow machine the two axes above
+  // already keep the main thread busy. Deferring it keeps the first seconds after
+  // load (when a reader is likeliest to open the settings) free of its sweep.
+  var codeSignature = stacks.code;
+  if (codeSignature === codeWarmSignature) return;
+  codeWarmSignature = codeSignature;
+  globalThis.setTimeout(function () {
+    deferWeightWarm(function () {
+      probeContinuity(stacks.code);
+      weightProfileFor(stacks.code, shared.WEIGHT_BASE);
+      probeLog("weight-warm", { axis: "code", stack: stacks.code });
+    });
+  }, WARM_CODE_DELAY_MS);
 };
 
 /**
@@ -9453,7 +9732,8 @@ function FontCard(props) {
   var weightField = function (props) {
     var profile = weightProfileFor(
       props.stack === undefined ? "" : props.stack,
-      props.top === undefined ? shared.WEIGHT_LADDER_STRONG : props.top
+      props.top === undefined ? shared.WEIGHT_LADDER_STRONG : props.top,
+      { peek: true }
     );
     var stored = props.value === WEIGHT_UNSET ? NEUTRAL_WEIGHT : props.value;
     // A stored offset outside the measured range (the font changed since it was
@@ -10070,7 +10350,7 @@ function FontCard(props) {
     var isCode = field === CODE_WEIGHT_FIELD;
     var stack =
       field === WEIGHT_DIALOG_FIELD ? dialogStack : isCode ? codeStack : uiStack;
-    var profile = weightProfileFor(stack, isCode ? shared.WEIGHT_BASE : shared.WEIGHT_LADDER_STRONG);
+    var profile = weightProfileFor(stack, isCode ? shared.WEIGHT_BASE : shared.WEIGHT_LADDER_STRONG, { peek: true });
     return weightStepRange(profile, value === WEIGHT_UNSET ? 0 : value).value;
   };
 
@@ -10141,6 +10421,23 @@ function FontCard(props) {
     previewCodeStyle.lineHeight = "calc(20px + " + editing[CODE_LINE_HEIGHT_FIELD] + "px)";
   }
 
+  // A shape measured after this render changes the counts the rows above show, so
+  // the card redraws once one lands (see `notifyShapes`). Declared last on purpose:
+  // the hook order of everything before it stays exactly as it was.
+  var [, setShapeRevision] = useState(0);
+  useEffect(function () {
+    var listener = function () {
+      setShapeRevision(function (count) {
+        return count + 1;
+      });
+    };
+    shapeListeners.push(listener);
+    return function () {
+      var at = shapeListeners.indexOf(listener);
+      if (at >= 0) shapeListeners.splice(at, 1);
+    };
+  }, []);
+
   return h(
     "li",
     { className: "dfp-card" + (open ? " dfp-cardOpen" : "") },
@@ -13483,7 +13780,7 @@ function mountFloatPanel(scope, t, hostCtx) {
     var dialogStack = weightAxisStacks(config).dialog;
     var profile = { min: WEIGHT_DELTA_MIN, max: WEIGHT_DELTA_MAX, step: 1 };
     try {
-      profile = weightProfileFor(dialogStack, shared.WEIGHT_LADDER_STRONG);
+      profile = weightProfileFor(dialogStack, shared.WEIGHT_LADDER_STRONG, { peek: true });
     } catch (profileError) {
       // The nominal window stands in when the family cannot be measured.
     }
@@ -13859,13 +14156,18 @@ function mountFloatPanel(scope, t, hostCtx) {
   }
 
   // A promotion changes the weight row's shape; the panel redraws itself when one
-  // lands, and stops listening when it goes away.
+  // lands, and stops listening when it goes away. A shape that only lands with the
+  // idle measurement is the same story: the row was rendered with the provisional
+  // counts, so it has to be redrawn once the real ones exist.
   promotionListeners.push(render);
+  shapeListeners.push(render);
 
   return {
     destroy: function () {
       var at = promotionListeners.indexOf(render);
       if (at >= 0) promotionListeners.splice(at, 1);
+      var shapeAt = shapeListeners.indexOf(render);
+      if (shapeAt >= 0) shapeListeners.splice(shapeAt, 1);
       if (statusTimer !== null) globalThis.clearTimeout(statusTimer);
       if (closeTimer !== null) globalThis.clearTimeout(closeTimer);
       if (reflowTimer !== null) globalThis.clearTimeout(reflowTimer);

package/lib/shared.cjs

@@ -3467,6 +3467,70 @@ function balancedStackShape(entries, base, low, high, spread) {
   return best;
 }
 
+/**
+ * The FIRST weight of an arithmetic grid whose rendering matches a signature.
+ *
+ * The probe grid is monotone: below a family's lightest face every weight renders
+ * the same (the lightest face), above its heaviest face every weight renders the
+ * same (the heaviest face), and in between it walks the faces. So "renders like the
+ * ceiling" is a predicate that is false, then true, and its boundary is worth
+ * `log2` samples instead of one render per grid point — which is what the two
+ * horizon scans used to cost (eighty-one renders per family, issue #3).
+ * @param {(weight: number) => string|number} sample - renders a probe at one weight.
+ * @param {string|number} signature - the signature the boundary shares.
+ * @param {number} low - first weight of the grid.
+ * @param {number} high - last weight of the grid.
+ * @param {number} step - spacing of the grid.
+ * @param {number|null} fallback - returned when no grid weight matches.
+ * @returns {number|null} the weight, or the fallback.
+ */
+function firstGridWeight(sample, signature, low, high, step, fallback) {
+  var count = Math.floor((high - low) / step) + 1;
+  if (count < 1 || !(step > 0)) return fallback;
+  var at = function (index) {
+    return low + index * step;
+  };
+  if (sample(at(count - 1)) !== signature) return fallback;
+  var first = 0;
+  var last = count - 1;
+  while (first < last) {
+    var middle = (first + last) >> 1;
+    if (sample(at(middle)) === signature) last = middle;
+    else first = middle + 1;
+  }
+  return at(first);
+}
+
+/**
+ * The LAST weight of an arithmetic grid whose rendering matches a signature.
+ *
+ * The mirror of `firstGridWeight`: "renders like the floor" is true, then false,
+ * so the boundary is found from the other end.
+ * @param {(weight: number) => string|number} sample - renders a probe at one weight.
+ * @param {string|number} signature - the signature the boundary shares.
+ * @param {number} low - first weight of the grid.
+ * @param {number} high - last weight of the grid.
+ * @param {number} step - spacing of the grid.
+ * @param {number|null} fallback - returned when no grid weight matches.
+ * @returns {number|null} the weight, or the fallback.
+ */
+function lastGridWeight(sample, signature, low, high, step, fallback) {
+  var count = Math.floor((high - low) / step) + 1;
+  if (count < 1 || !(step > 0)) return fallback;
+  var at = function (index) {
+    return low + index * step;
+  };
+  if (sample(at(0)) !== signature) return fallback;
+  var first = 0;
+  var last = count - 1;
+  while (first < last) {
+    var middle = (first + last + 1) >> 1;
+    if (sample(at(middle)) === signature) first = middle;
+    else last = middle - 1;
+  }
+  return at(first);
+}
+
 /**
  * One slider shape for a stack whose text can land on more than one family.
  *
@@ -3628,30 +3692,38 @@ function weightProfileFrom(sample, options) {
   var top = typeof settings.top === "number" ? settings.top : WEIGHT_LADDER_STRONG;
   var topSignature = sample(WEIGHT_PROBE_HIGH);
   var bottomSignature = sample(WEIGHT_PROBE_LOW);
-  var heaviest = WEIGHT_PROBE_HIGH;
-  for (var weight = WEIGHT_PROBE_LOW; weight <= WEIGHT_PROBE_HIGH; weight += WEIGHT_PROBE_STEP) {
-    if (sample(weight) === topSignature) {
-      heaviest = weight;
-      break;
-    }
-  }
-  var lightest = WEIGHT_PROBE_LOW;
-  for (var back = WEIGHT_PROBE_HIGH; back >= WEIGHT_PROBE_LOW; back -= WEIGHT_PROBE_STEP) {
-    if (sample(back) === bottomSignature) {
-      lightest = back;
-      break;
-    }
-  }
+  // The two horizons used to be found by walking the whole probe grid from one end
+  // — eighty-one canvas renders per family, and on a font collection of a few
+  // hundred megabytes each render is the browser rasterizing a new weight (issue
+  // #3: seconds of blocked main thread). The grid is monotone in weight: everything
+  // from a family's heaviest face UP renders the same, so the horizon is a
+  // boundary, and a bisection finds it in seven samples instead of eighty-one.
+  var heaviest = firstGridWeight(
+    sample,
+    topSignature,
+    WEIGHT_PROBE_LOW,
+    WEIGHT_PROBE_HIGH,
+    WEIGHT_PROBE_STEP,
+    WEIGHT_PROBE_HIGH
+  );
+  var lightest = lastGridWeight(
+    sample,
+    bottomSignature,
+    WEIGHT_PROBE_LOW,
+    WEIGHT_PROBE_HIGH,
+    WEIGHT_PROBE_STEP,
+    WEIGHT_PROBE_LOW
+  );
   // How far the offset can go before NO layer that must move can move any more:
   // the widest horizon among those bases, since a layer that could still change
   // must not be cut off by one that already sits at its heaviest face.
   var headroom = Math.max(0, heaviest - WEIGHT_BASE);
   if (top !== WEIGHT_BASE) {
-    for (var up = top; up <= WEIGHT_PROBE_HIGH; up += WEIGHT_PROBE_STEP) {
-      if (sample(up) === topSignature) {
-        headroom = Math.max(headroom, up - top);
-        break;
-      }
+    // Same boundary, same bisection: the first weight at or above the heavy base
+    // that already renders at the ceiling.
+    var reached = firstGridWeight(sample, topSignature, top, WEIGHT_PROBE_HIGH, WEIGHT_PROBE_STEP, null);
+    if (reached !== null) {
+      headroom = Math.max(headroom, reached - top);
     }
   }
   var reachUp = Math.min(ceil, WEIGHT_DELTA_UP_LIMIT, headroom);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-fonttune",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "description": "Font plugin for the DeepSeek Harness Web GUI: the conversation gets its own font, size, line height and weight, the interface font and weight follow it, code keeps its own axis with ligature control, and whole setups save as presets.",
   "type": "module",
   "icon": "icon.svg",
@@ -50,7 +50,10 @@
         "0.2.1-rc.1": "compatible",
         "0.2.1-rc.2": "compatible",
         "0.2.1-rc.4": "compatible",
-        "0.2.2-alpha.2": "compatible"
+        "0.2.1-rc.3": "compatible",
+      "0.2.1-rc.5": "compatible",
+      "0.2.2-alpha.2": "compatible",
+      "0.2.2-rc.1": "compatible"
       }
     }
   },