dsh-fonttune 0.3.0 → 0.3.1

package/CHANGELOG.en.md

@@ -2,6 +2,16 @@
 
 All notable changes to **dsh-fonttune** are documented here. Chinese version: [CHANGELOG.md](CHANGELOG.md).
 
+## [0.3.1] - 2026-09-28
+
+### Fixed
+- **The upper positions of the weight slider jumped to a lower number**: two of them were read as an absolute weight and converted, so the third step showed as −1 and the fourth rendered exactly like 0. A position now stays where it is put.
+- **With the conversation weight at 0, the conversation still picked up the interface offset**: the two axes shared a range, so 0 carried the interface's offset as well and the 0 and +1 positions looked nearly the same. Each axis now keeps to its own scope, and 0 is DSH's own weight.
+- **The line-height preview in the card was taller at 100% than at the notches above it**: the preview and the conversation did not share a base. They do now, so every notch is taller in the preview as well.
+
+### Changed
+- **The weight slider's positions and step come from the font**: one step is one pair of neighbouring faces, and the range starts where body text and bold text can still swap faces — a family whose body text has more weights gets more positions (the range is no longer held back by the heading layer), and the heading layer stops once it is at its boldest; changing the family measures it again.
+
 ## [0.3.0] - 2026-09-28
 
 ### Fixed

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 **dsh-fonttune** 的重要变更都记录在这里。英文版见 [CHANGELOG.en.md](CHANGELOG.en.md)。
 
+## [0.3.1] - 2026-09-28
+
+### 修复
+- **字重滑块偏上的档位会跳到较小的数值**：此前有两个档位会被换算成别的数值，表现为拖到第三档显示成 −1、第四档与 0 档的粗细看起来完全一样。现在拖到哪一档就停在哪一档。
+- **「对话字重偏移」为 0 时，对话还是会跟着「界面字重偏移」一起变粗**：两个轴的范围互相串了，界面设了偏移时对话的 0 档也带上了那个偏移，于是 0 与 +1 两档看起来几乎一样。现在每个轴只管自己的范围，0 档就是 DSH 原样。
+- **卡片里的行高预览在 100% 时比更高的档位还高**：预览与真实对话用的不是同一个基准。现在两者一致，预览里也是每一档都更高。
+
+### 变更
+- **字重滑块的档位与档距按字体实测**：一档就是字体相邻的两张字形，范围从「正文与加粗文字都还能换到字形」的地方起算——正文字重档位多的字体给更多档位（正文能走的范围不再被标题压小），标题那一层到顶后停住；换字体会重新测量。
+
 ## [0.3.0] - 2026-09-28
 
 ### 修复
@@ -12,7 +22,7 @@
 
 ### 变更
 - **三个字重轴统一，并按档调整**：对话、界面与代码都改成「在每个元素自身粗细上叠加」的偏移，滑块按当前字体**实际能渲染的粗细分档**——读数就是档数（例如 `-2 … +4`，0 表示保持 DSH 原样），字体有几档就有几档，每挪一格都是一次看得见的变化；换字体后档数会重新测量。
-- **旧版本存的绝对字重会自动换算**（400 → 0、450 → +1），不需要重设；文档里保存的仍是通用数值，换字体不会让已有设置失效。
+- **旧版本存的绝对字重会自动换算**（400 → 0、450 → +1），不需要重设；换字体也不会让已有设置失效。
 
 ## [0.2.7] - 2026-09-24
 

package/README.en.md

@@ -9,7 +9,7 @@
 - **Three typography sets** — the conversation (markdown paragraphs, tables, headings) comes first and owns every axis; the interface (settings sheet, sidebars, workspace, headings and buttons) offers **a font and a weight** and follows the conversation by default (switchable); code stays its own axis
 - **Interface / conversation / code fonts** — three independent fallback lists, Latin families first and CJK after; leaving one empty keeps DSH's own stack untouched
 - **Font-size offsets** — the **conversation** takes -3 ~ +6 px on top of DSH's own "conversation font size" (the official value is the base), moving paragraphs, headings and line heights together — and it is applied **once, at the source** (H1/H2/H3 all derive from the same delta, so the hierarchy holds at any offset and no heading comes out smaller than expected); code is its own axis at -3 ~ +6 px. **The interface has no size axis**: verified against DSH, the settings sheet, sidebars and workspace size their text in upstream CSS, and the only official size hook is the conversation one
-- **Font-weight offsets** — the **conversation**, the **interface** and **code** all take the same **relative offset** (-100 ~ +200, unset reads 0 and the readout is signed): the offset is added to each element's **own** weight, so the heading hierarchy DSH ships (h1~h3 700, h4~h6 and bold 600, table head 500, body 400) survives in both directions — headings stay clearly bolder than body text at any setting, and bold text inside a code surface stays bold. The interface offset is one rule over `body` plus an element table, with the whole conversation markdown subtree excluded: measured against computed styles on a live page, it takes every interface text element to the target and moves nothing inside the markdown subtree, so **changing the interface weight never touches the conversation**. The slider **counts steps**: the readout is the step count (for example `-2 -1 0 +1 +2 +3 +4`) and **the font decides how many there are** — the card measures how many distinct weights the chosen family can actually render, then works out the range and the size of one step, so every notch is a visible change and the numbers stay small. What is stored is still a weight offset (older values are converted), so changing the font never breaks a setting; a family with only regular and bold offers three positions in total, and continuous control needs a family with more weights or a variable font
+- **Font-weight offsets** — the **conversation**, the **interface** and **code** all take the same **relative offset** (-100 ~ +200, unset reads 0 and the readout is signed): the offset is added to each element's **own** weight, so the heading hierarchy DSH ships (h1~h3 700, h4~h6 and bold 600, table head 500, body 400) survives in both directions — headings stay clearly bolder than body text at any setting, and bold text inside a code surface stays bold. The interface offset is one rule over `body` plus an element table, with the whole conversation markdown subtree excluded: measured against computed styles on a live page, it takes every interface text element to the target and moves nothing inside the markdown subtree, so **changing the interface weight never touches the conversation**. The slider **counts steps**: the readout is the step count (for example `-1 0 +1`) and **the font decides how many there are** — the card measures how many distinct weights the chosen family can render for body text and for bold text, so one step is one pair of neighbouring faces and the range ends where those two stop swapping faces (the heading layer stops once it is at its boldest) — every notch is a visible change and the numbers stay small. What is stored is still a weight offset (older values are converted), so changing the font never breaks a setting; a family with only regular and bold offers three positions in total, and continuous control needs a family with more weights or a variable font
 - **Line heights** — the **conversation** uses a ratio (100% ~ 160%), code an additive offset (-4 ~ +8 px); the interface has no line-height axis, for the same reason as size
 - **Code ligatures** — a three-mode switch (default / on / off; browsers enable them by default, turning them off restores `=>` and `!=` as plain characters), plus an advanced `font-feature-settings` value field
 - **Refuse synthetic styles** (off by default, i.e. synthesis is allowed) — turning it on stops the browser from faking italic and bold for CJK faces, which have neither, so marked text stays upright; left off, the browser synthesises by its own rules, which at least gives a visible "bold" step for a family with no bold face
