dsh-fonttune 0.7.3 → 0.7.5

package/CHANGELOG.en.md

@@ -2,6 +2,19 @@
 
 All notable changes to **dsh-fonttune** are documented here. Chinese version: [CHANGELOG.md](CHANGELOG.md).
 
+## [0.7.5] - 2026-11-01
+
+### Fixed
+- **The floating dot covered the composer in a new session**: before conversation text appeared, the dot could remain over the input area; it now moves to the lower-left of the main content area, clear of both the composer and the sidebar.
+
+## [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,19 @@
 
 **dsh-fonttune** 的重要变更都记录在这里。英文版见 [CHANGELOG.en.md](CHANGELOG.en.md)。
 
+## [0.7.5] - 2026-11-01
+
+### 修复
+- **新会话中的悬浮圆点遮挡输入框**：对话正文尚未出现时，圆点可能停在输入框内；现在会将这类位置移至主内容区左下角，避开输入框与侧栏。
+
+## [0.7.4] - 2026-10-30
+
+### 修复
+- **中英混排时两边字重不同步**：一套中文字体只带几个字面时，字重滑块有些档位只让西文变、中文不动，有些档位是浏览器把中文自动加粗，读起来一边太重一边太轻。现在档位取自两种字体都能真画出来的范围，每档两边变化幅度接近。
+
+### 变更
+- **档位数量按字体能画的字面计算**：中文字面越多的字体，滑块给的档位越多——只有三个字面的中文字体最多三档，七个字面的约多一倍。读数是档数，换字体后档数会跟着变。
+
 ## [0.7.3] - 2026-10-29
 
 ### 修复

package/lib/client.js

@@ -1238,6 +1238,23 @@ function floatBoundsFrom(rects, viewport) {
   return floatBoundsPick(rects, viewport).bounds;
 }
 
+/**
+ * The fallback region to use when the conversation has no measurable text yet.
+ *
+ * The page's whole-window stand-in starts at x=0, which puts the dot over the left
+ * navigation rail. On a host shell that exposes a main-column rectangle, using that
+ * rectangle as the fallback puts the dot at the content column's left corner while
+ * the conversation itself is mounting. If the shell supplies no usable region, the
+ * viewport stays the fallback.
+ * @param {unknown} region - the main content column, or null when unavailable.
+ * @param {{width: number, height: number}} viewport - the window size.
+ * @returns {{left:number,top:number,right:number,bottom:number,width:number,height:number}}
+ *   the clipped content box, or the whole viewport.
+ */
+function floatFallbackBounds(region, viewport) {
+  return floatBoundsPick(region === null || region === undefined ? [] : [region], viewport).bounds;
+}
+
 /**
  * Whether a second reading of the winning rectangle is the same shape as the last.
  *
@@ -3263,6 +3280,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?
  *
@@ -4678,6 +4983,7 @@ var shared = {
   floatBoxOf: floatBoxOf,
   floatBoundsPick: floatBoundsPick,
   floatBoundsFrom: floatBoundsFrom,
+  floatFallbackBounds: floatFallbackBounds,
   sameWatchBounds: sameWatchBounds,
   floatTargetsConnected: floatTargetsConnected,
   floatQuadrantIn: floatQuadrantIn,
@@ -4846,6 +5152,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 +6483,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 +6921,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 +6942,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 +6997,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 };
@@ -10934,9 +11379,9 @@ function mountFloatPanel(scope, t, hostCtx) {
     return null;
   };
 
-  // Whether the last region reading was a real region or the whole-window
-  // stand-in (see `floatBounds`). A stand-in never moves the dot: it means "no
-  // conversation to measure right now", not "the conversation is the window".
+  // Whether the last bounds reading was a REAL conversation region or a stand-in
+  // (main column, then viewport; see `floatBounds`). A stand-in means "no conversation
+  // to measure right now", not "the conversation is that whole shell column".
   var boundsAreReal = false;
 
   /** The window size the bounds are cut to, with the shared fallback. */
