dsh-fonttune 0.7.3 → 0.7.4

package/CHANGELOG.en.md

@@ -2,6 +2,14 @@
 
 All notable changes to **dsh-fonttune** are documented here. Chinese version: [CHANGELOG.md](CHANGELOG.md).
 
+## [0.7.4] - 2026-10-30
+
+### Fixed
+- **The weight slider moved the Latin and the Chinese text by different amounts**: when a Chinese family ships only a few faces, some notches changed only the Latin side and others made the browser thicken the Chinese one itself, so one script read heavier than the other. The notches are now taken from what both families can draw, and each one changes the two sides by a similar amount.
+
+### Changed
+- **How many notches you get follows the faces the fonts ship**: a Chinese family with more faces offers more notches — three faces give at most three positions, seven give about twice that. The readout counts positions, so it changes with the font.
+
 ## [0.7.3] - 2026-10-29
 
 ### Fixed

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 **dsh-fonttune** 的重要变更都记录在这里。英文版见 [CHANGELOG.en.md](CHANGELOG.en.md)。
 
+## [0.7.4] - 2026-10-30
+
+### 修复
+- **中英混排时两边字重不同步**：一套中文字体只带几个字面时，字重滑块有些档位只让西文变、中文不动，有些档位是浏览器把中文自动加粗，读起来一边太重一边太轻。现在档位取自两种字体都能真画出来的范围，每档两边变化幅度接近。
+
+### 变更
+- **档位数量按字体能画的字面计算**：中文字面越多的字体，滑块给的档位越多——只有三个字面的中文字体最多三档，七个字面的约多一倍。读数是档数，换字体后档数会跟着变。
+
 ## [0.7.3] - 2026-10-29
 
 ### 修复

package/lib/client.js

@@ -3263,6 +3263,294 @@ function ceilTo(value, step) {
   return Math.ceil(value / step) * step;
 }
 
