dsh-fonttune 0.7.6 → 0.7.8

package/CHANGELOG.en.md

@@ -2,6 +2,24 @@
 
 All notable changes to **dsh-fonttune** are documented here. Chinese version: [CHANGELOG.md](CHANGELOG.md).
 
+## [0.7.8] - 2026-11-05
+
+### Fixed
+- **The font picker opened slowly**: the list now builds one screenful, and the names are no longer drawn in each family's own font, so opening and scrolling stay quick on a machine with many installed fonts.
+- **A pause when switching presets**: a preset remembers the notches that were measured for it, so switching uses them directly instead of measuring again at that moment.
+
+### Changed
+- **Only verified host versions are declared**: 0.2.0-rc.1 through 0.2.2-rc.1 are listed one by one; older or untested versions are no longer claimed.
+
+## [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,24 @@
 
 **dsh-fonttune** 的重要变更都记录在这里。英文版见 [CHANGELOG.en.md](CHANGELOG.en.md)。
 
+## [0.7.8] - 2026-11-05
+
+### 修复
+- **字体选择列表打开较慢**：列表现在只列出首屏，并且不再逐个用各自字体显示名称；机器上安装的字体很多时，打开与滚动都更快。
+- **切换配置方案时的停顿**：方案会记住已测好的档位，切换时直接使用，切换的那一瞬间不再重新测量。
+
+### 变更
+- **兼容范围只保留实测过的版本**：从 0.2.0-rc.1 到 0.2.2-rc.1 逐个列出，更早或未验证的版本不再声明支持。
+
+## [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.2.0-rc.1, 0.2.0-rc.2, 0.2.1-rc.1, 0.2.1-rc.2, 0.2.1-rc.3, 0.2.1-rc.4, 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.2.0-rc.1、0.2.0-rc.2、0.2.1-rc.1、0.2.1-rc.2、0.2.1-rc.3、0.2.1-rc.4、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);
@@ -4928,6 +5000,40 @@ function catalogRefreshDue(cache, now, retryMs) {
   return now - (cache.at || 0) >= retryMs;
 }
 
