dsh-fonttune 0.7.5 → 0.7.7

package/CHANGELOG.en.md

@@ -2,6 +2,20 @@
 
 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
+- **The plugin did not actually load on some hosts**: the Font tune settings card and the first-frame type stylesheet were missing while the conversation still looked completely normal, so it was easy to miss; the plugin now waits for its dependency to finish loading before it registers, and no longer starts half-loaded.
+
 ## [0.7.5] - 2026-11-01
 
 ### Fixed

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 **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
+
+### 修复
+- **部分环境下插件启动后没有真正加载**：字体增强的设置卡片与首帧字体样式会缺失，而对话外观看起来一切正常，所以很难发现；现在启动时会等依赖就绪再注册，不再出现这种「看着正常、其实没加载」的状态。
+
 ## [0.7.5] - 2026-11-01
 
 ### 修复

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/index.js

@@ -22,7 +22,7 @@
  */
 import { createRequire } from "node:module";
 import { dirname, sep } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 // Default import, not named: `shared.cjs` is a CommonJS module, and Node's
 // CJS-to-ESM interop only guarantees `module.exports` as the default binding
 // (statically-detected named exports would break this half at boot).
@@ -47,26 +47,73 @@ import shared from "./shared.cjs";
  * entry (its `node_modules` holds the authoritative copy); anything resolving
  * back inside THIS package is skipped, so the offline suites — which have no
  * host — still fall through to the devDependency.
- * @returns {object} the schemastery export.
+ *
+ * RESOLVE with `require`, LOAD with the ESM loader. The package resolves to its
+ * CommonJS build, and that build `require`s `@deepseek-ai/cosmokit`, which ships
+ * as ES module only. Requiring it while the host is still loading that same
+ * module graph throws `ERR_REQUIRE_ESM_RACE_CONDITION` — "Cannot require() ES
+ * Module … because it is not yet fully loaded" — and then the whole host half
+ * fails to import: no settings namespace, no first-frame stylesheet, while the
+ * browser half keeps working and hides the damage (issue #7, reproduced here).
+ * `import()` waits for the graph instead of racing it, and it lands on the same
+ * instance: a `.cjs` file loaded through the ESM loader goes through the
+ * CommonJS cache, so the host's copy is still the only copy.
+ * @returns {Promise<object>} the schemastery export.
  */
-function loadSchemastery() {
+async function loadSchemastery() {
   const own = dirname(dirname(fileURLToPath(import.meta.url))) + sep;
   const bases = [process.argv[1], fileURLToPath(import.meta.url)];
   for (const base of bases) {
     if (typeof base !== "string" || base === "") continue;
-    try {
-      const from = createRequire(base);
-      if (!from.resolve("@deepseek-ai/schemastery").startsWith(own)) {
-        return from("@deepseek-ai/schemastery");
-      }
-    } catch {
-      // Not resolvable from that anchor: try the next one.
-    }
+    const resolved = resolveSchemastery(createRequire(base), own);
+    if (resolved !== null) return importSchemastery(resolved);
+  }
+  // Nothing outside this package offers it (the offline suites have no host), so
+  // the devDependency is the answer — still loaded through the ESM loader.
+  const fallback = resolveSchemastery(createRequire(import.meta.url), "");
+  if (fallback === null) {
+    throw new Error("@deepseek-ai/schemastery is not resolvable from the host or this package");
+  }
+  return importSchemastery(fallback);
+}
+
+/**
+ * Locate the schema library from one anchor WITHOUT loading it.
+ *
+ * Only the resolution is anchored to the host: `createRequire(base).resolve()`
+ * answers "which file would the host use", while nothing is executed. An answer
+ * that points back inside this package is refused, so a linked install cannot
+ * shadow the host's copy with this package's devDependency.
+ * @param {NodeRequire} from - the resolver anchored at the host entry.
+ * @param {string} own - this package's directory prefix, "" to accept anything.
+ * @returns {string|null} the file to load, or null when this anchor cannot offer it.
+ */
+function resolveSchemastery(from, own) {
+  try {
+    const resolved = from.resolve("@deepseek-ai/schemastery");
+    if (typeof resolved !== "string" || resolved === "") return null;
+    if (own !== "" && resolved.startsWith(own)) return null;
+    return resolved;
+  } catch {
+    // Not resolvable from that anchor (or has no `require` entry): try the next.
+    return null;
   }
-  return createRequire(import.meta.url)("@deepseek-ai/schemastery");
 }
 
-const z = loadSchemastery();
+/**
+ * Load one resolved file through the ESM loader.
+ *
+ * A CommonJS build arrives as its `default` binding, which is the module's own
+ * `module.exports`; a build that is already ESM answers with itself.
+ * @param {string} resolved - an absolute path, from `resolveSchemastery`.
+ * @returns {Promise<object>} the schemastery export.
+ */
+async function importSchemastery(resolved) {
+  const loaded = await import(pathToFileURL(resolved).href);
+  return loaded.default ?? loaded;
+}
+
+const z = await loadSchemastery();
 
 const {
   buildFontCss,

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.5",
+  "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"
       }
     }
   },