dsh-fonttune 0.4.1 → 0.5.0

package/CHANGELOG.en.md

@@ -2,6 +2,24 @@
 
 All notable changes to **dsh-fonttune** are documented here. Chinese version: [CHANGELOG.md](CHANGELOG.md).
 
+## [0.5.0] - 2026-10-13
+
+### Added
+- **Finer weight steps on fonts with a continuous weight range**: for a font that supports one, the weight slider of the conversation, the interface and code goes from a handful of steps to a couple of dozen, and every notch changes the text. Machines whose fonts do not support it keep the steps they had.
+
+### Fixed
+- **Headings shrank when the conversation line height was adjusted**: the axis now moves the spacing alone, leaving the size and the hierarchy of headings and body text untouched.
+- **The floating panel offered different weight steps than the settings card**: both now read and write the same steps and the same range.
+- **The preview box did not match the real conversation**: moving the weight by one step now shows in the preview as well.
+
+### Changed
+- **The weight hints no longer describe a change of face per step**: on a font with a continuous weight range that is not what happens, so they now say every notch makes the text a little bolder or lighter.
+
+## [0.4.2] - 2026-10-12
+
+### Changed
+- **DSH 0.2.1-alpha.1 and 0.2.1-alpha.2 join the compatibility table**: both were verified live — the settings card, the floating panel's tweaks and their writes, and the plugin's page all behave as documented.
+
 ## [0.4.1] - 2026-10-04
 
 ### Fixed

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 **dsh-fonttune** 的重要变更都记录在这里。英文版见 [CHANGELOG.en.md](CHANGELOG.en.md)。
 
+## [0.5.0] - 2026-10-13
+
+### 新增
+- **字重滑块在无级字重的字体上更细**：字体本身支持无级字重时，对话、界面、代码三处的字重滑块从原来的几档变为二十几档，每挪一格文字都有变化；字体不支持的机器上档位与之前相同。
+
+### 修复
+- **调整对话行高时标题字号变小**：现在只改变行距，标题与正文的字号与层级保持不变。
+- **浮动面板的字重档位与设置页不一致**：两处显示与写入的档位、范围现在相同。
+- **预览框与真实对话的字体表现不一致**：预览里挪动字重看不出变化的问题不再出现。
+
+### 变更
+- **字重提示文字不再描述"每一格都换一张字形"**：在无级字重的字体上这句话不成立，改为说明每挪一格文字都会变粗或变细。
+
+## [0.4.2] - 2026-10-12
+
+### 变更
+- **兼容对照表列出 DSH 0.2.1-alpha.1 与 0.2.1-alpha.2**：两个新预发布版实测通过，设置卡片、悬浮面板调参与写入、插件页卡片均正常。
+
 ## [0.4.1] - 2026-10-04
 
 ### 修复

package/README.en.md

@@ -28,7 +28,8 @@
 
 | Plugin version | Supported DSH versions |
 | --- | --- |
-| **0.4.x** (latest, 0.4.1) | 0.1.7-alpha.1, 0.1.7-alpha.2, 0.1.7-rc.1, 0.1.7-rc.2, 0.2.0-rc.1, 0.2.0-rc.2 |
+| **0.5.x** (latest, 0.5.0) | 0.1.7-alpha.1, 0.1.7-alpha.2, 0.1.7-rc.1, 0.1.7-rc.2, 0.2.0-rc.1, 0.2.0-rc.2, 0.2.1-alpha.1, 0.2.1-alpha.2 |
+| 0.4.x (0.4.2) | 0.1.7-alpha.1, 0.1.7-alpha.2, 0.1.7-rc.1, 0.1.7-rc.2, 0.2.0-rc.1, 0.2.0-rc.2, 0.2.1-alpha.1, 0.2.1-alpha.2 |
 | 0.3.x (0.3.6) | 0.1.7-alpha.1, 0.1.7-alpha.2, 0.1.7-rc.1, 0.1.7-rc.2, 0.2.0-rc.1, 0.2.0-rc.2 |
 | 0.2.x (0.2.8) | 0.1.5-rc.3, 0.1.7-alpha.1, 0.1.7-alpha.2, 0.1.7-rc.1, 0.1.7-rc.2 |
 

package/README.md

@@ -28,7 +28,8 @@
 
 | 插件版本 | 支持的 DSH 版本 |
 | --- | --- |
-| **0.4.x**（最新，0.4.1） | 0.1.7-alpha.1、0.1.7-alpha.2、0.1.7-rc.1、0.1.7-rc.2、0.2.0-rc.1、0.2.0-rc.2 |
+| **0.5.x**（最新，0.5.0） | 0.1.7-alpha.1、0.1.7-alpha.2、0.1.7-rc.1、0.1.7-rc.2、0.2.0-rc.1、0.2.0-rc.2、0.2.1-alpha.1、0.2.1-alpha.2 |
+| 0.4.x（0.4.2） | 0.1.7-alpha.1、0.1.7-alpha.2、0.1.7-rc.1、0.1.7-rc.2、0.2.0-rc.1、0.2.0-rc.2、0.2.1-alpha.1、0.2.1-alpha.2 |
 | 0.3.x（0.3.6） | 0.1.7-alpha.1、0.1.7-alpha.2、0.1.7-rc.1、0.1.7-rc.2、0.2.0-rc.1、0.2.0-rc.2 |
 | 0.2.x（0.2.8） | 0.1.5-rc.3、0.1.7-alpha.1、0.1.7-alpha.2、0.1.7-rc.1、0.1.7-rc.2 |
 

package/lib/client.js