+/**
+ * How far apart two families may land on one notch before the stack refuses it.
+ *
+ * Measured on the reporter's pair (issue #4): one 100-weight notch adds +21.5%
+ * ink to the Latin family and +23.9% to the Chinese one — 2.4 points apart, which
+ * no reader notices. One 200-weight notch adds +44% and +51% — 7.4 points apart,
+ * and that is the reported "one side suits, the other is too heavy". Five points
+ * is the budget between those two observations.
+ */
+var INK_BALANCE_SPREAD = 0.05;
+
+/**
+ * How far apart a pair may land when the strict budget would leave no control.
+ *
+ * Measured on the reporter's pair (issue #4): going one notch LIGHTER, the Latin
+ * family loses 29.7% of its ink and the Chinese one 17.9% — 11.9 points apart, and
+ * no finer notch makes it better, because the two families simply space their faces
+ * differently. Under the strict budget the reader would get a weight control that
+ * cannot go lighter at all (two positions). The wider budget is what keeps that
+ * physical pair usable, and it is only consulted when the strict one is: a stack
+ * that has four even positions never sees it.
+ */
+var INK_BALANCE_SPREAD_WIDE = 0.15;
+
+/** How many notches the evenness walk looks at, one way. */
+var WEIGHT_MAX_POSITIONS = 24;
+
+/**
+ * The least ink one notch has to add before a position is worth having.
+ *
+ * This is the bar `weightProfileFrom` already measured on this host: a 200-weight
+ * step is +30% ink and a 100-weight step +16%, and 100 was not enough — a reader
+ * could not see it. Five per cent would put a variable family's stack at twenty-odd
+ * notches that each move a little (measured live: 29 positions of +6%), which is the
+ * dead-control the coarse step exists to avoid. Fifteen keeps every pair the faces
+ * do allow (the reported one tops out at +19%/+22%) and stops there.
+ */
+var INK_BALANCE_STEP = 0.15;
+
+/**
+ * One family's ink at one weight.
+ *
+ * A family answers through `inkOf`, the sampler its own measurement already uses;
+ * a weight it cannot measure — or a family that cannot be measured at all — answers
+ * null and is left out of a comparison instead of counting as a zero.
+ * @param {Object} entry - one measured family.
+ * @param {number} weight - CSS weight.
+ * @returns {number|null} the ink, or null when there is no measurement.
+ */
+function entryInk(entry, weight) {
+  if (entry === null || typeof entry !== "object") return null;
+  if (typeof entry.inkOf !== "function") return null;
+  var ink = null;
+  try {
+    ink = entry.inkOf(weight);
+  } catch (error) {
+    return null;
+  }
+  ink = Number(ink);
+  if (!isFinite(ink) || ink <= 0) return null;
+  return ink;
+}
+
+/**
+ * How much moving from one weight to another changes each family's ink.
+ *
+ * The share is relative to the family's OWN ink at `from`, so two families that
+ * start out different sizes are still comparable: +20% means the same thing for
+ * both. Families that cannot be measured on both sides are left out.
+ * @param {Array<Object>} entries - the measured families.
+ * @param {number} from - the weight the reader is at.
+ * @param {number} to - the weight being compared.
+ * @returns {number[]|null} the relative changes, or null when fewer than two
+ *   families can be measured.
+ */
+function inkShares(entries, from, to) {
+  var shares = [];
+  for (var index = 0; index < entries.length; index += 1) {
+    var before = entryInk(entries[index], from);
+    var after = entryInk(entries[index], to);
+    if (before === null || after === null) continue;
+    shares.push((after - before) / before);
+  }
+  return shares.length < 2 ? null : shares;
+}
+
+/**
+ * How far apart the families land, and how little the quietest one moved.
+ * @param {number[]} shares - one relative change per family.
+ * @returns {{spread: number, smallest: number}} `spread` is the signed range, so
+ *   families moving in opposite directions count as far apart.
+ */
+function shareSpread(shares) {
+  var least = shares[0];
+  var most = shares[0];
+  var smallest = Math.abs(shares[0]);
+  for (var index = 1; index < shares.length; index += 1) {
+    if (shares[index] < least) least = shares[index];
+    if (shares[index] > most) most = shares[index];
+    var size = Math.abs(shares[index]);
+    if (size < smallest) smallest = size;
+  }
+  return { spread: most - least, smallest: smallest };
+}
+
+/**
+ * The evenness verdict for one move of the stack.
+ * @param {Array<Object>} entries - the measured families.
+ * @param {number} from - the weight the move starts at.
+ * @param {number} to - the weight it ends at.
+ * @returns {{spread: number, smallest: number}|null} the verdict, or null when it
+ *   cannot be measured.
+ */
+function evennessOf(entries, from, to) {
+  var shares = inkShares(entries, from, to);
+  if (shares === null) return null;
+  return shareSpread(shares);
+}
+
+/** Is one move of the stack both visible and even? */
+function moveIsEven(verdict, spread) {
+  return verdict !== null && verdict.smallest >= INK_BALANCE_STEP && verdict.spread <= spread;
+}
+
+/**
+ * The shape a stack of families can follow together, chosen for EVENNESS.
+ *
+ * Issue #4 is not about the range: it is about two families being moved by one
+ * offset and landing on faces that are not the same distance apart. The test is
+ * therefore walked outwards from the neutral position, one notch at a time, and a
+ * notch only survives when BOTH hold:
+ *  - every family's ink changes by at least `INK_BALANCE_STEP` (the notch is
+ *    visible), and
+ *  - the families land within `INK_BALANCE_SPREAD` of each other, measured both for
+ *    that one notch and for the whole way back to the neutral position — a stack
+ *    can be even notch by notch and still drift apart after two of them.
+ *
+ * The walk is what removes the synthetic-bold step without ever having to ask the
+ * browser whether a weight is drawn or faked: above its last real face a family is
+ * stroked thicker by the browser, which adds a much larger share of ink than a drawn
+ * face does — so the notch where one family jumps and the other does not simply
+ * fails the budget and the range stops in front of it.
+ *
+ * Among the shapes that survive, the one with the MOST positions wins: the visible
+ * floor above is what makes a finer notch worth having, and more positions is more
+ * control. (A single family is not put through this at all — it keeps the coarse
+ * shape `weightProfileFrom` measured for it.)
+ * @param {Array<{min: number, max: number, step: number, inkOf?: Function}>} entries
+ *   one record per measured family.
+ * @param {number} base - the weight the offset is added to (body text).
+ * @param {number} low - the lowest offset every family can express.
+ * @param {number} high - the highest offset every family can express.
+ * @returns {{min: number, max: number, step: number}|null} the shape, or null when
+ *   no step leaves the stack two positions to move between.
+ */
+function balancedStackShape(entries, base, low, high, spread) {
+  var budget = typeof spread === "number" && spread > 0 ? spread : INK_BALANCE_SPREAD;
+  var best = null;
+  var bestCount = 1;
+  var bestScore = Infinity;
+  for (var index = 0; index < WEIGHT_STEP_CANDIDATES.length; index += 1) {
+    var step = WEIGHT_STEP_CANDIDATES[index];
+    if (!(step > 0)) continue;
+    var up = 0;
+    var down = 0;
+    // A walk is bounded: no useful shape has more than a couple of dozen
+    // positions, and an unbounded one on a one-unit grid would cost hundreds of
+    // canvas renders on the very first measurement.
+    var limit = step * WEIGHT_MAX_POSITIONS;
+    for (var position = step; position <= high && position <= limit; position += step) {
+      if (!moveIsEven(evennessOf(entries, base + position - step, base + position), budget)) break;
+      if (!moveIsEven(evennessOf(entries, base, base + position), budget)) break;
+      up = position;
+    }
+    for (var back = step; back <= -low && back <= limit; back += step) {
+      if (!moveIsEven(evennessOf(entries, base - back + step, base - back), budget)) break;
+      if (!moveIsEven(evennessOf(entries, base, base - back), budget)) break;
+      down = back;
+    }
+    var count = (up + down) / step + 1;
+    if (count < 2) continue;
+    // How close the two families are on one notch from the neutral position: a tie
+    // between two shapes that move the stack over the same number of positions.
+    var headroom = evennessOf(entries, base, base + step);
+    if (headroom === null) headroom = evennessOf(entries, base, base - step);
+    var score = headroom === null ? Infinity : headroom.spread;
+    if (count > bestCount || (count === bestCount && score < bestScore)) {
+      // -0 would read as a different number to a strict comparison.
+      best = { min: down === 0 ? 0 : -down, max: up, step: step };
+      bestCount = count;
+      bestScore = score;
+    }
+  }
+  return best;
+}
+
+/**
+ * One slider shape for a stack whose text can land on more than one family.
+ *
+ * A reader sets ONE offset; the browser then renders English with the first
+ * family and Chinese with the fallback, each snapping that same requested value
+ * to its own faces. When the fallback ships three faces and the primary is a
+ * variable font, a step measured on the primary alone leaves the fallback
+ * unchanged on most notches — the reported "one side suits, the other is too
+ * heavy or too light" (issue #4: Inclusive Sans beside a three-face CJK family).
+ *
+ * The combined shape keeps every family moving on every notch, but the notch is
+ * chosen for EVENNESS (see `balancedStackShape`): each family has to change by a
+ * comparable share of its own ink, and the stack has to stay together over the
+ * whole length of the range. Families that can report their ink (`inkOf`) get that
+ * shape; a stack measured without a canvas keeps the plain shared-multiple shape,
+ * which is also what a single family gets.
+ * @param {Array<{min: number, max: number, step: number, inkOf?: Function}|null>} profiles
+ *   one shape per family.
+ * @param {{base?: number}} [options] `base` is the weight the offset is added to
+ *   (body text); it anchors the ink comparison.
+ * @returns {{min: number, max: number, step: number}|null} the combined shape, or
+ *   null when nothing usable was measured.
+ */
+function combineWeightProfiles(profiles, options) {
+  var list = [];
+  if (Array.isArray(profiles)) {
+    for (var index = 0; index < profiles.length; index += 1) {
+      var entry = profiles[index];
+      if (entry === null || typeof entry !== "object") continue;
+      if (!isFinite(entry.min) || !isFinite(entry.max) || !isFinite(entry.step)) continue;
+      if (!(entry.step > 0)) continue;
+      list.push(entry);
+    }
+  }
+  if (list.length === 0) return null;
+  if (list.length === 1) return { min: list[0].min, max: list[0].max, step: list[0].step };
+  var step = list[0].step;
+  for (var other = 1; other < list.length; other += 1) {
+    step = commonStep(step, list[other].step);
+  }
+  var low = list[0].min;
+  var high = list[0].max;
+  for (var more = 1; more < list.length; more += 1) {
+    low = Math.max(low, list[more].min);
+    high = Math.min(high, list[more].max);
+  }
+  var settings = options === null || typeof options !== "object" ? {} : options;
+  var base = isFinite(settings.base) ? Number(settings.base) : WEIGHT_BASE;
+  // Every family that can report ink is put through the evenness walk; a stack whose
+  // canvas could not answer keeps the plain shared-multiple shape.
+  var measured = false;
+  for (var scan = 0; scan < list.length; scan += 1) {
+    if (typeof list[scan].inkOf === "function") measured = true;
+  }
+  if (measured) {
+    var even = balancedStackShape(list, base, low, high);
+    var positions = even === null ? 0 : (even.max - even.min) / even.step + 1;
+    if (positions >= 3) return even;
+    // The pair's own faces are spaced so unevenly that the strict budget leaves
+    // no control; the wider one is what keeps a lighter position reachable.
+    var relaxed = balancedStackShape(list, base, low, high, INK_BALANCE_SPREAD_WIDE);
+    var relaxedPositions = relaxed === null ? 0 : (relaxed.max - relaxed.min) / relaxed.step + 1;
+    if (relaxedPositions > positions) return relaxed;
+    if (even !== null) return even;
+  }
+  var onGrid = { min: ceilTo(low, step), max: floorTo(high, step) };
+  if (onGrid.max >= onGrid.min) return { min: onGrid.min, max: onGrid.max, step: step };
+  var widest = list[0];
+  for (var alt = 1; alt < list.length; alt += 1) {
+    if (list[alt].max - list[alt].min > widest.max - widest.min) widest = list[alt];
+  }
+  return { min: widest.min, max: widest.max, step: widest.step };
+}
+
+/**
+ * The smallest candidate step that is a whole multiple of both inputs.
+ *
+ * Profiles come from one candidate list, so a shared multiple usually exists
+ * there; two steps that share none fall back to the coarser one, which still
+ * moves the coarser family on every notch.
+ * @param {number} a - one step.
+ * @param {number} b - another step.
+ * @returns {number} the combined step.
+ */
+function commonStep(a, b) {
+  for (var index = 0; index < WEIGHT_STEP_CANDIDATES.length; index += 1) {
+    var candidate = WEIGHT_STEP_CANDIDATES[index];
+    if (candidate % a === 0 && candidate % b === 0) return candidate;
+  }
+  return Math.max(a, b);
+}
+
 /**
  * Does every position of `[min..max]` in `step` increments render differently?
  *
@@ -4846,6 +5134,16 @@ var shared = {
   WEIGHT_CSS_MIN: WEIGHT_CSS_MIN,
   WEIGHT_CSS_MAX: WEIGHT_CSS_MAX,
   weightProfileFrom: weightProfileFrom,
+  combineWeightProfiles: combineWeightProfiles,
+  balancedStackShape: balancedStackShape,
+  evennessOf: evennessOf,
+  INK_BALANCE_SPREAD: INK_BALANCE_SPREAD,
+  INK_BALANCE_STEP: INK_BALANCE_STEP,
+  INK_BALANCE_SPREAD_WIDE: INK_BALANCE_SPREAD_WIDE,
+  WEIGHT_PROBE_LOW: WEIGHT_PROBE_LOW,
+  WEIGHT_PROBE_HIGH: WEIGHT_PROBE_HIGH,
+  WEIGHT_PROBE_STEP: WEIGHT_PROBE_STEP,
+  GENERIC_FAMILIES: GENERIC_FAMILIES,
   weightStepRange: weightStepRange,
   isShorthandName: isShorthandName,
   isScaledToken: isScaledToken,
@@ -6167,6 +6465,114 @@ var weightProbeCanvas = null;
 /** Cache of measured slider shapes, keyed by the resolved family stack. */
 var weightProfileCache = {};
 