@@ -26,7 +26,8 @@
 
 | Plugin version | Supported DSH versions |
 | --- | --- |
-| **0.3.0** (latest) | 0.1.5-rc.3, 0.1.7-alpha.1 / alpha.2, 0.1.7-rc.1 / rc.2 |
+| **0.3.1** (latest) | 0.1.5-rc.3, 0.1.7-alpha.1 / alpha.2, 0.1.7-rc.1 / rc.2 |
+| 0.3.0 | 0.1.5-rc.3, 0.1.7-alpha.1 / alpha.2, 0.1.7-rc.1 / rc.2 |
 | 0.2.7 | 0.1.5-rc.3, 0.1.7-alpha.1 / alpha.2, 0.1.7-rc.1 / rc.2 |
 | 0.2.6 | 0.1.5-rc.3, 0.1.7-alpha.1 / alpha.2, 0.1.7-rc.1 |
 | 0.2.5 | 0.1.5-rc.1 / rc.2 / rc.3, 0.1.7-alpha.1 / alpha.2 |
@@ -79,7 +80,7 @@ Restart DSH once afterwards and open the Web UI; changing settings needs no rest
 - **Switching following off never jumps** — the moment the switch goes off, the interface writes the font and weight offset it was **already showing** into its own fields (that is what it was following), so nothing changes on screen and the sliders continue from there; an axis the conversation does not set clears the interface's own field instead, keeping DSH's default. "Reset" on that field goes back to DSH's own weight (all three weight offsets return to 0)
 - **The interface weight cannot reach the conversation** — it is the one axis that has to cover the whole page (DSH pins its small labels' weights in upstream class rules, which nothing narrower can reach), so it is implemented as a rule with the **whole conversation markdown subtree excluded**: paragraphs, headings and bold text in the conversation are untouched
 - **Weight readouts** — all three weight axes read 0 when unset (the slider sits in the middle); no "unset" wording appears anywhere, and an absolute weight stored by an older version (300 ~ 600) is converted to its equivalent offset on read (400 → 0, 450 → +50), so nothing has to be set again
-- **The weight slider counts steps** — the card measures how many distinct weights the current family can render and derives the slider's range and step size from that (the readout is the step count, e.g. `-2` … `+4`), so every notch is a visible change and the numbers stay small; changing the family re-measures it
+- **The weight slider counts steps** — the card measures how many distinct weights the current family can render for body text and for bold text, one step being one pair of neighbouring faces, and the range ending where those two stop swapping faces (the readout is the step count, e.g. `-2 … +2`), so every notch is a visible change and the numbers stay small; changing the family re-measures it
 - **Presets** — the dropdown select below the edit mode (默认配置 1 ~ 5, with the card's own chevron inside the box); picking one switches and auto-saves the edits that follow. "Rename" renames the current preset, "Export" copies JSON and "Import" merges a paste. Operation results ("copied to the clipboard") appear on the **right** of the row below and fade out by themselves after about 2.6 s, without moving any layout
 - **Preview** — expanding the conversation / interface / code section ends with that section's own preview box, rendering just that part
 - Settings are stored in DSH's settings document (the profile's `cordis.patch.yml` from 0.1.7 on, `settings.yaml` before that), so they travel with the profile

package/README.md

@@ -9,7 +9,7 @@
 - **三套排印**：对话（会话 Markdown 正文、表格与标题）排在第一位、拥有全部轴；界面（设置页、侧栏、工作区与标题按钮）提供**字体与字重**、默认跟随对话（可关）；代码独立成轴
 - **界面 / 对话 / 代码字体** —— 各自独立的字体回退列表，拉丁字体在前、中文字体在后；留空表示完全沿用 DSH 的字体栈
 - **字号偏移** —— **对话**字号 -3 ~ +6 px，加在 DSH 自己的「对话字号」之上（官方数值是基准），段落、标题与行高一起跟随，且**只在源头加一次**（H1/H2/H3 的尺寸都由同一条 delta 派生，任意偏移下层级都不变、也不会出现某个标题偏小）；代码字号独立成轴，-3 ~ +6 px。**界面没有字号轴**：经实测 DSH 的设置页、侧栏与工作区把字号写死在上游 CSS 里，唯一官方字号接口就是「对话字号」
-- **字重偏移** —— **对话、界面与代码都是同一种相对偏移**（-100 ~ +200，未设置即 0、读数按 `+n` / `-n` 显示）：偏移叠加在每个元素**自身的**字重上，标题仍按 DSH 的层级（h1~h3 700、h4~h6 与加粗 600、表头 500、正文 400）逐级保持"标题明显粗于正文"，调重调轻都不会把层级抹平，代码块里的粗体也不会被压平。界面偏移是一条把对话 Markdown 整棵子树排除在外、只铺 `body` 与自带字重的元素表的规则：真机实测（活页面计算样式）它把界面的文本元素改到目标值、对话 markdown 里的元素一个都没动，所以**改界面字重不会碰到对话**。滑块**按档计数**：读数就是档数（例如 `-2 -1 0 +1 +2 +3 +4`），**档数由字体决定**——卡片会在页面里量出所选字体实际能渲染出几种粗细，再据此决定一共有几档、每一档差多少，所以每挪一格都是一次看得见的变化，换字体会重新测量。文档里存的仍是字重偏移（旧值自动换算），换字体不会把设置改坏；字体只有常规与粗体两档时全范围就只有 3 档，要连续可选用字重档位多的字体或可变字体
+- **字重偏移** —— **对话、界面与代码都是同一种相对偏移**（-100 ~ +200，未设置即 0、读数按 `+n` / `-n` 显示）：偏移叠加在每个元素**自身的**字重上，标题仍按 DSH 的层级（h1~h3 700、h4~h6 与加粗 600、表头 500、正文 400）逐级保持"标题明显粗于正文"，调重调轻都不会把层级抹平，代码块里的粗体也不会被压平。界面偏移是一条把对话 Markdown 整棵子树排除在外、只铺 `body` 与自带字重的元素表的规则：真机实测（活页面计算样式）它把界面的文本元素改到目标值、对话 markdown 里的元素一个都没动，所以**改界面字重不会碰到对话**。滑块**按档计数**：读数就是档数（例如 `-1 0 +1`），**档数由字体决定**——卡片会在页面里量出所选字体在正文与加粗文字两处实际能渲染出几种粗细，一档就是相邻的两张字形，范围也以这两处还能换到字形为限（标题那一层到顶后停住），所以每挪一格都是看得见的变化，数字也不会出现"几百几百"；换字体会重新测量。文档里存的仍是字重偏移（旧值自动换算），换字体不会把设置改坏；字体只有常规与粗体两档时全范围就只有 3 档，要连续可选用字重档位多的字体或可变字体
 - **行高** —— **对话**行高用倍率（100% ~ 160%）；代码行高用加法偏移（-4 ~ +8 px）。界面没有行高轴（同字号的原因）
 - **代码连字** —— 三档开关（默认 / 开启 / 关闭，浏览器默认即开启，关闭可还原 `=>`、`!=` 这类连字），高级模式另有 `font-feature-settings` 特性值输入
 - **拒绝合成样式**（默认关闭 = 允许合成） —— 打开后禁用浏览器为中文伪造的斜体与粗体（中文字体没有斜体字形，浏览器会硬掰）；关着（默认）时由浏览器按自己的规则合成，字体缺粗体字形时至少还能看出"粗体"这一档
@@ -26,7 +26,8 @@
 
 | 插件版本 | 支持的 DSH 版本 |
 | --- | --- |
-| **0.3.0**（最新） | 0.1.5-rc.3、0.1.7-alpha.1 / alpha.2、0.1.7-rc.1 / rc.2 |
+| **0.3.1**（最新） | 0.1.5-rc.3、0.1.7-alpha.1 / alpha.2、0.1.7-rc.1 / rc.2 |
+| 0.3.0 | 0.1.5-rc.3、0.1.7-alpha.1 / alpha.2、0.1.7-rc.1 / rc.2 |
 | 0.2.7 | 0.1.5-rc.3、0.1.7-alpha.1 / alpha.2、0.1.7-rc.1 / rc.2 |
 | 0.2.6 | 0.1.5-rc.3、0.1.7-alpha.1 / alpha.2、0.1.7-rc.1 |
 | 0.2.5 | 0.1.5-rc.1 / rc.2 / rc.3、0.1.7-alpha.1 / alpha.2 |
@@ -79,7 +80,7 @@ dsh plugin --profile web add <插件目录路径>
 - **关掉跟随不会跳变** —— 关掉开关的那一刻，界面会把**正在显示的**字体与字重偏移写成自己的值（跟随期间它本来就是这两项），所以画面零变化、滑块从当前值继续调；对话没设的那一项则清掉界面自己的字段、保持 DSH 默认。想回到 DSH 自己的粗细点该项的「重置」（三个字重偏移读数都回到 0）
 - **界面字重不会碰到对话** —— 界面字重是唯一必须铺满整页的轴（DSH 把小标签的粗细写死在上游 CSS 的类规则里，窄规则够不到它），实现上是一条把**对话 Markdown 整棵子树排除在外**的规则，所以对话的段落、标题、粗体都不受影响
 - **字重读数** —— 三个字重轴的未设置读数都显示 0（滑块停在正中）；不会出现「未设置」这类字眼；旧版本存的绝对字重（300 ~ 600）会在读取时自动换算成等价偏移（400 → 0、450 → +50），无需手动重设
-- **字重滑块按档计数** —— 卡片会量出当前字体能渲染出几档粗细，据此决定滑块的上下限与每档的大小（读数就是档数，如 `-2` ~ `+4`），所以每挪一格都看得出变化、也不会出现"几百几百"的数字；换字体后档数会重新测量
+- **字重滑块按档计数** —— 卡片会量出当前字体在正文与加粗文字两处各能渲染出几档粗细，一档 = 相邻两张字形、上下限以这两处还能换字形为限（读数就是档数，如 `-2 … +2`），所以每挪一格都看得出变化、也不会出现"几百几百"的数字；换字体后档数会重新测量
 - **预设方案** —— 编辑模式下方的下拉选择框（默认配置 1 ~ 5，框内右侧有与卡片一致的下拉箭头），点开选择即切换并自动保存后续改动；「改名」重命名当前方案，「导出」复制 JSON，「导入」粘贴合并。操作结果（如「已复制到剪贴板」）显示在下面那行的**右侧**，约 2.6 秒后自动淡出，不会顶动任何布局
 - **预览** —— 对话 / 界面 / 代码分区展开后，各自分区末尾有一个预览框，只渲染该分区的样式
 - 设置保存在 DSH 的设置文档里（0.1.7 起是 profile 的 `cordis.patch.yml`，更早的版本是 `settings.yaml`），跟随 profile 走

package/lib/client.js

@@ -176,6 +176,16 @@ var WEIGHT_DELTA_CEIL = 600;
 /** The weight DSH gives an element that declares none of its own. */
 var WEIGHT_BASE = 400;
 
+/**
+ * The weight range CSS accepts at all.
+ *
+ * Named because it is easy to confuse with `WEIGHT_MIN…WEIGHT_MAX`, which is the
+ * window an ABSOLUTE weight from a pre-relative document occupies (300…600) and
+ * has nothing to do with what a font can render.
+ */
+var WEIGHT_CSS_MIN = 100;
+var WEIGHT_CSS_MAX = 900;
+
 /**
  * The weight ladder of the conversation: each group carries the weight DSH's
  * own stylesheet gives those elements, so an offset lands ON TOP of it.
@@ -195,6 +205,43 @@ var DIALOG_WEIGHT_GROUPS = [
   },
 ];
 
+/**
+ * The heaviest base in the conversation ladder — the layer with the least room.
+ *
+ * Derived from the ladder so the two cannot drift apart.
+ */
+var WEIGHT_LADDER_TOP = DIALOG_WEIGHT_GROUPS.reduce(function (top, group) {
+  return group.base > top ? group.base : top;
+}, WEIGHT_BASE);
+
+/**
+ * How far above its base an offset may reach at all.
+ *
+ * Every axis applies the offset to each element's OWN weight, and the heaviest
+ * layer of the ladder sits at `WEIGHT_LADDER_TOP`; past `WEIGHT_CSS_MAX` minus
+ * that, the heaviest layer cannot move any further, so a longer range would only
+ * add positions that change nothing for the boldest text on screen.
+ *
+ * Staying inside it has a second, load-bearing effect: offsets then never land in
+ * `WEIGHT_MIN…WEIGHT_MAX`, the range an ABSOLUTE weight from a pre-relative
+ * document occupies (see `clampWeightDelta`). The two meanings cannot be confused,
+ * so a stored offset is never rescaled into a different one.
+ */
+var WEIGHT_DELTA_UP_LIMIT = WEIGHT_CSS_MAX - WEIGHT_LADDER_TOP;
+
+/**
+ * The heaviest layer a notch still has to move: bold text.
+ *
+ * The heading layer above it is deliberately left out of that requirement. A heavy
+ * family spaces its top faces far apart (a 700 cut next to a 900), so headings
+ * reach their heaviest rendering part-way up the range and would otherwise hold the
+ * whole control down to one wide step. Every notch must move the text you read and
+ * the text you emphasise; a heading that is already at its boldest face stays there.
+ */
+var WEIGHT_LADDER_STRONG = DIALOG_WEIGHT_GROUPS.reduce(function (strong, group) {
+  return group.base < WEIGHT_LADDER_TOP && group.base > strong ? group.base : strong;
+}, WEIGHT_BASE);
+
 /** Allowed line-height ratio range, in percent (100 = untouched). */
 var LINE_HEIGHT_MIN = 100;
 var LINE_HEIGHT_MAX = 160;
@@ -1669,19 +1716,25 @@ function ceilTo(value, step) {
 
 /**
  * Does every position of `[min..max]` in `step` increments render differently?
+ *
+ * Checked at every base the offset is added to: a step that is fine for body text
+ * can be a no-op one layer up, where the faces are further apart.
  * @param {(weight: number) => string|number} sample - probe.
- * @param {number} base - the weight the offsets are added to.
+ * @param {number[]} bases - the weights the offsets are added to.
  * @param {number} min - first offset.
  * @param {number} max - last offset.
  * @param {number} step - offset increment.
- * @returns {boolean} true when no two neighbours render the same.
- */
-function everyPositionDiffers(sample, base, min, max, step) {
-  var previous = null;
-  for (var position = min; position <= max; position += step) {
-    var signature = sample(base + position);
-    if (previous !== null && signature === previous) return false;
-    previous = signature;
+ * @returns {boolean} true when no two neighbours render the same at any base.
+ */
+function everyPositionDiffers(sample, bases, min, max, step) {
+  for (var index = 0; index < bases.length; index += 1) {
+    var base = bases[index];
+    var previous = null;
+    for (var position = min; position <= max; position += step) {
+      var signature = sample(base + position);
+      if (previous !== null && signature === previous) return false;
+      previous = signature;
+    }
   }
   return true;
 }
@@ -1692,17 +1745,21 @@ function everyPositionDiffers(sample, base, min, max, step) {
  * A font with six faces can be made lighter or heavier only as far as those faces
  * reach, and only in steps between them; a family with a continuous axis gets a
  * fine step and a wide range. Measured on a weight grid:
- *  - the top of the range is the LOWEST weight that already renders as heavy as
- *    the family can (asking for more cannot change anything), and the bottom is
- *    the highest weight that still renders as light as it can;
- *  - the step is the finest candidate whose positions all differ, so no notch is
- *    a no-op. A family whose faces are unevenly spaced (a 700 next to a 900) may
- *    end up with one repeated position whichever uniform step is used — the
- *    coarsest candidate is then the honest answer, never a crash.
+ *  - the downward reach is the highest weight that still renders as light as the
+ *    family can (asking for less cannot change anything);
+ *  - the upward reach is the LOWEST weight at or above the layer a notch has to
+ *    move that already renders as heavy as the family can, so the range ends where
+ *    bold text stops changing instead of running past it (see `WEIGHT_DELTA_UP_LIMIT`
+ *    for why that ceiling is also the widest one allowed);
+ *  - the step is the finest candidate whose positions all differ at every base a
+ *    notch has to move, so no notch is a no-op for body text or bold text. A family whose faces are unevenly spaced
+ *    (a 700 next to a 900) may end up with one repeated position whichever uniform
+ *    step is used — the coarsest candidate is then the honest answer, never a crash.
  * @param {(weight: number) => string|number} sample - renders a probe at one
  *   weight and returns a signature; equal signatures mean identical rendering.
- * @param {{candidates?: number[], floor?: number, ceil?: number}} [options]
- *   overrides for the candidates and the widest allowed range.
+ * @param {{candidates?: number[], floor?: number, ceil?: number, top?: number}}
+ *   [options] overrides for the candidates, the widest allowed range and the
+ *   heaviest base the offset is added to (the ladder's, or the axis's own).
  * @returns {{min: number, max: number, step: number}} the slider's shape; the
  *   range always contains 0, which is the "leave DSH alone" position.
  */
@@ -1714,6 +1771,7 @@ function weightProfileFrom(sample, options) {
       : WEIGHT_STEP_CANDIDATES;
   var floor = typeof settings.floor === "number" ? settings.floor : WEIGHT_DELTA_FLOOR;
   var ceil = typeof settings.ceil === "number" ? settings.ceil : WEIGHT_DELTA_CEIL;
+  var top = typeof settings.top === "number" ? settings.top : WEIGHT_LADDER_STRONG;
   var topSignature = sample(WEIGHT_PROBE_HIGH);
   var bottomSignature = sample(WEIGHT_PROBE_LOW);
   var heaviest = WEIGHT_PROBE_HIGH;
@@ -1730,23 +1788,41 @@ function weightProfileFrom(sample, options) {
       break;
     }
   }
-  var reachUp = Math.min(ceil, Math.max(0, heaviest - WEIGHT_BASE));
+  // How far the offset can go before NO layer that must move can move any more:
+  // the widest horizon among those bases, since a layer that could still change
+  // must not be cut off by one that already sits at its heaviest face.
+  var headroom = Math.max(0, heaviest - WEIGHT_BASE);
+  if (top !== WEIGHT_BASE) {
+    for (var up = top; up <= WEIGHT_PROBE_HIGH; up += WEIGHT_PROBE_STEP) {
+      if (sample(up) === topSignature) {
+        headroom = Math.max(headroom, up - top);
+        break;
+      }
+    }
+  }
+  var reachUp = Math.min(ceil, WEIGHT_DELTA_UP_LIMIT, headroom);
   var reachDown = Math.max(floor, Math.min(0, lightest - WEIGHT_BASE));
+  var bases = top === WEIGHT_BASE ? [WEIGHT_BASE] : [WEIGHT_BASE, top];
   for (var index = 0; index < candidates.length; index += 1) {
     var step = candidates[index];
     if (!(step > 0)) continue;
     var min = floorTo(reachDown, step);
-    var max = ceilTo(reachUp, step);
-    if (everyPositionDiffers(sample, WEIGHT_BASE, min, max, step)) {
+    // Rounding up to the step must not push the range past the limit: the widest
+    // offset has to stay out of the absolute-weight window.
+    var max = Math.min(ceilTo(reachUp, step), WEIGHT_DELTA_UP_LIMIT);
+    // A step wider than the range would leave only one reachable position.
+    if (max > min && step > max - min) continue;
+    if (everyPositionDiffers(sample, bases, min, max, step)) {
       return { min: min, max: max, step: step };
     }
   }
   var coarsest = candidates[candidates.length - 1];
-  return {
-    min: floorTo(reachDown, coarsest),
-    max: ceilTo(reachUp, coarsest),
-    step: coarsest,
-  };
+  var min = floorTo(reachDown, coarsest);
+  var max = Math.min(ceilTo(reachUp, coarsest), WEIGHT_DELTA_UP_LIMIT);
+  // Nothing kept every position alive: the coarsest step that still fits is the
+  // honest answer, never a step the control cannot reach.
+  var span = max - min;
+  return { min: min, max: max, step: span > 0 ? Math.min(coarsest, span) : 1 };
 }
 
 /**
@@ -1930,7 +2006,9 @@ function buildAxisCss(axis, baseTokens, isDark, hints) {
    * @returns {string} the `font-weight` value.
    */
   function ladderWeight(base) {
-    return "clamp(100,calc(" + base + " + var(--dfp-wdelta,0)),900)";
+    return (
+      "clamp(" + WEIGHT_CSS_MIN + ",calc(" + base + " + var(--dfp-wdelta,0))," + WEIGHT_CSS_MAX + ")"
+    );
   }
   /**
    * The scope the conversation WEIGHT rules hang on: the cheap markdown wrapper
@@ -2088,6 +2166,16 @@ function buildAxisCss(axis, baseTokens, isDark, hints) {
   // ladder below re-states each group's own base PLUS the offset, so the
   // hierarchy survives any offset, in both directions, and `d = 0` injects
   // nothing at all.
+  if (dialogDelta === WEIGHT_UNSET && interfaceDelta !== WEIGHT_UNSET) {
+    // The conversation has NO offset of its own — which is exactly why it has to
+    // say so. The interface axis declares `--dfp-wdelta` on `:root,body`, so an
+    // unset conversation INHERITED it: with the interface at +80 the card showed 0
+    // for the conversation while the page rendered +80, and the first notch above
+    // it only added 20 units — a step nobody can see (measured on 0.1.7-rc.2:
+    // `delta` read 80 at the "0" position and 100 at "+1"). Pinning zero keeps
+    // "0 = leave DSH alone" true no matter what the other axes are set to.
+    declarations.push(weightScopeRule("--dfp-wdelta:0"));
+  }
   if (dialogDelta !== WEIGHT_UNSET) {
     // Every ladder rule reads `--dfp-wdelta`, so the conversation pins it to its
     // own offset: the interface's value must not leak in, and an element inside
@@ -2793,6 +2881,11 @@ var shared = {
   WEIGHT_STEP_CANDIDATES: WEIGHT_STEP_CANDIDATES,
   WEIGHT_DELTA_FLOOR: WEIGHT_DELTA_FLOOR,
   WEIGHT_DELTA_CEIL: WEIGHT_DELTA_CEIL,
+  WEIGHT_LADDER_TOP: WEIGHT_LADDER_TOP,
+  WEIGHT_LADDER_STRONG: WEIGHT_LADDER_STRONG,
+  WEIGHT_DELTA_UP_LIMIT: WEIGHT_DELTA_UP_LIMIT,
+  WEIGHT_CSS_MIN: WEIGHT_CSS_MIN,
+  WEIGHT_CSS_MAX: WEIGHT_CSS_MAX,
   weightProfileFrom: weightProfileFrom,
   weightStepRange: weightStepRange,
   isShorthandName: isShorthandName,
@@ -3120,13 +3213,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); another font offers a different number of them.",
+      "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.",
     "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); another font offers a different number of them.",
+      "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.",
     "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); another font offers a different number of them.",
+      "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.",
 
     "line.dialogLabel": "Conversation line height",
     "line.dialogHint":
@@ -3264,13 +3357,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 原样。",
@@ -3747,7 +3840,11 @@ function sampleWeightSignature(stack, weight) {
     weightProbeCanvas.width = 260;
     weightProbeCanvas.height = 56;
   }
-  var context = weightProbeCanvas.getContext("2d");
+  // `willReadFrequently` matters here: the profile probe reads the canvas back once
+// per sampled weight (~80 times on the first measurement), and without it the
+// browser keeps a GPU-backed surface and warns about the readbacks — which is part
+// of why dragging the weight felt heavy.
+var context = weightProbeCanvas.getContext("2d", { willReadFrequently: true });
   context.clearRect(0, 0, weightProbeCanvas.width, weightProbeCanvas.height);
   context.font = weight + " 32px " + stack;
   context.textBaseline = "top";
@@ -3765,22 +3862,27 @@ function sampleWeightSignature(stack, weight) {
  *
  * A family can only be made as light or as heavy as the faces it ships, so the
  * range is measured rather than fixed (`weightProfileFrom`), which also makes
- * every notch a change. Measured once per family and cached; any failure (no
- * canvas, no 2D context) falls back to the nominal window with single units.
+ * every notch a change — for every layer of the ladder, so the measurement is
+ * told which base is the heaviest one the offset lands on. Measured once per
+ * family and base and cached; any failure (no canvas, no 2D context) falls back
+ * to the nominal window with single units.
  * @param {string} stack - resolved `font-family` value, "" for the page default.
+ * @param {number} [top] - the heaviest base the offset is added to; the ladder's
+ *   own top for the conversation and interface axes, the axis's base for code.
  * @returns {{min: number, max: number, step: number}} the slider shape.
  */
-function weightProfileFor(stack) {
-  var key = String(stack);
+function weightProfileFor(stack, top) {
+  var base = typeof top === "number" ? top : shared.WEIGHT_LADDER_TOP;
+  var key = String(stack) + "\u0000" + base;
   if (Object.prototype.hasOwnProperty.call(weightProfileCache, key)) {
     return weightProfileCache[key];
   }
   var profile = { min: WEIGHT_DELTA_MIN, max: WEIGHT_DELTA_MAX, step: 1 };
   try {
-    var resolved = key === "" ? liveFamily() : key;
+    var resolved = String(stack) === "" ? liveFamily() : String(stack);
     profile = weightProfileFrom(function (weight) {
       return sampleWeightSignature(resolved, weight);
-    });
+    }, { top: base });
   } catch (error) {
     profile = { min: WEIGHT_DELTA_MIN, max: WEIGHT_DELTA_MAX, step: 1 };
   }
@@ -3801,6 +3903,72 @@ function liveFamily() {
   }
 }
 
+/**
+ * The conversation's own line-height ratio, measured once.
+ *
+ * The dialog line-height axis is a percentage OF DSH's own height (`28px × 1.05`),
+ * so a preview that used the percentage as an ABSOLUTE ratio was wrong twice over:
+ * at 100% it fell back to DSH's real (taller) default, while 105% asked for 1.05 —
+ * shorter than that default and out of order with the notches above it.
+ *
+ * The base is read from a hidden node carrying the markdown class whose rule
+ * consumes DSH's markdown shorthand, so it is the same ratio the page multiplies.
+ * @returns {number} line height ÷ font size; a plain default when unmeasurable.
+ */
+var DIALOG_LINE_RATIO_FALLBACK = 1.5;
+var dialogLineRatioCache = null;
+function dialogLineRatio() {
+  if (typeof dialogLineRatioCache === "number") return dialogLineRatioCache;
+  if (typeof document === "undefined" || typeof document.defaultView === "undefined") {
+    return DIALOG_LINE_RATIO_FALLBACK;
+  }
+  try {
+    var className = "";
+    var sheets = document.styleSheets || [];
+    for (var index = 0; index < sheets.length && className === ""; index += 1) {
+      var rules = null;
+      try {
+        rules = sheets[index].cssRules;
+      } catch (error) {
+        rules = null;
+      }
+      if (!rules) continue;
+      for (var ruleIndex = 0; ruleIndex < rules.length; ruleIndex += 1) {
+        var selector = rules[ruleIndex].selectorText || "";
+        var body = rules[ruleIndex].style ? rules[ruleIndex].style.cssText : "";
+        if (selector.indexOf("_markdown_") < 0) continue;
+        if (body.indexOf("--dsw-font-markdown-base") < 0) continue;
+        var found = selector.match(/\.(_markdown_[A-Za-z0-9_-]+)/);
+        if (found) className = found[1];
+      }
+    }
+    if (className !== "") {
+      var host = document.createElement("div");
+      host.className = className;
+      host.setAttribute("data-dss-prose", "");
+      host.style.position = "absolute";
+      host.style.visibility = "hidden";
+      host.style.left = "-9999px";
+      var probe = document.createElement("p");
+      probe.textContent = "line";
+      probe.style.margin = "0";
+      host.appendChild(probe);
+      document.body.appendChild(host);
+      var style = document.defaultView.getComputedStyle(probe);
+      var size = parseFloat(style.fontSize);
+      var height = parseFloat(style.lineHeight);
+      if (isFinite(size) && size > 0 && isFinite(height) && height > 0) {
+        dialogLineRatioCache = Math.round((height / size) * 10000) / 10000;
+      }
+      if (host.parentNode) host.parentNode.removeChild(host);
+    }
+  } catch (error) {
+    /* the fallback stands */
+  }
+  if (typeof dialogLineRatioCache !== "number") dialogLineRatioCache = DIALOG_LINE_RATIO_FALLBACK;
+  return dialogLineRatioCache;
+}
+
 /**
  * The family code surfaces render with when the code axis sets none.
  * @returns {string} the computed family, or "" when unreadable.
@@ -5322,7 +5490,10 @@ function FontCard(props) {
   // measured on the page. The VALUE written to the document stays a weight offset,
   // so nothing stored before has to be migrated and the stylesheet is unchanged.
   var weightField = function (props) {
-    var profile = weightProfileFor(props.stack === undefined ? "" : props.stack);
+    var profile = weightProfileFor(
+      props.stack === undefined ? "" : props.stack,
+      props.top === undefined ? shared.WEIGHT_LADDER_STRONG : props.top
+    );
     var stored = props.value === WEIGHT_UNSET ? NEUTRAL_WEIGHT : props.value;
     // A stored offset outside the measured range (the font changed since it was
     // set) widens the control, so it is never unreachable.
@@ -5741,9 +5912,10 @@ function FontCard(props) {
    * @returns {number} the step count.
    */
   var weightCount = function (field, value) {
+    var isCode = field === CODE_WEIGHT_FIELD;
     var stack =
-      field === WEIGHT_DIALOG_FIELD ? dialogStack : field === CODE_WEIGHT_FIELD ? codeStack : uiStack;
-    var profile = weightProfileFor(stack);
+      field === WEIGHT_DIALOG_FIELD ? dialogStack : isCode ? codeStack : uiStack;
+    var profile = weightProfileFor(stack, isCode ? shared.WEIGHT_BASE : shared.WEIGHT_LADDER_STRONG);
     return weightStepRange(profile, value === WEIGHT_UNSET ? 0 : value).value;
   };
 
@@ -5760,9 +5932,13 @@ function FontCard(props) {
   // rule would otherwise paint into this box.
   if (dialogStack !== "") previewDialogStyle.fontFamily = dialogStack;
   previewDialogStyle.fontSize = 13 + editing[SIZE_DIALOG_FIELD] + "px";
-  if (editing[LINE_HEIGHT_DIALOG_FIELD] !== LINE_HEIGHT_MIN) {
-    previewDialogStyle.lineHeight = String(editing[LINE_HEIGHT_DIALOG_FIELD] / 100);
-  }
+  // 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,
+  // or the preview would show a shorter line at 105% than at 100%.
+  previewDialogStyle.lineHeight = String(
+    Math.round(dialogLineRatio() * (editing[LINE_HEIGHT_DIALOG_FIELD] / LINE_HEIGHT_MIN) * 10000) /
+      10000
+  );
   if (editing[WEIGHT_DIALOG_FIELD] !== WEIGHT_UNSET) {
     // The offset, not a weight: the injected stylesheet's conversation ladder
     // reads `--dfp-wdelta` on this very class and re-states each element's own
@@ -6149,6 +6325,10 @@ function FontCard(props) {
               labelKey: "weight.codeLabel",
               hintKey: "weight.codeHint",
               value: editing[CODE_WEIGHT_FIELD],
+              // The code axis puts one weight on the whole surface, so its own base
+              // is the heaviest layer there is: any lower base would cap the range
+              // short of what code text can actually reach.
+              top: shared.WEIGHT_BASE,
               stack: codeStack,
             }),
             ligatureField(),

package/lib/shared.cjs

@@ -167,6 +167,16 @@ var WEIGHT_DELTA_CEIL = 600;
 /** The weight DSH gives an element that declares none of its own. */
 var WEIGHT_BASE = 400;
 
+/**
+ * The weight range CSS accepts at all.
+ *
+ * Named because it is easy to confuse with `WEIGHT_MIN…WEIGHT_MAX`, which is the
+ * window an ABSOLUTE weight from a pre-relative document occupies (300…600) and
+ * has nothing to do with what a font can render.
+ */
+var WEIGHT_CSS_MIN = 100;
+var WEIGHT_CSS_MAX = 900;
+
 /**
  * The weight ladder of the conversation: each group carries the weight DSH's
  * own stylesheet gives those elements, so an offset lands ON TOP of it.
@@ -186,6 +196,43 @@ var DIALOG_WEIGHT_GROUPS = [
   },
 ];
 
+/**
+ * The heaviest base in the conversation ladder — the layer with the least room.
+ *
+ * Derived from the ladder so the two cannot drift apart.
+ */
+var WEIGHT_LADDER_TOP = DIALOG_WEIGHT_GROUPS.reduce(function (top, group) {
+  return group.base > top ? group.base : top;
+}, WEIGHT_BASE);
+
+/**
+ * How far above its base an offset may reach at all.
+ *
+ * Every axis applies the offset to each element's OWN weight, and the heaviest
+ * layer of the ladder sits at `WEIGHT_LADDER_TOP`; past `WEIGHT_CSS_MAX` minus
+ * that, the heaviest layer cannot move any further, so a longer range would only
+ * add positions that change nothing for the boldest text on screen.
+ *
+ * Staying inside it has a second, load-bearing effect: offsets then never land in
+ * `WEIGHT_MIN…WEIGHT_MAX`, the range an ABSOLUTE weight from a pre-relative
+ * document occupies (see `clampWeightDelta`). The two meanings cannot be confused,
+ * so a stored offset is never rescaled into a different one.
+ */
+var WEIGHT_DELTA_UP_LIMIT = WEIGHT_CSS_MAX - WEIGHT_LADDER_TOP;
+
+/**
+ * The heaviest layer a notch still has to move: bold text.
+ *
+ * The heading layer above it is deliberately left out of that requirement. A heavy
+ * family spaces its top faces far apart (a 700 cut next to a 900), so headings
+ * reach their heaviest rendering part-way up the range and would otherwise hold the
+ * whole control down to one wide step. Every notch must move the text you read and
+ * the text you emphasise; a heading that is already at its boldest face stays there.
+ */
+var WEIGHT_LADDER_STRONG = DIALOG_WEIGHT_GROUPS.reduce(function (strong, group) {
+  return group.base < WEIGHT_LADDER_TOP && group.base > strong ? group.base : strong;
+}, WEIGHT_BASE);
+
 /** Allowed line-height ratio range, in percent (100 = untouched). */
 var LINE_HEIGHT_MIN = 100;
 var LINE_HEIGHT_MAX = 160;
@@ -1660,19 +1707,25 @@ function ceilTo(value, step) {
 
 /**
  * Does every position of `[min..max]` in `step` increments render differently?
+ *
+ * Checked at every base the offset is added to: a step that is fine for body text
+ * can be a no-op one layer up, where the faces are further apart.
  * @param {(weight: number) => string|number} sample - probe.
- * @param {number} base - the weight the offsets are added to.
+ * @param {number[]} bases - the weights the offsets are added to.
  * @param {number} min - first offset.
  * @param {number} max - last offset.
  * @param {number} step - offset increment.
- * @returns {boolean} true when no two neighbours render the same.
- */
-function everyPositionDiffers(sample, base, min, max, step) {
-  var previous = null;
-  for (var position = min; position <= max; position += step) {
-    var signature = sample(base + position);
-    if (previous !== null && signature === previous) return false;
-    previous = signature;
+ * @returns {boolean} true when no two neighbours render the same at any base.
+ */
+function everyPositionDiffers(sample, bases, min, max, step) {
+  for (var index = 0; index < bases.length; index += 1) {
+    var base = bases[index];
+    var previous = null;
+    for (var position = min; position <= max; position += step) {
+      var signature = sample(base + position);
+      if (previous !== null && signature === previous) return false;
+      previous = signature;
+    }
   }
   return true;
 }
@@ -1683,17 +1736,21 @@ function everyPositionDiffers(sample, base, min, max, step) {
  * A font with six faces can be made lighter or heavier only as far as those faces
  * reach, and only in steps between them; a family with a continuous axis gets a
  * fine step and a wide range. Measured on a weight grid:
- *  - the top of the range is the LOWEST weight that already renders as heavy as
- *    the family can (asking for more cannot change anything), and the bottom is
- *    the highest weight that still renders as light as it can;
- *  - the step is the finest candidate whose positions all differ, so no notch is
- *    a no-op. A family whose faces are unevenly spaced (a 700 next to a 900) may
- *    end up with one repeated position whichever uniform step is used — the
- *    coarsest candidate is then the honest answer, never a crash.
+ *  - the downward reach is the highest weight that still renders as light as the
+ *    family can (asking for less cannot change anything);
+ *  - the upward reach is the LOWEST weight at or above the layer a notch has to
+ *    move that already renders as heavy as the family can, so the range ends where
+ *    bold text stops changing instead of running past it (see `WEIGHT_DELTA_UP_LIMIT`
+ *    for why that ceiling is also the widest one allowed);
+ *  - the step is the finest candidate whose positions all differ at every base a
+ *    notch has to move, so no notch is a no-op for body text or bold text. A family whose faces are unevenly spaced
+ *    (a 700 next to a 900) may end up with one repeated position whichever uniform
+ *    step is used — the coarsest candidate is then the honest answer, never a crash.
  * @param {(weight: number) => string|number} sample - renders a probe at one
  *   weight and returns a signature; equal signatures mean identical rendering.
- * @param {{candidates?: number[], floor?: number, ceil?: number}} [options]
- *   overrides for the candidates and the widest allowed range.
+ * @param {{candidates?: number[], floor?: number, ceil?: number, top?: number}}
+ *   [options] overrides for the candidates, the widest allowed range and the
+ *   heaviest base the offset is added to (the ladder's, or the axis's own).
  * @returns {{min: number, max: number, step: number}} the slider's shape; the
  *   range always contains 0, which is the "leave DSH alone" position.
  */
@@ -1705,6 +1762,7 @@ function weightProfileFrom(sample, options) {
       : WEIGHT_STEP_CANDIDATES;
   var floor = typeof settings.floor === "number" ? settings.floor : WEIGHT_DELTA_FLOOR;
   var ceil = typeof settings.ceil === "number" ? settings.ceil : WEIGHT_DELTA_CEIL;
+  var top = typeof settings.top === "number" ? settings.top : WEIGHT_LADDER_STRONG;
   var topSignature = sample(WEIGHT_PROBE_HIGH);
   var bottomSignature = sample(WEIGHT_PROBE_LOW);
   var heaviest = WEIGHT_PROBE_HIGH;
@@ -1721,23 +1779,41 @@ function weightProfileFrom(sample, options) {
       break;
     }
   }
-  var reachUp = Math.min(ceil, Math.max(0, heaviest - WEIGHT_BASE));
+  // How far the offset can go before NO layer that must move can move any more:
+  // the widest horizon among those bases, since a layer that could still change
+  // must not be cut off by one that already sits at its heaviest face.
+  var headroom = Math.max(0, heaviest - WEIGHT_BASE);
+  if (top !== WEIGHT_BASE) {
+    for (var up = top; up <= WEIGHT_PROBE_HIGH; up += WEIGHT_PROBE_STEP) {
+      if (sample(up) === topSignature) {
+        headroom = Math.max(headroom, up - top);
+        break;
+      }
+    }
+  }
+  var reachUp = Math.min(ceil, WEIGHT_DELTA_UP_LIMIT, headroom);
   var reachDown = Math.max(floor, Math.min(0, lightest - WEIGHT_BASE));
+  var bases = top === WEIGHT_BASE ? [WEIGHT_BASE] : [WEIGHT_BASE, top];
   for (var index = 0; index < candidates.length; index += 1) {
     var step = candidates[index];
     if (!(step > 0)) continue;
     var min = floorTo(reachDown, step);
-    var max = ceilTo(reachUp, step);
-    if (everyPositionDiffers(sample, WEIGHT_BASE, min, max, step)) {
+    // Rounding up to the step must not push the range past the limit: the widest
+    // offset has to stay out of the absolute-weight window.
+    var max = Math.min(ceilTo(reachUp, step), WEIGHT_DELTA_UP_LIMIT);
+    // A step wider than the range would leave only one reachable position.
+    if (max > min && step > max - min) continue;
+    if (everyPositionDiffers(sample, bases, min, max, step)) {
       return { min: min, max: max, step: step };
     }
   }
   var coarsest = candidates[candidates.length - 1];
-  return {
-    min: floorTo(reachDown, coarsest),
-    max: ceilTo(reachUp, coarsest),
-    step: coarsest,
-  };
+  var min = floorTo(reachDown, coarsest);
+  var max = Math.min(ceilTo(reachUp, coarsest), WEIGHT_DELTA_UP_LIMIT);
+  // Nothing kept every position alive: the coarsest step that still fits is the
+  // honest answer, never a step the control cannot reach.
+  var span = max - min;
+  return { min: min, max: max, step: span > 0 ? Math.min(coarsest, span) : 1 };
 }
 
 /**
@@ -1921,7 +1997,9 @@ function buildAxisCss(axis, baseTokens, isDark, hints) {
    * @returns {string} the `font-weight` value.
    */
   function ladderWeight(base) {
-    return "clamp(100,calc(" + base + " + var(--dfp-wdelta,0)),900)";
+    return (
+      "clamp(" + WEIGHT_CSS_MIN + ",calc(" + base + " + var(--dfp-wdelta,0))," + WEIGHT_CSS_MAX + ")"
+    );
   }
   /**
    * The scope the conversation WEIGHT rules hang on: the cheap markdown wrapper
@@ -2079,6 +2157,16 @@ function buildAxisCss(axis, baseTokens, isDark, hints) {
   // ladder below re-states each group's own base PLUS the offset, so the
   // hierarchy survives any offset, in both directions, and `d = 0` injects
   // nothing at all.
+  if (dialogDelta === WEIGHT_UNSET && interfaceDelta !== WEIGHT_UNSET) {
+    // The conversation has NO offset of its own — which is exactly why it has to
+    // say so. The interface axis declares `--dfp-wdelta` on `:root,body`, so an
+    // unset conversation INHERITED it: with the interface at +80 the card showed 0
+    // for the conversation while the page rendered +80, and the first notch above
+    // it only added 20 units — a step nobody can see (measured on 0.1.7-rc.2:
+    // `delta` read 80 at the "0" position and 100 at "+1"). Pinning zero keeps
+    // "0 = leave DSH alone" true no matter what the other axes are set to.
+    declarations.push(weightScopeRule("--dfp-wdelta:0"));
+  }
   if (dialogDelta !== WEIGHT_UNSET) {
     // Every ladder rule reads `--dfp-wdelta`, so the conversation pins it to its
     // own offset: the interface's value must not leak in, and an element inside
@@ -2784,6 +2872,11 @@ var shared = {
   WEIGHT_STEP_CANDIDATES: WEIGHT_STEP_CANDIDATES,
   WEIGHT_DELTA_FLOOR: WEIGHT_DELTA_FLOOR,
   WEIGHT_DELTA_CEIL: WEIGHT_DELTA_CEIL,
+  WEIGHT_LADDER_TOP: WEIGHT_LADDER_TOP,
+  WEIGHT_LADDER_STRONG: WEIGHT_LADDER_STRONG,
+  WEIGHT_DELTA_UP_LIMIT: WEIGHT_DELTA_UP_LIMIT,
+  WEIGHT_CSS_MIN: WEIGHT_CSS_MIN,
+  WEIGHT_CSS_MAX: WEIGHT_CSS_MAX,
   weightProfileFrom: weightProfileFrom,
   weightStepRange: weightStepRange,
   isShorthandName: isShorthandName,

package/package.json

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