@@ -10954,9 +11399,62 @@ function mountFloatPanel(scope, t, hostCtx) {
    * session had 36. The first in document order is usually an old turn scrolled
    * thousands of pixels off screen, and its scroll container can measure zero;
    * reading the bounds from that one element alone threw both of its candidates
-   * away and snapped the dot to the whole window instead of the conversation.
+   * away and snapped the dot to the fallback area instead of the conversation.
    * @returns {Array<object>} the prose elements (possibly empty).
    */
+  var EDITABLE_ANCESTOR =
+    "[contenteditable]:not([contenteditable='false']),textarea,input,[role='textbox']";
+
+  /**
+   * Whether a node sits inside something the reader types into.
+   * @param {object} node - the element to test (it counts as its own ancestor).
+   * @returns {boolean} true for the composer and anything inside it.
+   */
+  var insideEditable = function (node) {
+    try {
+      return node.closest(EDITABLE_ANCESTOR) !== null;
+    } catch (error) {
+      return false;
+    }
+  };
+
+  /**
+   * Whether the dot's stored position lies over a field the reader types into.
+   *
+   * On a fresh session no conversation region is measurable, and a stand-in never
+   * moves a dot that already has a position. A dot saved over the composer (the
+   * reported bug: its region was the input's own box) would therefore stay inside
+   * the input for good. That place is wrong whatever the region is, so this is the
+   * one case the stand-in may relocate.
+   * @returns {boolean} true when the stored square overlaps an editable field.
+   */
+  var strandedInField = function () {
+    if (pos === null) return false;
+    var left = pos.x;
+    var top = pos.y;
+    var right = pos.x + shared.FLOAT_DOT;
+    var bottom = pos.y + shared.FLOAT_DOT;
+    try {
+      var fields = document.querySelectorAll(EDITABLE_ANCESTOR);
+      for (var index = 0; index < fields.length; index += 1) {
+        var box = fields[index].getBoundingClientRect();
+        if (
+          box.width > 0 &&
+          box.height > 0 &&
+          left < box.right &&
+          right > box.left &&
+          top < box.bottom &&
+          bottom > box.top
+        ) {
+          return true;
+        }
+      }
+    } catch (error) {
+      return false;
+    }
+    return false;
+  };
+
   var proseElements = function () {
     var found = [];
     var add = function (nodes) {
@@ -10971,7 +11469,17 @@ function mountFloatPanel(scope, t, hostCtx) {
     } catch (error) {
       // A page without a queryable document keeps the empty list (the window).
     }
-    return found;
+    // The composer is part of the conversation container on a fresh session, so a
+    // paragraph the input holds matches the conversation selector too. Measured
+    // live: one typed character left a `<p>` in the input, and the dot's region
+    // became the input's own scroll box, which parked the dot inside the input. A
+    // message is never typed into a field, so anything inside one is not the
+    // conversation, whatever class or attribute it carries.
+    var kept = [];
+    for (var at = 0; at < found.length; at += 1) {
+      if (!insideEditable(found[at])) kept.push(found[at]);
+    }
+    return kept;
   };
 
   /**
@@ -11063,25 +11571,71 @@ function mountFloatPanel(scope, t, hostCtx) {
     return true;
   };
 
+  /**
+   * The main content column while the conversation itself has no measurable prose.
+   *
+   * DSH's shell marks its bottom-row element with a stable data attribute and puts
+   * it directly inside the three-column frame. The frame's direct children are the
+   * left rail, the main column and the right rail; taking the main column's actual
+   * rectangle means its left edge follows an open or collapsed sidebar without a
+   * plugin-specific width guess, and its right edge leaves room for the right rail.
+   * If the shell changes shape or is not present, the viewport remains the fallback.
+   * @returns {object|null} the main column's rectangle, or null when it is not usable.
+   */
+  var shellMainColumnRect = function () {
+    try {
+      var bottom = document.querySelector("[data-shell-bottom]");
+      var frame = bottom === null ? null : bottom.parentElement;
+      if (frame === null || frame === undefined || frame.children.length < 2) return null;
+      var sidebar = frame.children[0];
+      var main = frame.children[1];
+      if (
+        main === null ||
+        main === undefined ||
+        main.hasAttribute("data-rightbar-col") ||
+        main.hasAttribute("data-shell-bottom") ||
+        main.hasAttribute("data-shell-overlay")
+      ) {
+        return null;
+      }
+      var sidebarRect = rectOf(sidebar);
+      var mainRect = rectOf(main);
+      if (
+        sidebarRect === null ||
+        mainRect === null ||
+        !(sidebarRect.width > 0) ||
+        !(mainRect.width > 0) ||
+        !(mainRect.height > 0) ||
+        mainRect.left + 1 < sidebarRect.right
+      ) {
+        return null;
+      }
+      return mainRect;
+    } catch (error) {
+      return null;
+    }
+  };
+
   /**
    * The rectangle the dot snaps to, drags within and reads its own quadrant from.
    *
-   * The conversation when it can be found, the whole window when it cannot (a
-   * settings page has no prose at all): the window is what this used to be
-   * everywhere, and it stays the last resort rather than the rule.
+   * The conversation when it can be found; when no conversation is measurable,
+   * the host's main column stands in so the bottom-left home is just past the left
+   * rail, rather than underneath its avatar. On pages that do not expose a main
+   * column, the whole window remains the fallback.
    *
-   * WHICH one answered is remembered in `boundsAreReal`, because the two are not
-   * interchangeable for a MOVE: the whole window is a stand-in for "there is no
-   * conversation to measure at this instant" — a session still mounting, a
-   * message list laid out at 0×0 — and a dot parked on the window's corner over
-   * a page that does have a conversation is exactly the reported "it sits on the
-   * window's left edge instead of the conversation's corner".
+   * WHICH one answered is remembered in `boundsAreReal`, because the main column
+   * is still a stand-in, not a real conversation region: a stored dot only moves
+   * within it when its saved position sits over an editable field (see
+   * `strandedInField`).
    * @returns {object} the bounds, in viewport coordinates.
    */
   var floatBounds = function () {
-    var picked = shared.floatBoundsPick(floatBoundsRects(), floatViewport());
+    var viewport = floatViewport();
+    var picked = shared.floatBoundsPick(floatBoundsRects(), viewport);
     boundsAreReal = picked.index >= 0;
-    return picked.bounds;
+    if (boundsAreReal) return picked.bounds;
+    return shared.floatFallbackBounds(shellMainColumnRect(), viewport);
   };
 
   /**
@@ -11637,13 +12191,12 @@ function mountFloatPanel(scope, t, hostCtx) {
    */
   var snapToCorner = function (instant) {
     var bounds = floatBounds();
-    // A stand-in region is not a home: the window's corner is what the dot would
-    // land on over a page whose conversation is merely not measurable yet, which
-    // is the reported "it snaps to the window's left edge instead of the
-    // conversation's corner". A dot the document already placed keeps the corner
+    // A stand-in region is not a home: the main-column corner is only where an
+    // editable-field position can be re-homed while the conversation is not
+    // measurable yet. A dot the document already placed keeps the corner
     // the last REAL region gave it; the observer settles it again the moment one
     // exists (see `reflowIntoBounds`).
-    if (!boundsAreReal && pos !== null) return pos;
+    if (!boundsAreReal && pos !== null && !strandedInField()) return pos;
     var snapped;
     if (pos !== null) {
       snapped = cornerHome(bounds, pos);
@@ -11785,10 +12338,13 @@ function mountFloatPanel(scope, t, hostCtx) {
     var bounds = floatBounds();
     // Nothing real to settle onto: a shut panel on a settings page, or a
     // conversation that is not measurable at this instant, leaves the dot where
-    // it is — moving it onto the window's corner is the bug, not the fallback.
+    // it is — moving it onto the fallback corner is the bug, not the fallback.
     // With nothing stored at all there is no home to keep, so the stylesheet's
-    // own corner is pinned as before.
-    if (!boundsAreReal && pos !== null) return false;
+    // own corner is pinned as before. The one exception is a dot stored INSIDE a
+    // field the reader types into (see `strandedInField`): that place is wrong
+    // whatever the region is, so it is re-homed to the main column and persisted.
+    var rehomeEditable = !boundsAreReal && pos !== null && strandedInField();
+    if (!boundsAreReal && pos !== null && !rehomeEditable) return false;
     var at = pos;
     if (at === null) {
       var rect = rectOf(host);
@@ -11833,7 +12389,7 @@ function mountFloatPanel(scope, t, hostCtx) {
     // told which corner that is, in the same `mutate`. A region that changed
     // shape is the caller that has to store the move it just made, wherever the
     // dot was standing before (see the note above).
-    if (outside || naming) persistIfDirty();
+    if (outside || naming || rehomeEditable) persistIfDirty();
     if (regionMoved === true) persistIfDirty();
     return true;
   };

package/lib/shared.cjs

@@ -1229,6 +1229,23 @@ function floatBoundsFrom(rects, viewport) {
   return floatBoundsPick(rects, viewport).bounds;
 }
 
+/**
+ * The fallback region to use when the conversation has no measurable text yet.
+ *
+ * The page's whole-window stand-in starts at x=0, which puts the dot over the left
+ * navigation rail. On a host shell that exposes a main-column rectangle, using that
+ * rectangle as the fallback puts the dot at the content column's left corner while
+ * the conversation itself is mounting. If the shell supplies no usable region, the
+ * viewport stays the fallback.
+ * @param {unknown} region - the main content column, or null when unavailable.
+ * @param {{width: number, height: number}} viewport - the window size.
+ * @returns {{left:number,top:number,right:number,bottom:number,width:number,height:number}}
+ *   the clipped content box, or the whole viewport.
+ */
+function floatFallbackBounds(region, viewport) {
+  return floatBoundsPick(region === null || region === undefined ? [] : [region], viewport).bounds;
+}
+
 /**
  * Whether a second reading of the winning rectangle is the same shape as the last.
  *
@@ -3254,6 +3271,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?
  *
@@ -4669,6 +4974,7 @@ var shared = {
   floatBoxOf: floatBoxOf,
   floatBoundsPick: floatBoundsPick,
   floatBoundsFrom: floatBoundsFrom,
+  floatFallbackBounds: floatFallbackBounds,
   sameWatchBounds: sameWatchBounds,
   floatTargetsConnected: floatTargetsConnected,
   floatQuadrantIn: floatQuadrantIn,
@@ -4837,6 +5143,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.5",
   "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",