+/**
+ * The families a stack can actually render text with.
+ *
+ * The first family draws the Latin text and a later one draws whatever the first
+ * cannot (that is where the Chinese comes from), so the notch step has to be one
+ * every one of them can follow. Generic keywords are dropped: `serif` is not a
+ * family anyone ships faces for.
+ * @param {string} stack - resolved `font-family` value.
+ * @returns {string[]} the family names, primary first.
+ */
+function stackFamilies(stack) {
+  var parsed = shared.parseStack(String(stack));
+  var out = [];
+  for (var index = 0; index < parsed.length; index += 1) {
+    var name = String(parsed[index]).trim();
+    if (name === "") continue;
+    if (shared.GENERIC_FAMILIES.indexOf(name.toLowerCase()) >= 0) continue;
+    if (out.indexOf(name) >= 0) continue;
+    out.push(name);
+  }
+  return out;
+}
+
+/**
+ * How many families of one stack are measured.
+ *
+ * Two covers the reported case — a Latin family with the CJK fallback behind it
+ * — and keeps the first measurement to about twice what it was: the probe renders
+ * the family on a canvas for every weight it asks about.
+ */
+var WEIGHT_STACK_FAMILIES = 2;
+
+/** Measured shapes per family, so a combined stack measures each family once. */
+var familyProfileCache = {};
+
+/**
+ * The text each family of a stack is measured on when the two have to move together.
+ *
+ * A stack is one Latin family followed by whatever draws the Chinese, and each of
+ * them draws only part of a mixed sample: measured on mixed text the Latin family
+ * borrows the Chinese from the browser's own fallback — a third family the reader
+ * never sees beside it — and its ink curve would then partly describe that one. The
+ * evenness comparison therefore measures each family on the script it renders.
+ */
+var WEIGHT_SAMPLE_LATIN = "Hamburgefonstiv 0189";
+var WEIGHT_SAMPLE_FALLBACK = "对话字体粗细大小变化";
+
+/**
+ * One family's slider shape, measured through its alias when it is promoted.
+ *
+ * `null` means the canvas could not answer; the caller then falls back to the
+ * nominal window instead of offering a control built on no data.
+ *
+ * When the stack has a second family, the record also carries `inkOf`, a sampler
+ * for that family's ink on the script it draws. `combineWeightProfiles` walks it to
+ * find the notch and range that move both families evenly (issue #4).
+ * @param {string} family - the family name, unquoted.
+ * @param {number} base - the heaviest weight the offset lands on.
+ * @param {string} alias - the variable alias to measure through, "" when none.
+ * @param {string|null} [inkText] - the text the ink is measured on, or null when the
+ *   stack has nothing to be even with.
+ * @returns {{min: number, max: number, step: number, inkOf: Function|null}|null}
+ *   the shape plus the ink sampler.
+ */
+function familyWeightProfile(family, base, alias, inkText) {
+  var text = typeof inkText === "string" && inkText !== "" ? inkText : null;
+  var key =
+    family +
+    "\u0000" +
+    base +
+    "\u0000" +
+    (alias === "" ? "stepped" : "continuous") +
+    "\u0000" +
+    (text === null ? "plain" : "ink");
+  if (Object.prototype.hasOwnProperty.call(familyProfileCache, key)) {
+    return familyProfileCache[key];
+  }
+  var record = null;
+  try {
+    var target = '"' + (alias === "" ? family : alias) + '"';
+    var seen = {};
+    var sample = function (weight) {
+      if (!Object.prototype.hasOwnProperty.call(seen, weight)) {
+        seen[weight] = sampleWeightSignature(target, weight);
+      }
+      return seen[weight];
+    };
+    var shape =
+      alias === ""
+        ? weightProfileFrom(sample, { top: base })
+        : weightProfileFrom(sample, { top: base, candidates: shared.CONTINUOUS_CANDIDATES });
+    record = { min: shape.min, max: shape.max, step: shape.step, inkOf: null };
+    if (text !== null) {
+      var inks = {};
+      record.inkOf = function (weight) {
+        if (!Object.prototype.hasOwnProperty.call(inks, weight)) {
+          inks[weight] = inkOfSignature(sampleWeightSignature(target, weight, text));
+        }
+        return inks[weight];
+      };
+    }
+  } catch (error) {
+    record = null;
+  }
+  familyProfileCache[key] = record;
+  return record;
+}
+
 /**
  * Values the card has moved but the settings document has not confirmed yet.
  *
@@ -6497,13 +6903,17 @@ function probeLog(kind, detail) {
  * — and report a coarse family where the weights are in fact continuous.
  * @param {string} stack - resolved `font-family` value.
  * @param {number} weight - CSS weight to draw with.
+ * @param {string} [text] - the text to draw; the card's shared sample by default.
  * @returns {string} the signature; equal signatures mean identical rendering.
  */