@@ -2338,6 +2338,27 @@ function rebuildShorthand(parts) {
  * token classification
  * ------------------------------------------------------------------ */
 
+/**
+ * Whether a CSS selector declares something for the WHOLE page.
+ *
+ * The typography tokens live on `:root`, `html` or `body`. A selector scoped to a class
+ * or an attribute declares a LOCAL value: another plugin's module stylesheet may reuse a
+ * token name for its own compact panel (measured: `dsh-better-sidebar` sets
+ * `--dsw-font-markdown-h1` to `600 13px/18px` on `.…_taskMarkdown`), and reading that as
+ * the base hands the conversation a size that panel picked for itself.
+ * @param {string} selector - a rule's selector text.
+ * @returns {boolean} true when every selector in the list is a root scope.
+ */
+function isRootScopeSelector(selector) {
+  if (typeof selector !== "string" || selector.trim() === "") return false;
+  var parts = selector.split(",");
+  for (var index = 0; index < parts.length; index += 1) {
+    var part = parts[index].trim().toLowerCase();
+    if (part !== ":root" && part !== "html" && part !== "body" && part !== "*") return false;
+  }
+  return true;
+}
+
 /**
  * Match DSH's typography PART tokens: the design system's sizes plus the
  * content size the theme plugin writes on `body` (whose secondary variant
@@ -3178,6 +3199,180 @@ function weightStepRange(profile, value) {
   return { min: min, max: max, unit: unit, value: count };
 }
 
+/* ------------------------------------------------------------------ *
+ * continuous weight (FT-060)
+ * ------------------------------------------------------------------ */
+
+/** Prefix of the alias family a continuous family is drawn through. */
+var VARIABLE_ALIAS_PREFIX = "dfp-vf-";
+
+/**
+ * The weights the continuity probe lays out. Dense on purpose: a variable font
+ * that moves in small steps shows a width change at every one of them, while a
+ * family that snaps to named instances repeats its width across each stretch.
+ */
+var CONTINUITY_WEIGHTS = [400, 420, 440, 460, 480, 500, 550, 600, 650, 700, 750, 800, 900];
+
+/**
+ * The share of adjacent probe pairs that must differ before a family's laid-out
+ * WIDTH counts as continuous. Measured: a variable family drawn through its alias
+ * changes width at every sampled weight (share 1.0), while a family snapping to
+ * named instances repeats its width across each stretch (share 0.25–0.42).
+ */
+var CONTINUOUS_MIN_SHARE = 0.9;
+
+/**
+ * The notches offered for a continuous family, finest first.
+ *
+ * The shape is still measured (the alias is drawn on the same weight grid as any
+ * other family), but the candidates are fine: a continuous axis can answer at every
+ * one of them, which is the whole point of the mode. `weightProfileFrom` walks this
+ * list from the END, so the finest candidate that still yields enough visible
+ * positions wins.
+ */
+var CONTINUOUS_CANDIDATES = [10, 20, 25];
+
+/**
+ * The nominal continuous slider, used when the measured shape cannot be taken
+ * (no canvas, a refused probe). One notch is 20 weight units; the range is the
+ * widest offset the ceiling allows either way.
+ */
+var CONTINUOUS_STEP = 20;
+var CONTINUOUS_RANGE = 200;
+
+/**
+ * How many different values a list of measurements holds.
+ * @param {number[]} values - the measurements.
+ * @returns {number} the count of distinct values.
+ */
+function distinctCount(values) {
+  if (!Array.isArray(values)) return 0;
+  var seen = [];
+  for (var index = 0; index < values.length; index += 1) {
+    if (seen.indexOf(values[index]) < 0) seen.push(values[index]);
+  }
+  return seen.length;
+}
+
+/**
+ * Does the same family answer more finely through its alias than through itself?
+ *
+ * This is the discriminator the continuity probe trusts, and it needs no threshold:
+ * a family that snaps to named instances renders IDENTICALLY either way, so both
+ * responses hold the same number of distinct values; a variable family drawn through
+ * the alias moves at weights where the system path already stopped. Comparing the
+ * family against ITSELF also keeps the answer honest for a narrow axis, where a
+ * share-of-neighbours rule would read saturation as "static".
+ * @param {number[]} throughAlias - measurements taken through the alias face.
+ * @param {number[]} plain - the same measurements taken through the family itself.
+ * @returns {boolean} true when the alias resolves finer detail.
+ */
+function respondsFinerThan(throughAlias, plain) {
+  if (!Array.isArray(throughAlias) || !Array.isArray(plain)) return false;
+  var fine = distinctCount(throughAlias);
+  return fine >= 3 && fine > distinctCount(plain);
+}
+
+
+/**
+ * The alias family name for one family. A hash, not the family itself, so the
+ * name is a plain identifier whatever the family is called.
+ * @param {string} family - a family name.
+ * @returns {string} the alias, stable across sessions.
+ */
+function variableAliasFor(family) {
+  var text = sanitizeFamily(family);
+  var hash = 0;
+  for (var index = 0; index < text.length; index += 1) {
+    hash = (hash * 31 + text.charCodeAt(index)) >>> 0;
+  }
+  return VARIABLE_ALIAS_PREFIX + hash.toString(36);
+}
+
+/**
+ * The `@font-face` rule that draws one family through its own variable axis.
+ *
+ * `local()` points the face at the installed family, and the weight RANGE is the
+ * part that matters: it tells the engine the family is continuous, so `font-weight`
+ * picks a point on the axis instead of the nearest named instance. (Without the
+ * range the same family snaps; `font-variation-settings` does not help a system
+ * family at all — measured, see FT-060.)
+ * @param {string} family - the installed family name.
+ * @param {string} alias - the alias from `variableAliasFor`.
+ * @returns {string} one CSS rule.
+ */
+function variableFaceRule(family, alias) {
+  var text = sanitizeFamily(family).replace(/"/g, "");
+  return '@font-face{font-family:"' + alias + '";src:local("' + text + '");font-weight:100 900;}';
+}
+
+/**
+ * Every `@font-face` rule for a map of family → alias.
+ * @param {Record<string, string>} variable - the families that measured continuous.
+ * @returns {string} the rules, one per line; "" when there are none.
+ */
+function buildVariableFaces(variable) {
+  var rules = [];
+  if (variable === null || typeof variable !== "object") return "";
+  for (var family in variable) {
+    if (Object.prototype.hasOwnProperty.call(variable, family)) {
+      rules.push(variableFaceRule(family, variable[family]));
+    }
+  }
+  return rules.join("\n");
+}
+
+/**
+ * Put the alias IN FRONT of every continuous family a stack names.
+ *
+ * The family stays in the list after its alias, so a glyph the alias lacks still
+ * falls through to the same face the reader chose, and a stack that names no
+ * continuous family is returned unchanged.
+ * @param {string} stack - a formatted font-family value.
+ * @param {Record<string, string>} variable - family → alias map.
+ * @returns {string} the stack, with aliases prepended where they apply.
+ */
+function withVariableFaces(stack, variable) {
+  if (typeof stack !== "string" || stack === "" || variable === null || typeof variable !== "object") {
+    return stack;
+  }
+  // The stack may already carry its alias — a family read back from the page's own
+  // computed style does, once the mode is on. Prepending it again would stack up a
+  // duplicate on every rebuild.
+  var names = parseStack(stack);
+  var lead = names.length > 0 ? names[0] : "";
+  var prefix = [];
+  for (var family in variable) {
+    if (!Object.prototype.hasOwnProperty.call(variable, family)) continue;
+    if (stack.indexOf(quoteFamily(family)) < 0) continue;
+    if (lead === variable[family]) continue;
+    prefix.push('"' + variable[family] + '"');
+  }
+  return prefix.length === 0 ? stack : prefix.join(", ") + ", " + stack;
+}
+
+/**
+ * Did a family respond continuously to weight in the probe?
+ * @param {number[]} widths - laid-out widths, in `CONTINUITY_WEIGHTS` order.
+ * @returns {boolean} true when enough neighbours differ.
+ */
+function isContinuousResponse(widths) {
+  if (!Array.isArray(widths) || widths.length < 3) return false;
+  var changes = 0;
+  for (var index = 1; index < widths.length; index += 1) {
+    if (widths[index] !== widths[index - 1]) changes += 1;
+  }
+  return changes / (widths.length - 1) >= CONTINUOUS_MIN_SHARE;
+}
+
+/**
+ * The slider shape for a continuous family: the finest notch, centred on 0.
+ * @returns {{min: number, max: number, step: number}} the profile, in weight units.
+ */
+function continuousWeightProfile() {
+  return { min: -CONTINUOUS_RANGE, max: CONTINUOUS_RANGE, step: CONTINUOUS_STEP };
+}
+
 /**
  * What a slider's local (unconfirmed) value should do when a value arrives from
  * the settings document.
@@ -3265,10 +3460,12 @@ function isDormant(config) {
  * @param {boolean} isDark - prefix every rule with the dark-theme attribute.
  * @returns {string} declarations for one `<style>` element.
  */
-function buildAxisCss(axis, baseTokens, isDark, hints) {
-  var sans = formatStack(parseStack(axis[SANS_FIELD]));
-  var mono = formatStack(parseStack(axis[MONO_FIELD]));
-  var dialog = formatStack(parseStack(axis[STACK_DIALOG_FIELD]));
+function buildAxisCss(axis, baseTokens, isDark, hints, variable) {
+  // A continuous family leads its stack with its alias (see `withVariableFaces`);
+  // with no map, every stack stays exactly as written.
+  var sans = withVariableFaces(formatStack(parseStack(axis[SANS_FIELD])), variable);
+  var mono = withVariableFaces(formatStack(parseStack(axis[MONO_FIELD])), variable);
+  var dialog = withVariableFaces(formatStack(parseStack(axis[STACK_DIALOG_FIELD])), variable);
   // Normalised once: an expanded axis always carries a number, but a caller
   // handing in a raw object may leave the field out, and "absent" has to mean
   // "unset" rather than "write the string undefined". The conversation's value
@@ -3668,7 +3865,28 @@ function buildAxisCss(axis, baseTokens, isDark, hints) {
     if (noBold) declarations.push(bodyRule("font-synthesis-weight:none !important"));
   }
 
-  return declarations.join("\n");
+  return hardenDeltaRefs(declarations.join("\n"));
+}
+
+/**
+ * Give every reference to the content-size delta a fallback value.
+ *
+ * A heading's `font` shorthand is the markdown token, and DSH's own text for it reads
+ * `calc(21px + var(--dsh-content-font-delta))` — a reference with NO fallback. Nothing
+ * outside this plugin defines that property, so any rebuild that emits the reference
+ * without the definition leaves it resolving to nothing, which makes the WHOLE shorthand
+ * invalid at computed-value time: every font longhand falls back to `inherit`, and the
+ * heading is painted at body size. Measured on a live page: h1 23px → 16px the moment the
+ * property resolved to nothing, back to 23px when it returned.
+ *
+ * The fallback cannot change a page that defines the property (the definition wins), and
+ * where the definition is missing it keeps the design's own size instead of collapsing.
+ * @param {string} css - generated declarations.
+ * @returns {string} the same declarations, with the reference made safe.
+ */
+function hardenDeltaRefs(css) {
+  if (typeof css !== "string" || css === "") return css;
+  return css.split("var(--dsh-content-font-delta)").join("var(--dsh-content-font-delta, 0px)");
 }
 
 /**
@@ -3760,7 +3978,7 @@ function scaleCodeTokens(baseTokens, scale, lineOffset) {
  *   correct everywhere and costs an attribute scan per element per rule.
  * @returns {string} declarations for one `<style>` element ("" when dormant).
  */
-function buildFontCss(config, baseTokens, hints) {
+function buildFontCss(config, baseTokens, hints, variable) {
   var tokens = baseTokens === undefined || baseTokens === null ? FALLBACK_TOKENS : baseTokens;
   var sets = resolveAxes(config);
   // The rendering preference is NOT an axis: it must paint even when every
@@ -3768,16 +3986,16 @@ function buildFontCss(config, baseTokens, hints) {
   // use case with everything else untouched.
   var smoothing = smoothingRule(config !== null && typeof config === "object" ? config[SMOOTHING_FIELD] : "");
   if (isDormant(sets.light) && isDormant(sets.dark)) return smoothing;
-  var light = buildAxisCss(sets.light, tokens, false, hints);
+  var light = buildAxisCss(sets.light, tokens, false, hints, variable);
   if (sameValueSet(sets.light, sets.dark)) {
-    return smoothing === "" ? light : light === "" ? smoothing : light + "\n" + smoothing;
+    return hardenDeltaRefs(smoothing === "" ? light : light === "" ? smoothing : light + "\n" + smoothing);
   }
-  var dark = buildAxisCss(sets.dark, tokens, true, hints);
+  var dark = buildAxisCss(sets.dark, tokens, true, hints, variable);
   var parts = [];
   if (light !== "") parts.push(light);
   if (dark !== "") parts.push(dark);
   if (smoothing !== "") parts.push(smoothing);
-  return parts.join("\n");
+  return hardenDeltaRefs(parts.join("\n"));
 }
 
 /**
@@ -4299,6 +4517,19 @@ var shared = {
   WEIGHT_DELTA_FLOOR: WEIGHT_DELTA_FLOOR,
   WEIGHT_DELTA_CEIL: WEIGHT_DELTA_CEIL,
   WEIGHT_MIN_POSITIONS: WEIGHT_MIN_POSITIONS,
+  VARIABLE_ALIAS_PREFIX: VARIABLE_ALIAS_PREFIX,
+  CONTINUITY_WEIGHTS: CONTINUITY_WEIGHTS,
+  isRootScopeSelector: isRootScopeSelector,
+  hardenDeltaRefs: hardenDeltaRefs,
+  CONTINUOUS_CANDIDATES: CONTINUOUS_CANDIDATES,
+  distinctCount: distinctCount,
+  respondsFinerThan: respondsFinerThan,
+  variableAliasFor: variableAliasFor,
+  variableFaceRule: variableFaceRule,
+  buildVariableFaces: buildVariableFaces,
+  withVariableFaces: withVariableFaces,
+  isContinuousResponse: isContinuousResponse,
+  continuousWeightProfile: continuousWeightProfile,
   WEIGHT_LADDER_TOP: WEIGHT_LADDER_TOP,
   WEIGHT_LADDER_STRONG: WEIGHT_LADDER_STRONG,
   WEIGHT_DELTA_UP_LIMIT: WEIGHT_DELTA_UP_LIMIT,
@@ -4640,13 +4871,13 @@ var DICTS = {
 
     "weight.uiLabel": "Interface font-weight offset",
     "weight.uiHint":
-      "Adds to the weight of the whole interface (sidebars, settings, buttons, headings): a positive value is bolder, a negative one lighter. The conversation keeps its own. The slider is divided into the weights the current font can actually render, so the readout counts STEPS (0 = leave DSH alone); every notch swaps in a different face for body text and headings alike, and another font offers a different number of steps. The step is measured for the current font, and its smallest step is the one that looks weakest.",
+      "Adds to the weight of the whole interface (sidebars, settings, buttons, headings): a positive value is bolder, a negative one lighter. The conversation keeps its own. The slider is divided into the weights the current font can actually render, so the readout counts STEPS (0 = leave DSH alone); every notch makes body text and headings a little bolder or lighter, and another font offers a different number of steps. The step is measured for the current font, and its smallest step is the one that looks weakest.",
     "weight.dialogLabel": "Conversation font-weight offset",
     "weight.dialogHint":
-      "Adds to the weight of each conversation element, so headings stay bolder than body text and bold text stays bold. Unset keeps DSH's own weights. The slider is divided into the weights the current font can actually render, so the readout counts STEPS (0 = leave DSH alone); every notch swaps in a different face for body text and headings alike, and another font offers a different number of steps. The step is measured for the current font, and its smallest step is the one that looks weakest.",
+      "Adds to the weight of each conversation element, so headings stay bolder than body text and bold text stays bold. Unset keeps DSH's own weights. The slider is divided into the weights the current font can actually render, so the readout counts STEPS (0 = leave DSH alone); every notch makes body text and headings a little bolder or lighter, and another font offers a different number of steps. The step is measured for the current font, and its smallest step is the one that looks weakest.",
     "weight.codeLabel": "Code font-weight offset",
     "weight.codeHint":
-      "Adds to the weight of each code surface (code blocks, inline code, terminal output); 0 or unset keeps DSH's own weight. The slider is divided into the weights the current font can actually render, so the readout counts STEPS (0 = leave DSH alone); every notch swaps in a different face for body text and headings alike, and another font offers a different number of steps. The step is measured for the current font, and its smallest step is the one that looks weakest.",
+      "Adds to the weight of each code surface (code blocks, inline code, terminal output); 0 or unset keeps DSH's own weight. The slider is divided into the weights the current font can actually render, so the readout counts STEPS (0 = leave DSH alone); every notch makes body text and headings a little bolder or lighter, and another font offers a different number of steps. The step is measured for the current font, and its smallest step is the one that looks weakest.",
 
     "line.dialogLabel": "Conversation line height",
     "line.dialogHint":
@@ -4802,13 +5033,13 @@ var DICTS = {
 
     "weight.uiLabel": "界面字重偏移",
     "weight.uiHint":
-      "在整个界面自身的字重上叠加（侧栏、设置、按钮、标题）：正数更粗、负数更细；对话 Markdown 不受影响。滑块按当前字体实际能渲染的粗细分档，读数是档数（0 = 保持 DSH 原样）：每挪一格，正文与标题都会换一张字形；换个字体，档数也会跟着变。档距按当前字体实测，其中幅度最小的一档看起来最弱。",
+      "在整个界面自身的字重上叠加（侧栏、设置、按钮、标题）：正数更粗、负数更细；对话 Markdown 不受影响。滑块按当前字体实际能渲染的粗细分档，读数是档数（0 = 保持 DSH 原样）：每挪一格，正文与标题都会变粗或变细；换个字体，档数也会跟着变。档距按当前字体实测，其中幅度最小的一档看起来最弱。",
     "weight.dialogLabel": "对话字重偏移",
     "weight.dialogHint":
-      "在每个元素自身的字重上叠加，所以标题依旧比正文粗、加粗文字依旧加粗；未设置时保持 DSH 原本的粗细。滑块按当前字体实际能渲染的粗细分档，读数是档数（0 = 保持 DSH 原样）：每挪一格，正文与标题都会换一张字形；换个字体，档数也会跟着变。档距按当前字体实测，其中幅度最小的一档看起来最弱。",
+      "在每个元素自身的字重上叠加，所以标题依旧比正文粗、加粗文字依旧加粗；未设置时保持 DSH 原本的粗细。滑块按当前字体实际能渲染的粗细分档，读数是档数（0 = 保持 DSH 原样）：每挪一格，正文与标题都会变粗或变细；换个字体，档数也会跟着变。档距按当前字体实测，其中幅度最小的一档看起来最弱。",
     "weight.codeLabel": "代码字重偏移",
     "weight.codeHint":
-      "在每个代码面自身的字重上叠加（代码块、行内代码、终端输出）；0 或未设置表示保持 DSH 原样。滑块按当前字体实际能渲染的粗细分档，读数是档数（0 = 保持 DSH 原样）：每挪一格，正文与标题都会换一张字形；换个字体，档数也会跟着变。档距按当前字体实测，其中幅度最小的一档看起来最弱。",
+      "在每个代码面自身的字重上叠加（代码块、行内代码、终端输出）；0 或未设置表示保持 DSH 原样。滑块按当前字体实际能渲染的粗细分档，读数是档数（0 = 保持 DSH 原样）：每挪一格，正文与标题都会变粗或变细；换个字体，档数也会跟着变。档距按当前字体实测，其中幅度最小的一档看起来最弱。",
 
     "line.dialogLabel": "对话行高",
     "line.dialogHint": "把对话行高整体缩放为 {ratio}；100% 表示保持 DSH 原样。",
@@ -5223,6 +5454,24 @@ function isOwnSheet(sheet) {
   }
 }
 
+/**
+ * Whether a style rule declares its custom properties for the WHOLE page.
+ *
+ * The design tokens live on `:root`, `html` or `body`. A rule scoped to a class
+ * declares a LOCAL value — another plugin's module stylesheet may reuse one of the
+ * token names for its own compact panel, and reading that as the base hands the
+ * conversation a size that panel chose for itself.
+ * @param {CSSStyleRule} rule - any rule from a document stylesheet.
+ * @returns {boolean} true when every selector in the rule is a root scope.
+ */
+function isRootScopedRule(rule) {
+  try {
+    return shared.isRootScopeSelector(rule.selectorText);
+  } catch (error) {
+    return false;
+  }
+}
+
 /**
  * Snapshot the typography tokens the size offsets scale.
  *
@@ -5238,6 +5487,13 @@ function isOwnSheet(sheet) {
  * collected too: they are what the shipped stylesheets actually consume, and
  * the line-height axes rebuild their inline heights.
  *
+ * Declarations come in two ranks, because a token name is not owned by the design
+ * system alone: `dsh-better-sidebar` redefines `--dsw-font-markdown-h1` as a compact
+ * `600 13px/18px` on its own panel class, and reading that as the base is how every
+ * conversation heading shrank once the line-height axis rebuilt those shorthands. A
+ * ROOT-scoped declaration is the page's value; a locally scoped one only fills a gap
+ * (a host line that declares its tokens nowhere else still gets them).
+ *
  * @returns {Record<string, string>} token name to its untouched value.
  */
 function readBaseTokens() {
@@ -5252,6 +5508,11 @@ function readBaseTokens() {
 
   try {
     var sheets = document.styleSheets;
+    // A local (class-scoped) declaration is kept APART and only fills gaps: another
+    // plugin may reuse a token name for its own panel, so it must never override the
+    // page's own value — but a host line that declares its tokens nowhere else still
+    // needs them. Root-scoped declarations always win.
+    var local = {};
     for (var sheetIndex = 0; sheetIndex < sheets.length; sheetIndex += 1) {
       if (isOwnSheet(sheets[sheetIndex])) continue;
       var rules = null;
@@ -5262,16 +5523,24 @@ function readBaseTokens() {
       }
       if (!rules) continue;
       for (var ruleIndex = 0; ruleIndex < rules.length; ruleIndex += 1) {
-        var style = rules[ruleIndex].style;
+        var rule = rules[ruleIndex];
+        var style = rule.style;
         if (!style) continue;
+        var rootScoped = isRootScopedRule(rule);
         for (var propertyIndex = 0; propertyIndex < style.length; propertyIndex += 1) {
           var property = style[propertyIndex];
           if (property.slice(0, 2) !== "--" || !isScaledToken(property)) continue;
           var declared = style.getPropertyValue(property).trim();
-          if (declared !== "") out[property] = declared;
+          if (declared === "") continue;
+          if (rootScoped) out[property] = declared;
+          else local[property] = declared;
         }
       }
     }
+    for (name in local) {
+      if (!Object.prototype.hasOwnProperty.call(local, name)) continue;
+      if (!Object.prototype.hasOwnProperty.call(out, name)) out[name] = local[name];
+    }
   } catch (error) {
     // Keep what the earlier sources produced.
   }
@@ -5345,7 +5614,11 @@ function createStylesheet(tokens) {
   var lastCss = null;
   return function apply(config) {
     if (typeof document === "undefined") return;
-    var css = buildFontCss(config, tokens(), harvestScope());
+    // Continuous families (FT-060) bring their own faces: the aliases are declared
+    // here, and `buildFontCss` leads the matching stacks with them.
+    var faces = shared.buildVariableFaces(variableFamilies);
+    var body = buildFontCss(config, tokens(), harvestScope(), variableFamilies);
+    var css = faces === "" ? body : faces + "\n" + body;
     if (css === lastCss && tag !== null && tag.isConnected) return;
     lastCss = css;
     if (tag === null || !tag.isConnected) {
@@ -5748,6 +6021,21 @@ var context = weightProbeCanvas.getContext("2d", { willReadFrequently: true });
   return ink + "/" + advance;
 }
 
+/**
+ * The ink share of a weight signature, as a number.
+ *
+ * `sampleWeightSignature` answers "<ink>/<advance>": the advance is the laid-out
+ * width, which a monospace family holds constant, so ink is the signal that still
+ * moves for those. Unreadable signatures answer 0, which simply never counts as a
+ * change.
+ * @param {string} signature - a signature from `sampleWeightSignature`.
+ * @returns {number} the summed alpha, or 0.
+ */
+function inkOfSignature(signature) {
+  var ink = Number(String(signature).split("/")[0]);
+  return isFinite(ink) ? ink : 0;
+}
+
 /**
  * The slider shape to use for one family: its range and its notch.
  *
@@ -5764,18 +6052,40 @@ var context = weightProbeCanvas.getContext("2d", { willReadFrequently: true });
  */
 function weightProfileFor(stack, top) {
   var base = typeof top === "number" ? top : shared.WEIGHT_LADDER_TOP;
-  var key = String(stack) + "\u0000" + base;
+  var resolved = String(stack) === "" ? liveFamily() : String(stack);
+  // `hasOwnProperty` rather than a truthiness test: the alias map is keyed by family
+  // name, and a family called "constructor" must not read as promoted.
+  var promoted = Object.prototype.hasOwnProperty.call(variableFamilies, primaryFamilyOf(resolved));
+  var alias = promoted ? variableFamilies[primaryFamilyOf(resolved)] : "";
+  // The promotion state is part of the key. The warm-up measures a family BEFORE the
+  // probe has finished (the probe awaits a font load), so without it the stepped shape
+  // measured first would be served from the cache forever after the family was
+  // promoted — the card then keeps offering the coarse notches the mode replaced.
+  var key = String(stack) + "\u0000" + base + "\u0000" + (promoted ? "continuous" : "stepped");
   if (Object.prototype.hasOwnProperty.call(weightProfileCache, key)) {
     return weightProfileCache[key];
   }
-  var profile = { min: WEIGHT_DELTA_MIN, max: WEIGHT_DELTA_MAX, step: 1 };
+  var profile = promoted
+    ? shared.continuousWeightProfile()
+    : { min: WEIGHT_DELTA_MIN, max: WEIGHT_DELTA_MAX, step: 1 };
   try {
-    var resolved = String(stack) === "" ? liveFamily() : String(stack);
-    profile = weightProfileFrom(function (weight) {
-      return sampleWeightSignature(resolved, weight);
-    }, { top: base });
+    // 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) {
-    profile = { min: WEIGHT_DELTA_MIN, max: WEIGHT_DELTA_MAX, step: 1 };
+    profile = promoted
+      ? shared.continuousWeightProfile()
+      : { min: WEIGHT_DELTA_MIN, max: WEIGHT_DELTA_MAX, step: 1 };
   }
   weightProfileCache[key] = profile;
   return profile;
@@ -5837,14 +6147,17 @@ var scheduleWeightWarm = function (editing) {
   warmSignature = signature;
   var jobs = [
     function () {
+      probeContinuity(stacks.dialog);
       weightProfileFor(stacks.dialog, shared.WEIGHT_LADDER_STRONG);
       probeLog("weight-warm", { axis: "dialog", stack: stacks.dialog });
     },
     function () {
+      probeContinuity(stacks.ui);
       weightProfileFor(stacks.ui, shared.WEIGHT_LADDER_STRONG);
       probeLog("weight-warm", { axis: "ui", stack: stacks.ui });
     },
     function () {
+      probeContinuity(stacks.code);
       weightProfileFor(stacks.code, shared.WEIGHT_BASE);
       probeLog("weight-warm", { axis: "code", stack: stacks.code });
     },
@@ -5858,6 +6171,201 @@ var scheduleWeightWarm = function (editing) {
   deferWeightWarm(runNext);
 };
 
+/**
+ * Families measured as continuous, family → alias (see FT-060).
+ *
+ * Filled by `probeContinuity` once a family has proven, in THIS page's own
+ * rendering, that it moves in small steps through its variable axis. A family
+ * that is not in here keeps the measured notch shape it always had.
+ */
+var variableFamilies = {};
+var continuityProbed = {};
+
+/**
+ * What to re-render when a family is promoted.
+ *
+ * The promotion lands a second or so after load, while the floating panel may already
+ * be on screen with its weight row built from the stepped shape. Rebuilding the
+ * stylesheet is not enough — the row caches the shape it was rendered with, so the
+ * panel would keep offering the coarse notches until something else happened to
+ * redraw it. Each mounted panel pushes its own render here and takes it back on
+ * destroy.
+ */
+var promotionListeners = [];
+
+/** Redraw whatever is showing a weight shape that the promotion just changed. */
+function notifyPromoted() {
+  var pending = promotionListeners.slice();
+  for (var index = 0; index < pending.length; index += 1) {
+    try {
+      pending[index]();
+    } catch (error) {
+      // A listener must never break the probe.
+    }
+  }
+}
+
+/**
+ * A stamp for the build the page is running.
+ *
+ * The client script is cached, and "I refreshed" has been wrong before: this is what
+ * a live page reports about itself (the panel host carries it as `data-dfp-build`).
+ */
+var CLIENT_BUILD = "2026-10-12-3";
+
+/** The families this page promoted to continuous weight, in map order. */
+function continuousNames() {
+  return Object.keys(variableFamilies);
+}
+
+/**
+ * Publish the promoted families on the panel host, when one is on screen.
+ *
+ * Promotion happens AFTER the first render (the probe awaits a font load), so the
+ * attribute set during render is re-stamped here: the host element is then the one
+ * place a reader — or a support session — can look without opening the console.
+ */
+function announceContinuous() {
+  if (typeof document === "undefined") return;
+  try {
+    var nodes = document.querySelectorAll("[data-dfp-build]");
+    var names = continuousNames().join(", ");
+    for (var index = 0; index < nodes.length; index += 1) {
+      if (names === "") nodes[index].removeAttribute("data-dfp-continuous");
+      else nodes[index].setAttribute("data-dfp-continuous", names);
+    }
+  } catch (error) {
+    // Diagnostics only: a host without attributes costs nothing.
+  }
+}
+
+/**
+ * The first family a stack names that is a REAL family, or "" when there is none.
+ *
+ * Our own alias families are skipped: once a family is promoted, any stack read back
+ * from the page (`liveFamily()`) leads with the alias, and treating that as the
+ * family name would miss the promotion map and hand back the stepped shape — which is
+ * how the floating panel kept offering the coarse notches after the card moved on.
+ * @param {string} stack - a formatted font-family value.
+ * @returns {string} the family the stack really draws with.
+ */
+function primaryFamilyOf(stack) {
+  var names = parseStack(stack);
+  for (var index = 0; index < names.length; index += 1) {
+    if (names[index].indexOf(shared.VARIABLE_ALIAS_PREFIX) !== 0) return names[index];
+  }
+  return "";
+}
+
+/**
+ * Ask the page whether a family is continuous under weight, once per family.
+ *
+ * The probe does what the page does: it installs the alias face for the family
+ * (`local()` plus a weight range) and waits for the browser to load it. It then
+ * asks TWO ways, both through that alias:
+ *
+ *  * the laid-out width, in the real DOM — what a reader's eye follows in prose;
+ *  * the canvas ink, which is the only signal a monospace family ever moves on,
+ *    since its advance is the same at every weight.
+ *
+ * A family that answers continuously on either signal is promoted to
+ * `variableFamilies`; the stylesheet is then rebuilt so the alias leads its
+ * stacks. Anything that cannot be measured (no font loading API, a rejected load)
+ * leaves the family as it was.
+ * @param {string} stack - the axis's formatted font-family value.
+ */
+function probeContinuity(stack) {
+  var family = primaryFamilyOf(stack);
+  if (family === "" || continuityProbed[family] === true) return;
+  continuityProbed[family] = true;
+  if (typeof document === "undefined" || !document.fonts || typeof document.fonts.load !== "function") return;
+  var alias = shared.variableAliasFor(family);
+  var style = document.createElement("style");
+  style.setAttribute("data-dfp-continuity", alias);
+  style.textContent = shared.variableFaceRule(family, alias);
+  document.head.appendChild(style);
+  var host = document.createElement("span");
+  host.style.cssText =
+    "position:fixed;left:-10000px;top:0;white-space:nowrap;font-size:64px;font-family:\"" + alias + "\"";
+  host.textContent = WEIGHT_SAMPLE_TEXT;
+  document.body.appendChild(host);
+  var keepFace = false;
+  var finish = function () {
+    host.remove();
+    // A promoted family keeps its face: the stylesheet will declare the same alias,
+    // and the weight profile is measured THROUGH it after promotion, so removing the
+    // rule here would leave that measurement drawing with the fallback.
+    if (!keepFace) style.remove();
+  };
+  // Two signals, because neither covers every family on its own: the DOM width
+  // moves for a proportional font, while a monospace font never changes width and
+  // can only be seen in the canvas ink. The ink is also read through the FAMILY
+  // itself, and the two responses are compared: a family that snaps to named
+  // instances answers identically either way, while a variable family moves through
+  // its alias at weights where its own path already stopped.
+  //
+  // All values equal means the face has not taken effect yet (the page is still
+  // drawing with its fallback), not that the family is stepped: a stepped family
+  // still changes between its faces. Wait a beat and measure again, a few times at
+  // most, so a slow face is not mistaken for a static one.
+  var attempts = 0;
+  var measure = function () {
+    attempts += 1;
+    // `!important` on purpose: the page's own weight rules are `!important`, and a
+    // plain inline weight loses to them, which measured every width as one value.
+    var widths = shared.CONTINUITY_WEIGHTS.map(function (weight) {
+      host.style.setProperty("font-weight", String(weight), "important");
+      return host.getBoundingClientRect().width;
+    });
+    var inks = shared.CONTINUITY_WEIGHTS.map(function (weight) {
+      return inkOfSignature(sampleWeightSignature('"' + alias + '"', weight));
+    });
+    var plainInks = shared.CONTINUITY_WEIGHTS.map(function (weight) {
+      return inkOfSignature(sampleWeightSignature('"' + family + '"', weight));
+    });
+    var unchanged = function (list) {
+      return list.every(function (value) {
+        return value === list[0];
+      });
+    };
+    if (unchanged(widths) && unchanged(inks) && attempts < 8) {
+      globalThis.setTimeout(measure, 80);
+      return;
+    }
+    // The alias must answer more finely than the family itself. A family that snaps
+    // to named instances cannot: both responses hold the same values.
+    var finer = shared.respondsFinerThan(inks, plainInks);
+    var continuous = finer || shared.isContinuousResponse(widths);
+    keepFace = continuous;
+    finish();
+    probeLog("continuity", {
+      family: family,
+      continuous: continuous,
+      attempts: attempts,
+      byWidth: shared.isContinuousResponse(widths),
+      aliasInk: shared.distinctCount(inks),
+      plainInk: shared.distinctCount(plainInks),
+      widths: widths.map(function (width) {
+        return Math.round(width * 100) / 100;
+      }),
+    });
+    if (!continuous) return;
+    variableFamilies[family] = alias;
+    announceContinuous();
+    notifyPromoted();
+    if (typeof repaint === "function") repaint();
+  };
+  document.fonts.load('400 64px "' + alias + '"').then(
+    function () {
+      measure();
+    },
+    function () {
+      finish();
+      probeLog("continuity", { family: family, continuous: false, error: "load" });
+    }
+  );
+}
+
 /**
  * The family the page actually renders with, as a `font-family` value.
  * @returns {string} the computed family, or "" when unreadable.
@@ -8445,12 +8953,17 @@ function FontCard(props) {
   // nothing else — the weight, size and line height all come from the
   // conversation section.
   var previewUiStyle = {};
-  if (uiStack !== "") previewUiStyle.fontFamily = uiStack;
+  if (uiStack !== "") previewUiStyle.fontFamily = shared.withVariableFaces(uiStack, variableFamilies);
   var previewDialogStyle = {};
   // Independent and unset: the conversation keeps DSH's own family, so the
   // preview shows the theme's default rather than the interface stack the page
   // rule would otherwise paint into this box.
-  if (dialogStack !== "") previewDialogStyle.fontFamily = dialogStack;
+  //
+  // The alias leads these stacks exactly as it leads the real surfaces: without it
+  // the preview would draw through the system family, where the fine notches snap to
+  // the same named instance — so a notch that visibly moves the conversation would
+  // do nothing here.
+  if (dialogStack !== "") previewDialogStyle.fontFamily = shared.withVariableFaces(dialogStack, variableFamilies);
   previewDialogStyle.fontSize = 13 + editing[SIZE_DIALOG_FIELD] + "px";
   // The axis is a percentage OF DSH's own line height, so the preview multiplies the
   // measured base by the same percentage — and does it at every notch including 100,
@@ -8471,7 +8984,7 @@ function FontCard(props) {
   }
   var previewCodeStyle = {};
   if (editing[MONO_FIELD] !== "") {
-    previewCodeStyle.fontFamily = formatStack(parseStack(editing[MONO_FIELD]));
+    previewCodeStyle.fontFamily = shared.withVariableFaces(formatStack(parseStack(editing[MONO_FIELD])), variableFamilies);
   }
   previewCodeStyle.fontSize = 13 + editing[CODE_SIZE_FIELD] + "px";
   if (editing[CODE_LINE_HEIGHT_FIELD] !== 0) {
@@ -10818,8 +11331,13 @@ function mountFloatPanel(scope, t, hostCtx) {
     host.textContent = "";
     // One line in the console answers "which build is live": with a linked plugin
     // and a cached client script, "I refreshed" is not evidence on its own.
-    host.setAttribute("data-dfp-build", "2026-10-01-2");
-    var dot = el("button", "dfp-dot");
+    host.setAttribute("data-dfp-build", CLIENT_BUILD);
+    // And which families this build promoted to continuous weight, so a report of
+    // "the slider still has four notches" can be answered without a console session:
+    // an empty attribute means the probe has not (yet) promoted the reader's family,
+    // a missing one means the page is running a build from before the mode existed.
+    if (continuousNames().length > 0) host.setAttribute("data-dfp-continuous", continuousNames().join(", "));
+    else host.removeAttribute("data-dfp-continuous");    var dot = el("button", "dfp-dot");
     dot.type = "button";
     dot.setAttribute("aria-label", t("panel.dot"));
     dot.title = t("panel.dot");
@@ -11009,7 +11527,13 @@ function mountFloatPanel(scope, t, hostCtx) {
 
     // The dialog weight in the family's own steps, like the card's control:
     // the document keeps the offset, the readout counts steps.
-    var dialogStack = formatStack(parseStack(config[STACK_DIALOG_FIELD]));
+    //
+    // The stack comes from the SAME helper the card and the warm-up use. Resolving it
+    // here instead (the configured field alone) meant an unset stack fell through to
+    // the page's computed family, which carries our alias once a family is promoted —
+    // so the panel missed the promotion and kept showing the coarse notches while the
+    // card showed the fine ones.
+    var dialogStack = weightAxisStacks(config).dialog;
     var profile = { min: WEIGHT_DELTA_MIN, max: WEIGHT_DELTA_MAX, step: 1 };
     try {
       profile = weightProfileFor(dialogStack, shared.WEIGHT_LADDER_STRONG);
@@ -11021,6 +11545,13 @@ function mountFloatPanel(scope, t, hostCtx) {
       { min: Math.min(profile.min, storedWeight), max: Math.max(profile.max, storedWeight), step: profile.step },
       storedWeight
     );
+    probeLog("panel-weight", {
+      stack: dialogStack,
+      profile: profile,
+      stored: storedWeight,
+      shape: shape,
+      promoted: continuousNames(),
+    });
     (function () {
       var row = el("div", "dfp-floatRow");
       var label = el("div", "dfp-floatLabel");
@@ -11233,8 +11764,14 @@ function mountFloatPanel(scope, t, hostCtx) {
     // A document without events still gets the interval.
   }
 
+  // A promotion changes the weight row's shape; the panel redraws itself when one
+  // lands, and stops listening when it goes away.
+  promotionListeners.push(render);
+
   return {
     destroy: function () {
+      var at = promotionListeners.indexOf(render);
+      if (at >= 0) promotionListeners.splice(at, 1);
       if (statusTimer !== null) globalThis.clearTimeout(statusTimer);
       if (closeTimer !== null) globalThis.clearTimeout(closeTimer);
       if (reflowTimer !== null) globalThis.clearTimeout(reflowTimer);

package/lib/shared.cjs

@@ -2329,6 +2329,27 @@ function rebuildShorthand(parts) {
  * token classification
  * ------------------------------------------------------------------ */
 
+/**
+ * Whether a CSS selector declares something for the WHOLE page.
+ *
+ * The typography tokens live on `:root`, `html` or `body`. A selector scoped to a class
+ * or an attribute declares a LOCAL value: another plugin's module stylesheet may reuse a
+ * token name for its own compact panel (measured: `dsh-better-sidebar` sets
+ * `--dsw-font-markdown-h1` to `600 13px/18px` on `.…_taskMarkdown`), and reading that as
+ * the base hands the conversation a size that panel picked for itself.
+ * @param {string} selector - a rule's selector text.
+ * @returns {boolean} true when every selector in the list is a root scope.
+ */
+function isRootScopeSelector(selector) {
+  if (typeof selector !== "string" || selector.trim() === "") return false;
+  var parts = selector.split(",");
+  for (var index = 0; index < parts.length; index += 1) {
+    var part = parts[index].trim().toLowerCase();
+    if (part !== ":root" && part !== "html" && part !== "body" && part !== "*") return false;
+  }
+  return true;
+}
+
 /**
  * Match DSH's typography PART tokens: the design system's sizes plus the
  * content size the theme plugin writes on `body` (whose secondary variant
@@ -3169,6 +3190,180 @@ function weightStepRange(profile, value) {
   return { min: min, max: max, unit: unit, value: count };
 }
 
+/* ------------------------------------------------------------------ *
+ * continuous weight (FT-060)
+ * ------------------------------------------------------------------ */
+
+/** Prefix of the alias family a continuous family is drawn through. */
+var VARIABLE_ALIAS_PREFIX = "dfp-vf-";
+
+/**
+ * The weights the continuity probe lays out. Dense on purpose: a variable font
+ * that moves in small steps shows a width change at every one of them, while a
+ * family that snaps to named instances repeats its width across each stretch.
+ */
+var CONTINUITY_WEIGHTS = [400, 420, 440, 460, 480, 500, 550, 600, 650, 700, 750, 800, 900];
+
+/**
+ * The share of adjacent probe pairs that must differ before a family's laid-out
+ * WIDTH counts as continuous. Measured: a variable family drawn through its alias
+ * changes width at every sampled weight (share 1.0), while a family snapping to
+ * named instances repeats its width across each stretch (share 0.25–0.42).
+ */
+var CONTINUOUS_MIN_SHARE = 0.9;
+
+/**
+ * The notches offered for a continuous family, finest first.
+ *
+ * The shape is still measured (the alias is drawn on the same weight grid as any
+ * other family), but the candidates are fine: a continuous axis can answer at every
+ * one of them, which is the whole point of the mode. `weightProfileFrom` walks this
+ * list from the END, so the finest candidate that still yields enough visible
+ * positions wins.
+ */
+var CONTINUOUS_CANDIDATES = [10, 20, 25];
+
+/**
+ * The nominal continuous slider, used when the measured shape cannot be taken
+ * (no canvas, a refused probe). One notch is 20 weight units; the range is the
+ * widest offset the ceiling allows either way.
+ */
+var CONTINUOUS_STEP = 20;
+var CONTINUOUS_RANGE = 200;
+
+/**
+ * How many different values a list of measurements holds.
+ * @param {number[]} values - the measurements.
+ * @returns {number} the count of distinct values.
+ */
+function distinctCount(values) {
+  if (!Array.isArray(values)) return 0;
+  var seen = [];
+  for (var index = 0; index < values.length; index += 1) {
+    if (seen.indexOf(values[index]) < 0) seen.push(values[index]);
+  }
+  return seen.length;
+}
+
+/**
+ * Does the same family answer more finely through its alias than through itself?
+ *
+ * This is the discriminator the continuity probe trusts, and it needs no threshold:
+ * a family that snaps to named instances renders IDENTICALLY either way, so both
+ * responses hold the same number of distinct values; a variable family drawn through
+ * the alias moves at weights where the system path already stopped. Comparing the
+ * family against ITSELF also keeps the answer honest for a narrow axis, where a
+ * share-of-neighbours rule would read saturation as "static".
+ * @param {number[]} throughAlias - measurements taken through the alias face.
+ * @param {number[]} plain - the same measurements taken through the family itself.
+ * @returns {boolean} true when the alias resolves finer detail.
+ */
+function respondsFinerThan(throughAlias, plain) {
+  if (!Array.isArray(throughAlias) || !Array.isArray(plain)) return false;
+  var fine = distinctCount(throughAlias);
+  return fine >= 3 && fine > distinctCount(plain);
+}
+
+
+/**
+ * The alias family name for one family. A hash, not the family itself, so the
+ * name is a plain identifier whatever the family is called.
+ * @param {string} family - a family name.
+ * @returns {string} the alias, stable across sessions.
+ */
+function variableAliasFor(family) {
+  var text = sanitizeFamily(family);
+  var hash = 0;
+  for (var index = 0; index < text.length; index += 1) {
+    hash = (hash * 31 + text.charCodeAt(index)) >>> 0;
+  }
+  return VARIABLE_ALIAS_PREFIX + hash.toString(36);
+}
+
+/**
+ * The `@font-face` rule that draws one family through its own variable axis.
+ *
+ * `local()` points the face at the installed family, and the weight RANGE is the
+ * part that matters: it tells the engine the family is continuous, so `font-weight`
+ * picks a point on the axis instead of the nearest named instance. (Without the
+ * range the same family snaps; `font-variation-settings` does not help a system
+ * family at all — measured, see FT-060.)
+ * @param {string} family - the installed family name.
+ * @param {string} alias - the alias from `variableAliasFor`.
+ * @returns {string} one CSS rule.
+ */
+function variableFaceRule(family, alias) {
+  var text = sanitizeFamily(family).replace(/"/g, "");
+  return '@font-face{font-family:"' + alias + '";src:local("' + text + '");font-weight:100 900;}';
+}
+
+/**
+ * Every `@font-face` rule for a map of family → alias.
+ * @param {Record<string, string>} variable - the families that measured continuous.
+ * @returns {string} the rules, one per line; "" when there are none.
+ */
+function buildVariableFaces(variable) {
+  var rules = [];
+  if (variable === null || typeof variable !== "object") return "";
+  for (var family in variable) {
+    if (Object.prototype.hasOwnProperty.call(variable, family)) {
+      rules.push(variableFaceRule(family, variable[family]));
+    }
+  }
+  return rules.join("\n");
+}
+
+/**
+ * Put the alias IN FRONT of every continuous family a stack names.
+ *
+ * The family stays in the list after its alias, so a glyph the alias lacks still
+ * falls through to the same face the reader chose, and a stack that names no
+ * continuous family is returned unchanged.
+ * @param {string} stack - a formatted font-family value.
+ * @param {Record<string, string>} variable - family → alias map.
+ * @returns {string} the stack, with aliases prepended where they apply.
+ */
+function withVariableFaces(stack, variable) {
+  if (typeof stack !== "string" || stack === "" || variable === null || typeof variable !== "object") {
+    return stack;
+  }
+  // The stack may already carry its alias — a family read back from the page's own
+  // computed style does, once the mode is on. Prepending it again would stack up a
+  // duplicate on every rebuild.
+  var names = parseStack(stack);
+  var lead = names.length > 0 ? names[0] : "";
+  var prefix = [];
+  for (var family in variable) {
+    if (!Object.prototype.hasOwnProperty.call(variable, family)) continue;
+    if (stack.indexOf(quoteFamily(family)) < 0) continue;
+    if (lead === variable[family]) continue;
+    prefix.push('"' + variable[family] + '"');
+  }
+  return prefix.length === 0 ? stack : prefix.join(", ") + ", " + stack;
+}
+
+/**
+ * Did a family respond continuously to weight in the probe?
+ * @param {number[]} widths - laid-out widths, in `CONTINUITY_WEIGHTS` order.
+ * @returns {boolean} true when enough neighbours differ.
+ */
+function isContinuousResponse(widths) {
+  if (!Array.isArray(widths) || widths.length < 3) return false;
+  var changes = 0;
+  for (var index = 1; index < widths.length; index += 1) {
+    if (widths[index] !== widths[index - 1]) changes += 1;
+  }
+  return changes / (widths.length - 1) >= CONTINUOUS_MIN_SHARE;
+}
+
+/**
+ * The slider shape for a continuous family: the finest notch, centred on 0.
+ * @returns {{min: number, max: number, step: number}} the profile, in weight units.
+ */
+function continuousWeightProfile() {
+  return { min: -CONTINUOUS_RANGE, max: CONTINUOUS_RANGE, step: CONTINUOUS_STEP };
+}
+
 /**
  * What a slider's local (unconfirmed) value should do when a value arrives from
  * the settings document.
@@ -3256,10 +3451,12 @@ function isDormant(config) {
  * @param {boolean} isDark - prefix every rule with the dark-theme attribute.
  * @returns {string} declarations for one `<style>` element.
  */
-function buildAxisCss(axis, baseTokens, isDark, hints) {
-  var sans = formatStack(parseStack(axis[SANS_FIELD]));
-  var mono = formatStack(parseStack(axis[MONO_FIELD]));
-  var dialog = formatStack(parseStack(axis[STACK_DIALOG_FIELD]));
+function buildAxisCss(axis, baseTokens, isDark, hints, variable) {
+  // A continuous family leads its stack with its alias (see `withVariableFaces`);
+  // with no map, every stack stays exactly as written.
+  var sans = withVariableFaces(formatStack(parseStack(axis[SANS_FIELD])), variable);
+  var mono = withVariableFaces(formatStack(parseStack(axis[MONO_FIELD])), variable);
+  var dialog = withVariableFaces(formatStack(parseStack(axis[STACK_DIALOG_FIELD])), variable);
   // Normalised once: an expanded axis always carries a number, but a caller
   // handing in a raw object may leave the field out, and "absent" has to mean
   // "unset" rather than "write the string undefined". The conversation's value
@@ -3659,7 +3856,28 @@ function buildAxisCss(axis, baseTokens, isDark, hints) {
     if (noBold) declarations.push(bodyRule("font-synthesis-weight:none !important"));
   }
 
-  return declarations.join("\n");
+  return hardenDeltaRefs(declarations.join("\n"));
+}
+
+/**
+ * Give every reference to the content-size delta a fallback value.
+ *
+ * A heading's `font` shorthand is the markdown token, and DSH's own text for it reads
+ * `calc(21px + var(--dsh-content-font-delta))` — a reference with NO fallback. Nothing
+ * outside this plugin defines that property, so any rebuild that emits the reference
+ * without the definition leaves it resolving to nothing, which makes the WHOLE shorthand
+ * invalid at computed-value time: every font longhand falls back to `inherit`, and the
+ * heading is painted at body size. Measured on a live page: h1 23px → 16px the moment the
+ * property resolved to nothing, back to 23px when it returned.
+ *
+ * The fallback cannot change a page that defines the property (the definition wins), and
+ * where the definition is missing it keeps the design's own size instead of collapsing.
+ * @param {string} css - generated declarations.
+ * @returns {string} the same declarations, with the reference made safe.
+ */
+function hardenDeltaRefs(css) {
+  if (typeof css !== "string" || css === "") return css;
+  return css.split("var(--dsh-content-font-delta)").join("var(--dsh-content-font-delta, 0px)");
 }
 
 /**
@@ -3751,7 +3969,7 @@ function scaleCodeTokens(baseTokens, scale, lineOffset) {
  *   correct everywhere and costs an attribute scan per element per rule.
  * @returns {string} declarations for one `<style>` element ("" when dormant).
  */
-function buildFontCss(config, baseTokens, hints) {
+function buildFontCss(config, baseTokens, hints, variable) {
   var tokens = baseTokens === undefined || baseTokens === null ? FALLBACK_TOKENS : baseTokens;
   var sets = resolveAxes(config);
   // The rendering preference is NOT an axis: it must paint even when every
@@ -3759,16 +3977,16 @@ function buildFontCss(config, baseTokens, hints) {
   // use case with everything else untouched.
   var smoothing = smoothingRule(config !== null && typeof config === "object" ? config[SMOOTHING_FIELD] : "");
   if (isDormant(sets.light) && isDormant(sets.dark)) return smoothing;
-  var light = buildAxisCss(sets.light, tokens, false, hints);
+  var light = buildAxisCss(sets.light, tokens, false, hints, variable);
   if (sameValueSet(sets.light, sets.dark)) {
-    return smoothing === "" ? light : light === "" ? smoothing : light + "\n" + smoothing;
+    return hardenDeltaRefs(smoothing === "" ? light : light === "" ? smoothing : light + "\n" + smoothing);
   }
-  var dark = buildAxisCss(sets.dark, tokens, true, hints);
+  var dark = buildAxisCss(sets.dark, tokens, true, hints, variable);
   var parts = [];
   if (light !== "") parts.push(light);
   if (dark !== "") parts.push(dark);
   if (smoothing !== "") parts.push(smoothing);
-  return parts.join("\n");
+  return hardenDeltaRefs(parts.join("\n"));
 }
 
 /**
@@ -4290,6 +4508,19 @@ var shared = {
   WEIGHT_DELTA_FLOOR: WEIGHT_DELTA_FLOOR,
   WEIGHT_DELTA_CEIL: WEIGHT_DELTA_CEIL,
   WEIGHT_MIN_POSITIONS: WEIGHT_MIN_POSITIONS,
+  VARIABLE_ALIAS_PREFIX: VARIABLE_ALIAS_PREFIX,
+  CONTINUITY_WEIGHTS: CONTINUITY_WEIGHTS,
+  isRootScopeSelector: isRootScopeSelector,
+  hardenDeltaRefs: hardenDeltaRefs,
+  CONTINUOUS_CANDIDATES: CONTINUOUS_CANDIDATES,
+  distinctCount: distinctCount,
+  respondsFinerThan: respondsFinerThan,
+  variableAliasFor: variableAliasFor,
+  variableFaceRule: variableFaceRule,
+  buildVariableFaces: buildVariableFaces,
+  withVariableFaces: withVariableFaces,
+  isContinuousResponse: isContinuousResponse,
+  continuousWeightProfile: continuousWeightProfile,
   WEIGHT_LADDER_TOP: WEIGHT_LADDER_TOP,
   WEIGHT_LADDER_STRONG: WEIGHT_LADDER_STRONG,
   WEIGHT_DELTA_UP_LIMIT: WEIGHT_DELTA_UP_LIMIT,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-fonttune",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "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",
   "main": "lib/index.js",
@@ -37,7 +37,9 @@
         "0.1.7-rc.1": "compatible",
         "0.1.7-rc.2": "compatible",
         "0.2.0-rc.1": "compatible",
-        "0.2.0-rc.2": "compatible"
+        "0.2.0-rc.2": "compatible",
+        "0.2.1-alpha.1": "compatible",
+        "0.2.1-alpha.2": "compatible"
       }
     }
   },