+/**
+ * The rows one picker group actually renders.
+ *
+ * A machine with a huge font collection — or a Super TTC, which exposes every
+ * weight and variant as its own family — can enumerate hundreds of names, and
+ * building a row for each one is a visible stall when the list opens (issue #3:
+ * the reporter's second symptom). The list therefore renders a screenful unless
+ * the reader is searching, and a family that is already selected is always
+ * rendered so its check mark never falls outside the window.
+ * @param {string[]} families - the group's families, in display order.
+ * @param {string} query - the search text (empty means "browse the whole list").
+ * @param {Object<string, boolean>} selectedLower - lower-cased names already picked.
+ * @param {number} [limit] - how many rows a browse renders.
+ * @returns {string[]} the families to render.
+ */
+function pickerRows(families, query, selectedLower, limit) {
+  var list = Array.isArray(families) ? families : [];
+  var searching = typeof query === "string" && query.trim() !== "";
+  if (searching) return list.slice();
+  var cap = typeof limit === "number" && limit > 0 ? Math.floor(limit) : 60;
+  var picked = selectedLower !== null && typeof selectedLower === "object" ? selectedLower : {};
+  var rows = [];
+  var shown = 0;
+  for (var index = 0; index < list.length; index += 1) {
+    var name = list[index];
+    var isSelected = picked[String(name).toLowerCase()] === true;
+    if (isSelected || shown < cap) {
+      rows.push(name);
+      shown += 1;
+    }
+  }
+  return rows;
+}
+
 var shared = {
   NAMESPACE: NAMESPACE,
   SANS_FIELD: SANS_FIELD,
@@ -5075,6 +5181,7 @@ var shared = {
   PRESETS: PRESETS,
   PRESET_GROUPS: PRESET_GROUPS,
   MAX_LOCAL_FONTS: MAX_LOCAL_FONTS,
+  pickerRows: pickerRows,
   pickerGroups: pickerGroups,
   catalogRefreshDue: catalogRefreshDue,
   MARKDOWN_SELECTOR: MARKDOWN_SELECTOR,
@@ -6483,6 +6590,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 +6680,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 +6698,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 +6719,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 +7123,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 +7247,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 +7273,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 +7322,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,7 +7388,22 @@ function deferWeightWarm(job) {
  * @param {object} editing - the value set the axes read.
  */
 var warmSignature = null;
+
+/** When a preset was applied: its warm-up waits so the switch itself feels instant. */
+var presetSwitchAt = 0;
+
+/** The code stack the deferred slice was last scheduled for (scheduled once). */
+var codeWarmSignature = null;
 var scheduleWeightWarm = function (editing) {
+  // A preset switch changes several stacks at once. Hydrated shapes make the rows
+  // correct immediately, so the sweep those stacks would trigger can wait: measuring
+  // inside the switch is what made switching stutter on a slow font.
+  if (Date.now() - presetSwitchAt < 1200) {
+    globalThis.setTimeout(function () {
+      scheduleWeightWarm(editing);
+    }, 1200);
+    return;
+  }
   var stacks = weightAxisStacks(editing);
   var signature = stacks.dialog + "\u0000" + stacks.ui + "\u0000" + stacks.code;
   if (signature === warmSignature) return;
@@ -7102,11 +7419,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 +7427,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);
 };
 
 /**
@@ -8268,11 +8594,18 @@ function StackPicker(props) {
   var panel = null;
   if (open) {
     var rows = [];
+    // A machine with a huge font collection (or a Super TTC, which exposes every
+    // weight and variant as its own family) can enumerate hundreds of names. Only
+    // the first screenful is built unless the reader is searching, and a selected
+    // family is always among them — drawing every row was a second of layout on
+    // such a machine. The subsetting itself is pure and covered offline.
+    var RENDER_LIMIT = 60;
     for (var groupRender = 0; groupRender < options.length; groupRender += 1) {
       var group = options[groupRender];
       rows.push(h("div", { className: "dfp-group", key: "g:" + group.label }, t(group.label)));
-      for (var rowIndex = 0; rowIndex < group.families.length; rowIndex += 1) {
-        var name = group.families[rowIndex];
+      var visible = shared.pickerRows(group.families, typed, selectedLower, RENDER_LIMIT);
+      for (var rowIndex = 0; rowIndex < visible.length; rowIndex += 1) {
+        var name = visible[rowIndex];
         var isSelected = selectedLower[name.toLowerCase()] === true;
         rows.push(
           h(
@@ -8281,12 +8614,13 @@ function StackPicker(props) {
               type: "button",
               className: "dfp-option",
               key: "o:" + group.label + ":" + name,
-              style: { fontFamily: quoteFamily(name) },
               "data-family": name,
               onClick: function (event) {
                 toggle(event.currentTarget.dataset.family);
               },
             },
+            // The rows are NOT drawn in their own family: on a large collection that
+            // loaded one font per row, which is exactly the stall this list is about.
             h("span", { className: "dfp-optionLabel" }, name),
             isSelected ? h("span", { className: "dfp-optionCheck" }, "✓") : null
           )
@@ -9066,7 +9400,9 @@ function FontCard(props) {
     var next = presetList.slice();
     for (var index = 0; index < next.length; index += 1) {
       if (next[index].name === entry.name) {
+        var shapes = shapeSnapshotFor(values);
         next[index] = { name: entry.name, values: values, savedAt: Date.now() };
+        if (Object.keys(shapes).length > 0) next[index].shapes = shapes;
       }
     }
     return { op: shared.PENDING_SET, path: [PRESETS_FIELD], value: JSON.stringify(next) };
@@ -9453,7 +9789,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
@@ -9909,10 +10246,63 @@ function FontCard(props) {
    * is exact.
    * @param {{name: string, values: object}} entry - the picked preset.
    */
+  /**
+   * The measured shapes a preset can carry.
+   *
+   * Switching presets changes the font stacks, which invalidates the slider shapes:
+   * the new stacks would be measured again (a second of canvas work on a huge font
+   * collection) the moment they are applied. A preset therefore remembers the
+   * shapes it was saved with — three small records — and applying it restores them
+   * instead of measuring (issue #3 follow-up: "switching presets stutters").
+   * @param {object} values - the preset's value set.
+   * @returns {object} cache key -> shape, empty when nothing is known yet.
+   */
+  var shapeSnapshotFor = function (values) {
+    var stacks = weightAxisStacks(values);
+    var pairs = [
+      [stacks.dialog, shared.WEIGHT_LADDER_STRONG],
+      [stacks.ui, shared.WEIGHT_LADDER_STRONG],
+      [stacks.code, shared.WEIGHT_BASE],
+    ];
+    var snapshot = {};
+    for (var index = 0; index < pairs.length; index += 1) {
+      var stack = pairs[index][0];
+      var base = pairs[index][1];
+      var key = String(stack) + "\u0000" + base + "\u0000stepped";
+      if (Object.prototype.hasOwnProperty.call(weightProfileCache, key)) {
+        snapshot[key] = weightProfileCache[key];
+      } else {
+        var stored = storedWeightShape(key);
+        if (stored !== null) snapshot[key] = stored;
+      }
+    }
+    return snapshot;
+  };
+
+  /**
+   * Put a preset's remembered shapes back into the cache.
+   * @param {object} shapes - what `shapeSnapshotFor` recorded.
+   */
+  var hydrateShapes = function (shapes) {
+    if (shapes === null || typeof shapes !== "object") return;
+    for (var key in shapes) {
+      if (!Object.prototype.hasOwnProperty.call(shapes, key)) continue;
+      var shape = shapes[key];
+      if (shape === null || typeof shape !== "object") continue;
+      if (!isFinite(shape.min) || !isFinite(shape.max) || !isFinite(shape.step)) continue;
+      if (Object.prototype.hasOwnProperty.call(weightProfileCache, key)) continue;
+      weightProfileCache[key] = { min: shape.min, max: shape.max, step: shape.step };
+    }
+  };
+
   var switchPreset = function (entry) {
     if (!writable || entry.name === activeName) return;
+    // Stamp the switch BEFORE anything is written: the sync that follows it would
+    // otherwise start measuring the new stacks in the same task.
+    presetSwitchAt = Date.now();
     applyingRef.current = true;
     try {
+      hydrateShapes(entry.shapes);
       for (var index = 0; index < VALUE_FIELDS.length; index += 1) {
         var field = VALUE_FIELDS[index];
         var value = Object.prototype.hasOwnProperty.call(entry.values, field)
@@ -10070,7 +10460,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 +10531,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 +13890,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 +14266,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);
@@ -4919,6 +4991,40 @@ function catalogRefreshDue(cache, now, retryMs) {
   return now - (cache.at || 0) >= retryMs;
 }
 
+/**
+ * The rows one picker group actually renders.
+ *
+ * A machine with a huge font collection — or a Super TTC, which exposes every
+ * weight and variant as its own family — can enumerate hundreds of names, and
+ * building a row for each one is a visible stall when the list opens (issue #3:
+ * the reporter's second symptom). The list therefore renders a screenful unless
+ * the reader is searching, and a family that is already selected is always
+ * rendered so its check mark never falls outside the window.
+ * @param {string[]} families - the group's families, in display order.
+ * @param {string} query - the search text (empty means "browse the whole list").
+ * @param {Object<string, boolean>} selectedLower - lower-cased names already picked.
+ * @param {number} [limit] - how many rows a browse renders.
+ * @returns {string[]} the families to render.
+ */
+function pickerRows(families, query, selectedLower, limit) {
+  var list = Array.isArray(families) ? families : [];
+  var searching = typeof query === "string" && query.trim() !== "";
+  if (searching) return list.slice();
+  var cap = typeof limit === "number" && limit > 0 ? Math.floor(limit) : 60;
+  var picked = selectedLower !== null && typeof selectedLower === "object" ? selectedLower : {};
+  var rows = [];
+  var shown = 0;
+  for (var index = 0; index < list.length; index += 1) {
+    var name = list[index];
+    var isSelected = picked[String(name).toLowerCase()] === true;
+    if (isSelected || shown < cap) {
+      rows.push(name);
+      shown += 1;
+    }
+  }
+  return rows;
+}
+
 var shared = {
   NAMESPACE: NAMESPACE,
   SANS_FIELD: SANS_FIELD,
@@ -5066,6 +5172,7 @@ var shared = {
   PRESETS: PRESETS,
   PRESET_GROUPS: PRESET_GROUPS,
   MAX_LOCAL_FONTS: MAX_LOCAL_FONTS,
+  pickerRows: pickerRows,
   pickerGroups: pickerGroups,
   catalogRefreshDue: catalogRefreshDue,
   MARKDOWN_SELECTOR: MARKDOWN_SELECTOR,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-fonttune",
-  "version": "0.7.6",
+  "version": "0.7.8",
   "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",
@@ -25,7 +25,7 @@
     "docs/card-shaping.jpg"
   ],
   "engines": {
-    "dsh": ">=0.1.7-alpha.1 <0.3.0-0"
+    "dsh": ">=0.2.0-rc.1 <0.2.2-rc.2"
   },
   "dsh": {
     "bundle": {
@@ -36,21 +36,14 @@
     },
     "compatibility": {
       "dshReleases": {
-        "0.1.7-alpha.1": "compatible",
-        "0.1.7-alpha.2": "compatible",
-        "0.1.7-rc.1": "compatible",
-        "0.1.7-rc.2": "compatible",
         "0.2.0-rc.1": "compatible",
         "0.2.0-rc.2": "compatible",
-        "0.2.1-alpha.1": "compatible",
-        "0.2.1-alpha.2": "compatible",
-        "0.2.1-alpha.3": "compatible",
-        "0.2.1-alpha.4": "compatible",
-        "0.2.1-alpha.5": "compatible",
         "0.2.1-rc.1": "compatible",
         "0.2.1-rc.2": "compatible",
+        "0.2.1-rc.3": "compatible",
         "0.2.1-rc.4": "compatible",
-        "0.2.2-alpha.2": "compatible"
+        "0.2.1-rc.5": "compatible",
+        "0.2.2-rc.1": "compatible"
       }
     }
   },