-function sampleWeightSignature(stack, weight) {
+function sampleWeightSignature(stack, weight, text) {
+  var sampleText = typeof text === "string" && text !== "" ? text : WEIGHT_SAMPLE_TEXT;
+  // Wide and tall enough for the longest sample (a run of CJK glyphs at 32px) and
+  // for the line box no family clips: a clipped glyph would undercount its ink.
   if (weightProbeCanvas === null) {
     weightProbeCanvas = document.createElement("canvas");
-    weightProbeCanvas.width = 260;
-    weightProbeCanvas.height = 56;
+    weightProbeCanvas.width = 420;
+    weightProbeCanvas.height = 64;
   }
   // `willReadFrequently` matters here: the profile probe reads the canvas back once
 // per sampled weight (~80 times on the first measurement), and without it the
@@ -6514,8 +6924,8 @@ var context = weightProbeCanvas.getContext("2d", { willReadFrequently: true });
   context.font = weight + " 32px " + stack;
   context.textBaseline = "top";
   context.fillStyle = "#000";
-  context.fillText(WEIGHT_SAMPLE_TEXT, 2, 6);
-  var advance = Math.round(context.measureText(WEIGHT_SAMPLE_TEXT).width * 1000);
+  context.fillText(sampleText, 2, 6);
+  var advance = Math.round(context.measureText(sampleText).width * 1000);
   var pixels = context.getImageData(0, 0, weightProbeCanvas.width, weightProbeCanvas.height).data;
   var ink = 0;
   for (var index = 3; index < pixels.length; index += 4) ink += pixels[index];
@@ -6569,21 +6979,38 @@ function weightProfileFor(stack, top) {
   var profile = promoted
     ? shared.continuousWeightProfile()
     : { min: WEIGHT_DELTA_MIN, max: WEIGHT_DELTA_MAX, step: 1 };
-  try {
-    // A continuous family is measured THROUGH ITS ALIAS, on the fine candidate grid:
-    // the axis answers at every notch, so the finest one that still moves body text
-    // wins, and the range stops where the family's own axis does instead of running
-    // past it into weights that render the same.
-    var target = promoted ? '"' + alias + '"' : resolved;
-    var seen = {};
-    var sample = function (weight) {
-      if (!Object.prototype.hasOwnProperty.call(seen, weight)) {
-        seen[weight] = sampleWeightSignature(target, weight);
-      }
-      return seen[weight];
-    };
-    profile = weightProfileFrom(sample, promoted ? { top: base, candidates: shared.CONTINUOUS_CANDIDATES } : { top: base });
-  } catch (error) {
+  // EVERY family the text can land on has to follow the same notch: the reader
+  // sets one offset, and a Chinese family with three faces behind a variable
+  // Latin one only moves where the Latin one has moved five times (issue #4).
+  // The shapes are combined into the coarsest shared step and the range they
+  // can all still express; the primary family alone is the answer only when the
+  // stack names one family.
+  // The shapes are combined into one notch that moves BOTH families evenly: the
+  // first family draws the Latin text and the one behind it draws the Chinese, so
+  // each is measured on its own script (issue #4).
+  var families = stackFamilies(resolved);
+  var shapes = [];
+  // Comparing the families' ink costs a second set of canvas renders, so it runs
+  // only when there IS a second family to be even with.
+  var keepEven = families.length > 1;
+  for (var index = 0; index < families.length && index < WEIGHT_STACK_FAMILIES; index += 1) {
+    // A continuous family is measured THROUGH ITS ALIAS, on the fine candidate
+    // grid: the axis answers at every notch, so the finest one that still moves
+    // body text wins, and the range stops where the family's own axis does.
+    var shape = familyWeightProfile(
+      families[index],
+      base,
+      index === 0 && promoted ? alias : "",
+      keepEven ? (index === 0 ? WEIGHT_SAMPLE_LATIN : WEIGHT_SAMPLE_FALLBACK) : null
+    );
+    if (shape !== null) shapes.push(shape);
+  }
+  // `base` is body text: the weight the two families' ink is compared at.
+  var combined = shared.combineWeightProfiles(shapes, { base: shared.WEIGHT_BASE });
+  if (combined !== null) {
+    profile = combined;
+  } else if (families.length > 0) {
+    // Nothing measured (no canvas, no 2D context): the nominal window it is.
     profile = promoted
       ? shared.continuousWeightProfile()
       : { min: WEIGHT_DELTA_MIN, max: WEIGHT_DELTA_MAX, step: 1 };

package/lib/shared.cjs

@@ -3254,6 +3254,294 @@ function ceilTo(value, step) {
   return Math.ceil(value / step) * step;
 }
 
+/**
+ * How far apart two families may land on one notch before the stack refuses it.
+ *
+ * Measured on the reporter's pair (issue #4): one 100-weight notch adds +21.5%
+ * ink to the Latin family and +23.9% to the Chinese one — 2.4 points apart, which
+ * no reader notices. One 200-weight notch adds +44% and +51% — 7.4 points apart,
+ * and that is the reported "one side suits, the other is too heavy". Five points
+ * is the budget between those two observations.
+ */
+var INK_BALANCE_SPREAD = 0.05;
+
+/**
+ * How far apart a pair may land when the strict budget would leave no control.
+ *
+ * Measured on the reporter's pair (issue #4): going one notch LIGHTER, the Latin
+ * family loses 29.7% of its ink and the Chinese one 17.9% — 11.9 points apart, and
+ * no finer notch makes it better, because the two families simply space their faces
+ * differently. Under the strict budget the reader would get a weight control that
+ * cannot go lighter at all (two positions). The wider budget is what keeps that
+ * physical pair usable, and it is only consulted when the strict one is: a stack
+ * that has four even positions never sees it.
+ */
+var INK_BALANCE_SPREAD_WIDE = 0.15;
+
+/** How many notches the evenness walk looks at, one way. */
+var WEIGHT_MAX_POSITIONS = 24;
+
+/**
+ * The least ink one notch has to add before a position is worth having.
+ *
+ * This is the bar `weightProfileFrom` already measured on this host: a 200-weight
+ * step is +30% ink and a 100-weight step +16%, and 100 was not enough — a reader
+ * could not see it. Five per cent would put a variable family's stack at twenty-odd
+ * notches that each move a little (measured live: 29 positions of +6%), which is the
+ * dead-control the coarse step exists to avoid. Fifteen keeps every pair the faces
+ * do allow (the reported one tops out at +19%/+22%) and stops there.
+ */
+var INK_BALANCE_STEP = 0.15;
+
+/**
+ * One family's ink at one weight.
+ *
+ * A family answers through `inkOf`, the sampler its own measurement already uses;
+ * a weight it cannot measure — or a family that cannot be measured at all — answers
+ * null and is left out of a comparison instead of counting as a zero.
+ * @param {Object} entry - one measured family.
+ * @param {number} weight - CSS weight.
+ * @returns {number|null} the ink, or null when there is no measurement.
+ */
+function entryInk(entry, weight) {
+  if (entry === null || typeof entry !== "object") return null;
+  if (typeof entry.inkOf !== "function") return null;
+  var ink = null;
+  try {
+    ink = entry.inkOf(weight);
+  } catch (error) {
+    return null;
+  }
+  ink = Number(ink);
+  if (!isFinite(ink) || ink <= 0) return null;
+  return ink;
+}
+
+/**
+ * How much moving from one weight to another changes each family's ink.
+ *
+ * The share is relative to the family's OWN ink at `from`, so two families that
+ * start out different sizes are still comparable: +20% means the same thing for
+ * both. Families that cannot be measured on both sides are left out.
+ * @param {Array<Object>} entries - the measured families.
+ * @param {number} from - the weight the reader is at.
+ * @param {number} to - the weight being compared.
+ * @returns {number[]|null} the relative changes, or null when fewer than two
+ *   families can be measured.
+ */
+function inkShares(entries, from, to) {
+  var shares = [];
+  for (var index = 0; index < entries.length; index += 1) {
+    var before = entryInk(entries[index], from);
+    var after = entryInk(entries[index], to);
+    if (before === null || after === null) continue;
+    shares.push((after - before) / before);
+  }
+  return shares.length < 2 ? null : shares;
+}
+
+/**
+ * How far apart the families land, and how little the quietest one moved.
+ * @param {number[]} shares - one relative change per family.
+ * @returns {{spread: number, smallest: number}} `spread` is the signed range, so
+ *   families moving in opposite directions count as far apart.
+ */
+function shareSpread(shares) {
+  var least = shares[0];
+  var most = shares[0];
+  var smallest = Math.abs(shares[0]);
+  for (var index = 1; index < shares.length; index += 1) {
+    if (shares[index] < least) least = shares[index];
+    if (shares[index] > most) most = shares[index];
+    var size = Math.abs(shares[index]);
+    if (size < smallest) smallest = size;
+  }
+  return { spread: most - least, smallest: smallest };
+}
+
+/**
+ * The evenness verdict for one move of the stack.
+ * @param {Array<Object>} entries - the measured families.
+ * @param {number} from - the weight the move starts at.
+ * @param {number} to - the weight it ends at.
+ * @returns {{spread: number, smallest: number}|null} the verdict, or null when it
+ *   cannot be measured.
+ */
+function evennessOf(entries, from, to) {
+  var shares = inkShares(entries, from, to);
+  if (shares === null) return null;
+  return shareSpread(shares);
+}
+
+/** Is one move of the stack both visible and even? */
+function moveIsEven(verdict, spread) {
+  return verdict !== null && verdict.smallest >= INK_BALANCE_STEP && verdict.spread <= spread;
+}
+
+/**
+ * The shape a stack of families can follow together, chosen for EVENNESS.
+ *
+ * Issue #4 is not about the range: it is about two families being moved by one
+ * offset and landing on faces that are not the same distance apart. The test is
+ * therefore walked outwards from the neutral position, one notch at a time, and a
+ * notch only survives when BOTH hold:
+ *  - every family's ink changes by at least `INK_BALANCE_STEP` (the notch is
+ *    visible), and
+ *  - the families land within `INK_BALANCE_SPREAD` of each other, measured both for
+ *    that one notch and for the whole way back to the neutral position — a stack
+ *    can be even notch by notch and still drift apart after two of them.
+ *
+ * The walk is what removes the synthetic-bold step without ever having to ask the
+ * browser whether a weight is drawn or faked: above its last real face a family is
+ * stroked thicker by the browser, which adds a much larger share of ink than a drawn
+ * face does — so the notch where one family jumps and the other does not simply
+ * fails the budget and the range stops in front of it.
+ *
+ * Among the shapes that survive, the one with the MOST positions wins: the visible
+ * floor above is what makes a finer notch worth having, and more positions is more
+ * control. (A single family is not put through this at all — it keeps the coarse
+ * shape `weightProfileFrom` measured for it.)
+ * @param {Array<{min: number, max: number, step: number, inkOf?: Function}>} entries
+ *   one record per measured family.
+ * @param {number} base - the weight the offset is added to (body text).
+ * @param {number} low - the lowest offset every family can express.
+ * @param {number} high - the highest offset every family can express.
+ * @returns {{min: number, max: number, step: number}|null} the shape, or null when
+ *   no step leaves the stack two positions to move between.
+ */
+function balancedStackShape(entries, base, low, high, spread) {
+  var budget = typeof spread === "number" && spread > 0 ? spread : INK_BALANCE_SPREAD;
+  var best = null;
+  var bestCount = 1;
+  var bestScore = Infinity;
+  for (var index = 0; index < WEIGHT_STEP_CANDIDATES.length; index += 1) {
+    var step = WEIGHT_STEP_CANDIDATES[index];
+    if (!(step > 0)) continue;
+    var up = 0;
+    var down = 0;
+    // A walk is bounded: no useful shape has more than a couple of dozen
+    // positions, and an unbounded one on a one-unit grid would cost hundreds of
+    // canvas renders on the very first measurement.
+    var limit = step * WEIGHT_MAX_POSITIONS;
+    for (var position = step; position <= high && position <= limit; position += step) {
+      if (!moveIsEven(evennessOf(entries, base + position - step, base + position), budget)) break;
+      if (!moveIsEven(evennessOf(entries, base, base + position), budget)) break;
+      up = position;
+    }
+    for (var back = step; back <= -low && back <= limit; back += step) {
+      if (!moveIsEven(evennessOf(entries, base - back + step, base - back), budget)) break;
+      if (!moveIsEven(evennessOf(entries, base, base - back), budget)) break;
+      down = back;
+    }
+    var count = (up + down) / step + 1;
+    if (count < 2) continue;
+    // How close the two families are on one notch from the neutral position: a tie
+    // between two shapes that move the stack over the same number of positions.
+    var headroom = evennessOf(entries, base, base + step);
+    if (headroom === null) headroom = evennessOf(entries, base, base - step);
+    var score = headroom === null ? Infinity : headroom.spread;
+    if (count > bestCount || (count === bestCount && score < bestScore)) {
+      // -0 would read as a different number to a strict comparison.
+      best = { min: down === 0 ? 0 : -down, max: up, step: step };
+      bestCount = count;
+      bestScore = score;
+    }
+  }
+  return best;
+}
+
+/**
+ * One slider shape for a stack whose text can land on more than one family.
+ *
+ * A reader sets ONE offset; the browser then renders English with the first
+ * family and Chinese with the fallback, each snapping that same requested value
+ * to its own faces. When the fallback ships three faces and the primary is a
+ * variable font, a step measured on the primary alone leaves the fallback
+ * unchanged on most notches — the reported "one side suits, the other is too
+ * heavy or too light" (issue #4: Inclusive Sans beside a three-face CJK family).
+ *
+ * The combined shape keeps every family moving on every notch, but the notch is
+ * chosen for EVENNESS (see `balancedStackShape`): each family has to change by a
+ * comparable share of its own ink, and the stack has to stay together over the
+ * whole length of the range. Families that can report their ink (`inkOf`) get that
+ * shape; a stack measured without a canvas keeps the plain shared-multiple shape,
+ * which is also what a single family gets.
+ * @param {Array<{min: number, max: number, step: number, inkOf?: Function}|null>} profiles
+ *   one shape per family.
+ * @param {{base?: number}} [options] `base` is the weight the offset is added to
+ *   (body text); it anchors the ink comparison.
+ * @returns {{min: number, max: number, step: number}|null} the combined shape, or
+ *   null when nothing usable was measured.
+ */
+function combineWeightProfiles(profiles, options) {
+  var list = [];
+  if (Array.isArray(profiles)) {
+    for (var index = 0; index < profiles.length; index += 1) {
+      var entry = profiles[index];
+      if (entry === null || typeof entry !== "object") continue;
+      if (!isFinite(entry.min) || !isFinite(entry.max) || !isFinite(entry.step)) continue;
+      if (!(entry.step > 0)) continue;
+      list.push(entry);
+    }
+  }
+  if (list.length === 0) return null;
+  if (list.length === 1) return { min: list[0].min, max: list[0].max, step: list[0].step };
+  var step = list[0].step;
+  for (var other = 1; other < list.length; other += 1) {
+    step = commonStep(step, list[other].step);
+  }
+  var low = list[0].min;
+  var high = list[0].max;
+  for (var more = 1; more < list.length; more += 1) {
+    low = Math.max(low, list[more].min);
+    high = Math.min(high, list[more].max);
+  }
+  var settings = options === null || typeof options !== "object" ? {} : options;
+  var base = isFinite(settings.base) ? Number(settings.base) : WEIGHT_BASE;
+  // Every family that can report ink is put through the evenness walk; a stack whose
+  // canvas could not answer keeps the plain shared-multiple shape.
+  var measured = false;
+  for (var scan = 0; scan < list.length; scan += 1) {
+    if (typeof list[scan].inkOf === "function") measured = true;
+  }
+  if (measured) {
+    var even = balancedStackShape(list, base, low, high);
+    var positions = even === null ? 0 : (even.max - even.min) / even.step + 1;
+    if (positions >= 3) return even;
+    // The pair's own faces are spaced so unevenly that the strict budget leaves
+    // no control; the wider one is what keeps a lighter position reachable.
+    var relaxed = balancedStackShape(list, base, low, high, INK_BALANCE_SPREAD_WIDE);
+    var relaxedPositions = relaxed === null ? 0 : (relaxed.max - relaxed.min) / relaxed.step + 1;
+    if (relaxedPositions > positions) return relaxed;
+    if (even !== null) return even;
+  }
+  var onGrid = { min: ceilTo(low, step), max: floorTo(high, step) };
+  if (onGrid.max >= onGrid.min) return { min: onGrid.min, max: onGrid.max, step: step };
+  var widest = list[0];
+  for (var alt = 1; alt < list.length; alt += 1) {
+    if (list[alt].max - list[alt].min > widest.max - widest.min) widest = list[alt];
+  }
+  return { min: widest.min, max: widest.max, step: widest.step };
+}
+
+/**
+ * The smallest candidate step that is a whole multiple of both inputs.
+ *
+ * Profiles come from one candidate list, so a shared multiple usually exists
+ * there; two steps that share none fall back to the coarser one, which still
+ * moves the coarser family on every notch.
+ * @param {number} a - one step.
+ * @param {number} b - another step.
+ * @returns {number} the combined step.
+ */
+function commonStep(a, b) {
+  for (var index = 0; index < WEIGHT_STEP_CANDIDATES.length; index += 1) {
+    var candidate = WEIGHT_STEP_CANDIDATES[index];
+    if (candidate % a === 0 && candidate % b === 0) return candidate;
+  }
+  return Math.max(a, b);
+}
+
 /**
  * Does every position of `[min..max]` in `step` increments render differently?
  *
@@ -4837,6 +5125,16 @@ var shared = {
   WEIGHT_CSS_MIN: WEIGHT_CSS_MIN,
   WEIGHT_CSS_MAX: WEIGHT_CSS_MAX,
   weightProfileFrom: weightProfileFrom,
+  combineWeightProfiles: combineWeightProfiles,
+  balancedStackShape: balancedStackShape,
+  evennessOf: evennessOf,
+  INK_BALANCE_SPREAD: INK_BALANCE_SPREAD,
+  INK_BALANCE_STEP: INK_BALANCE_STEP,
+  INK_BALANCE_SPREAD_WIDE: INK_BALANCE_SPREAD_WIDE,
+  WEIGHT_PROBE_LOW: WEIGHT_PROBE_LOW,
+  WEIGHT_PROBE_HIGH: WEIGHT_PROBE_HIGH,
+  WEIGHT_PROBE_STEP: WEIGHT_PROBE_STEP,
+  GENERIC_FAMILIES: GENERIC_FAMILIES,
   weightStepRange: weightStepRange,
   isShorthandName: isShorthandName,
   isScaledToken: isScaledToken,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-fonttune",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "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",