dsh-fonttune 0.4.2 → 0.6.0

package/lib/index.js

@@ -247,6 +247,44 @@ export const Config = volatileWhenSupported(z.object({
     .description(
       "Code line-height offset in px (0 keeps DSH's own line heights)"
     ),
+  [shared.LETTER_SPACING_DIALOG_FIELD]: z
+    .number()
+    .min(shared.LETTER_SPACING_MIN)
+    .max(shared.LETTER_SPACING_MAX)
+    .default(0)
+    .description(
+      "Conversation letter-spacing offset in px (0 keeps DSH's own tracking)"
+    ),
+  [shared.WORD_SPACING_DIALOG_FIELD]: z
+    .number()
+    .min(shared.WORD_SPACING_MIN)
+    .max(shared.WORD_SPACING_MAX)
+    .default(0)
+    .description(
+      "Conversation word-spacing offset in px (0 keeps DSH's own word gaps)"
+    ),
+  [shared.PARAGRAPH_SPACING_DIALOG_FIELD]: z
+    .number()
+    .min(shared.PARAGRAPH_SPACING_MIN)
+    .max(shared.PARAGRAPH_SPACING_MAX)
+    .default(0)
+    .description(
+      "Conversation paragraph-gap offset in px, added to DSH's own paragraph spacing (0 keeps it)"
+    ),
+  [shared.INDENT_DIALOG_FIELD]: z
+    .number()
+    .min(shared.INDENT_MIN)
+    .max(shared.INDENT_MAX)
+    .default(0)
+    .description(
+      "Conversation first-line indent in em (0 keeps DSH's own flush-left paragraphs)"
+    ),
+  [shared.LINE_BREAK_STRICT_FIELD]: z
+    .boolean()
+    .default(false)
+    .description(
+      "Strict CJK line breaking in the conversation: keeps punctuation and small kana off the start of a line"
+    ),
   [LIGATURES_FIELD]: z
     .number()
     .min(0)

package/lib/shared.cjs

@@ -309,6 +309,67 @@ var LINE_HEIGHT_MAX = 160;
 var CODE_LINE_HEIGHT_MIN = -4;
 var CODE_LINE_HEIGHT_MAX = 8;
 
+/* ------------------------------------------------------------------ *
+ * conversation text shaping (measured against DSH's own markdown)
+ * ------------------------------------------------------------------ */
+
+/**
+ * Field carrying the letter-spacing offset in px (0 = DSH's own `normal`).
+ * DSH leaves tracking at `normal` on the markdown scope (measured 2026-10-13), so
+ * the offset can be written as an absolute value: 0 emits no rule at all.
+ */
+var LETTER_SPACING_DIALOG_FIELD = "letterSpacingDialog";
+
+/**
+ * Field carrying the word-spacing offset in px (0 = DSH's own `0px`).
+ * Word spacing is measured 0px on the same scope, so it is an absolute value too.
+ */
+var WORD_SPACING_DIALOG_FIELD = "wordSpacingDialog";
+
+/**
+ * Field carrying the paragraph-gap offset in px, added on top of DSH's own 16px.
+ * The paragraphs' margins are NOT zero on the shipped markdown (first 0/16, the
+ * rest 16/16, headings 32/16 — measured 2026-10-13), so this axis is an offset
+ * built on that baseline rather than an absolute value.
+ */
+var PARAGRAPH_SPACING_DIALOG_FIELD = "paragraphSpacingDialog";
+
+/** Field carrying the first-line indent, in em (0 = DSH's own none). */
+var INDENT_DIALOG_FIELD = "indentDialog";
+
+/**
+ * Field asking for strict CJK line breaking (`line-break:strict`) in the
+ * conversation: no small kana, no dash starting a line. DSH leaves `auto`.
+ */
+var LINE_BREAK_STRICT_FIELD = "lineBreakStrict";
+
+/** Letter-spacing offset range, in px, and its notch (measured: 0.1px is visible). */
+var LETTER_SPACING_MIN = -0.4;
+var LETTER_SPACING_MAX = 2.0;
+var LETTER_SPACING_STEP = 0.1;
+
+/** Word-spacing offset range, in px, and its notch. */
+var WORD_SPACING_MIN = -1.0;
+var WORD_SPACING_MAX = 4.0;
+var WORD_SPACING_STEP = 0.2;
+
+/** Paragraph-gap offset range, in px, over DSH's own 16px. */
+var PARAGRAPH_SPACING_MIN = -8;
+var PARAGRAPH_SPACING_MAX = 24;
+var PARAGRAPH_SPACING_STEP = 1;
+
+/** First-line indent range, in em, and its notch. */
+var INDENT_MIN = 0;
+var INDENT_MAX = 4;
+var INDENT_STEP = 0.25;
+
+/**
+ * The paragraph gap DSH's own markdown ships, in px. Measured on the conversation
+ * scope (2026-10-13): paragraphs carry 16px top/bottom margins, so that is the
+ * baseline every offset is added to.
+ */
+var PARAGRAPH_BASELINE_PX = 16;
+
 /** Ligature modes. */
 var LIGATURES_DEFAULT = 0;
 var LIGATURES_ON = 1;
@@ -334,6 +395,11 @@ var DEFAULTS = {
   lineHeight: LINE_HEIGHT_MIN,
   lineHeightDialog: LINE_HEIGHT_MIN,
   lineHeightCode: 0,
+  letterSpacingDialog: 0,
+  wordSpacingDialog: 0,
+  paragraphSpacingDialog: 0,
+  indentDialog: 0,
+  lineBreakStrict: false,
   codeLigatures: LIGATURES_DEFAULT,
   codeFeatures: "",
   noSyntheticItalic: false,
@@ -365,6 +431,11 @@ var VALUE_FIELDS = [
   CODE_WEIGHT_FIELD,
   LINE_HEIGHT_DIALOG_FIELD,
   CODE_LINE_HEIGHT_FIELD,
+  LETTER_SPACING_DIALOG_FIELD,
+  WORD_SPACING_DIALOG_FIELD,
+  PARAGRAPH_SPACING_DIALOG_FIELD,
+  INDENT_DIALOG_FIELD,
+  LINE_BREAK_STRICT_FIELD,
   LIGATURES_FIELD,
   FEATURES_FIELD,
   NO_SYNTHETIC_ITALIC_FIELD,
@@ -1507,6 +1578,16 @@ function normalizeField(field, value, relative) {
       return clampRatio(value);
     case CODE_LINE_HEIGHT_FIELD:
       return clampLineOffset(value);
+    case LETTER_SPACING_DIALOG_FIELD:
+      return clampSpacing(value, LETTER_SPACING_MIN, LETTER_SPACING_MAX);
+    case WORD_SPACING_DIALOG_FIELD:
+      return clampSpacing(value, WORD_SPACING_MIN, WORD_SPACING_MAX);
+    case PARAGRAPH_SPACING_DIALOG_FIELD:
+      return clampSpacing(value, PARAGRAPH_SPACING_MIN, PARAGRAPH_SPACING_MAX);
+    case INDENT_DIALOG_FIELD:
+      return clampIndent(value);
+    case LINE_BREAK_STRICT_FIELD:
+      return toBool(value);
     case LIGATURES_FIELD:
       return clampLigatures(value);
     case WEIGHT_OFFSETS_FIELD:
@@ -1590,6 +1671,52 @@ function clampWeight(value) {
   return Math.min(WEIGHT_MAX, Math.max(WEIGHT_MIN, weight));
 }
 
+/**
+ * Clamp one spacing offset (letter, word) to its allowed range, in px.
+ *
+ * These axes sit on top of a DSH default that is already zero (`normal` / `0px`,
+ * measured on the conversation scope), so no migration and no baseline is involved:
+ * the offset is written as it stands, and 0 means "emit nothing".
+ * @param {unknown} value - candidate offset.
+ * @param {number} min - the lowest allowed offset.
+ * @param {number} max - the highest allowed offset.
+ * @returns {number} the offset the stylesheet may use.
+ */
+function clampSpacing(value, min, max) {
+  var offset = Number(value);
+  if (!isFinite(offset)) return 0;
+  // Rounded to two decimals: the notches are tenths, and the sum of a few of them
+  // must not turn into 0.30000000000000004 in the emitted CSS.
+  offset = Math.round(offset * 100) / 100;
+  if (offset > max) return max;
+  if (offset < min) return min;
+  return offset;
+}
+
+/**
+ * Clamp the first-line indent to its allowed range, in em.
+ * @param {unknown} value - candidate indent.
+ * @returns {number} the indent the stylesheet may use.
+ */
+function clampIndent(value) {
+  var indent = Number(value);
+  if (!isFinite(indent)) return 0;
+  indent = Math.round(indent * 100) / 100;
+  if (indent > INDENT_MAX) return INDENT_MAX;
+  if (indent < INDENT_MIN) return INDENT_MIN;
+  return indent;
+}
+
+/**
+ * Format a spacing value for CSS, without scientific notation or float noise.
+ * @param {number} value - a clamped px value.
+ * @returns {string} the value as a px length.
+ */
+function pxText(value) {
+  var rounded = Math.round(value * 100) / 100;
+  return String(rounded) + "px";
+}
+
 /**
  * Clamp one RELATIVE weight to its allowed range, migrating an absolute value.
  *
@@ -2329,6 +2456,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 +3317,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.
@@ -3232,6 +3554,11 @@ function isDormant(config) {
     clampWeightDelta(axis[CODE_WEIGHT_FIELD], true) === WEIGHT_UNSET &&
     clampRatio(axis[LINE_HEIGHT_DIALOG_FIELD]) === LINE_HEIGHT_MIN &&
     clampLineOffset(axis[CODE_LINE_HEIGHT_FIELD]) === 0 &&
+    clampSpacing(axis[LETTER_SPACING_DIALOG_FIELD], LETTER_SPACING_MIN, LETTER_SPACING_MAX) === 0 &&
+    clampSpacing(axis[WORD_SPACING_DIALOG_FIELD], WORD_SPACING_MIN, WORD_SPACING_MAX) === 0 &&
+    clampSpacing(axis[PARAGRAPH_SPACING_DIALOG_FIELD], PARAGRAPH_SPACING_MIN, PARAGRAPH_SPACING_MAX) === 0 &&
+    clampIndent(axis[INDENT_DIALOG_FIELD]) === 0 &&
+    toBool(axis[LINE_BREAK_STRICT_FIELD]) === false &&
     clampLigatures(axis[LIGATURES_FIELD]) === LIGATURES_DEFAULT &&
     sanitizeFeatures(axis[FEATURES_FIELD]) === "" &&
     toBool(axis[NO_SYNTHETIC_ITALIC_FIELD]) === false &&
@@ -3256,10 +3583,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
@@ -3613,6 +3942,60 @@ function buildAxisCss(axis, baseTokens, isDark, hints) {
     }
   }
 
+  // ---- conversation text shaping (tracking, word gap, paragraph gap, indent) ----
+  //
+  // Every value here is written on the CONVERSATION scope, and the measurements that
+  // fixed the shape were taken there (2026-10-13): the markdown's tracking is `normal`
+  // and its word gap `0px`, so those two axes are absolute and 0 emits nothing; the
+  // paragraphs carry 16px margins, so the paragraph axis is an offset over that
+  // baseline. Code surfaces are excluded by the same scope rule the weight ladder uses,
+  // so a code block's own tracking is never rewritten by a conversation axis.
+  var letterSpacing = clampSpacing(axis[LETTER_SPACING_DIALOG_FIELD], LETTER_SPACING_MIN, LETTER_SPACING_MAX);
+  var wordSpacing = clampSpacing(axis[WORD_SPACING_DIALOG_FIELD], WORD_SPACING_MIN, WORD_SPACING_MAX);
+  var paragraphSpacing = clampSpacing(
+    axis[PARAGRAPH_SPACING_DIALOG_FIELD],
+    PARAGRAPH_SPACING_MIN,
+    PARAGRAPH_SPACING_MAX
+  );
+  var indent = clampIndent(axis[INDENT_DIALOG_FIELD]);
+  if (letterSpacing !== 0) {
+    declarations.push(weightScopeRule("letter-spacing:" + pxText(letterSpacing) + " !important"));
+  }
+  if (wordSpacing !== 0) {
+    declarations.push(weightScopeRule("word-spacing:" + pxText(wordSpacing) + " !important"));
+  }
+  if (indent !== 0) {
+    // A first-line indent is a PROSE convention, so it belongs to paragraphs. Emitted for
+    // the whole conversation scope it inherited into every block under it; each of these
+    // was measured on the page with the axis at 2em (32px on a 16px base):
+    //   - a heading sat 32px in, where no Chinese reader expects one;
+    //   - an ordered-list item's TEXT moved 32px while the number stayed at the content
+    //     edge (the marker sits outside the content box), so the number ended up in front
+    //     of the indent the text had taken;
+    //   - inline code is `display: inline-flex` in DSH's markdown — a block container of
+    //     its own — so the indent landed INSIDE the chip as blank space before its own
+    //     text, wherever the chip sat in the line;
+    //   - a code block's first line shifted the same way.
+    // Paragraphs are the only place the convention exists, and their descendants are
+    // zeroed so a chip that happens to be its own block still draws flush.
+    var indentDeclarations = "text-indent:" + String(indent) + "em !important";
+    declarations.push(weightScopeRule("p{" + indentDeclarations + "}"));
+    declarations.push(weightScopeRule("p *{text-indent:0 !important}"));
+  }
+  if (paragraphSpacing !== 0) {
+    // Both margins move together: adjacent siblings collapse to the LARGER of the two,
+    // so shifting only `margin-top` would silently ignore every negative offset.
+    var gap =
+      paragraphSpacing > 0
+        ? "calc(" + PARAGRAPH_BASELINE_PX + "px + " + pxText(paragraphSpacing) + ")"
+        : "calc(" + PARAGRAPH_BASELINE_PX + "px - " + pxText(-paragraphSpacing) + ")";
+    declarations.push(weightScopeRule("p{margin-bottom:" + gap + " !important}"));
+    declarations.push(weightScopeRule("p:not(:first-child){margin-top:" + gap + " !important}"));
+  }
+  if (toBool(axis[LINE_BREAK_STRICT_FIELD])) {
+    declarations.push(weightScopeRule("line-break:strict !important"));
+  }
+
   // ---- code axes ----
   var codeSize = axis[CODE_SIZE_FIELD];
   var codeLine = axis[CODE_LINE_HEIGHT_FIELD];
@@ -3659,7 +4042,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 +4155,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 +4163,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"));
 }
 
 /**
@@ -4213,6 +4617,24 @@ var shared = {
   LINE_HEIGHT_MAX: LINE_HEIGHT_MAX,
   CODE_LINE_HEIGHT_MIN: CODE_LINE_HEIGHT_MIN,
   CODE_LINE_HEIGHT_MAX: CODE_LINE_HEIGHT_MAX,
+  LETTER_SPACING_DIALOG_FIELD: LETTER_SPACING_DIALOG_FIELD,
+  WORD_SPACING_DIALOG_FIELD: WORD_SPACING_DIALOG_FIELD,
+  PARAGRAPH_SPACING_DIALOG_FIELD: PARAGRAPH_SPACING_DIALOG_FIELD,
+  INDENT_DIALOG_FIELD: INDENT_DIALOG_FIELD,
+  LINE_BREAK_STRICT_FIELD: LINE_BREAK_STRICT_FIELD,
+  LETTER_SPACING_MIN: LETTER_SPACING_MIN,
+  LETTER_SPACING_MAX: LETTER_SPACING_MAX,
+  LETTER_SPACING_STEP: LETTER_SPACING_STEP,
+  WORD_SPACING_MIN: WORD_SPACING_MIN,
+  WORD_SPACING_MAX: WORD_SPACING_MAX,
+  WORD_SPACING_STEP: WORD_SPACING_STEP,
+  PARAGRAPH_SPACING_MIN: PARAGRAPH_SPACING_MIN,
+  PARAGRAPH_SPACING_MAX: PARAGRAPH_SPACING_MAX,
+  PARAGRAPH_SPACING_STEP: PARAGRAPH_SPACING_STEP,
+  INDENT_MIN: INDENT_MIN,
+  INDENT_MAX: INDENT_MAX,
+  INDENT_STEP: INDENT_STEP,
+  PARAGRAPH_BASELINE_PX: PARAGRAPH_BASELINE_PX,
   LIGATURES_DEFAULT: LIGATURES_DEFAULT,
   SMOOTHING_FIELD: SMOOTHING_FIELD,
   SMOOTHING_AUTO: SMOOTHING_AUTO,
@@ -4290,6 +4712,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/locale/en.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "Font tune (dsh-fonttune)",
-    "description": "Interface and conversation fonts, a size, a weight and a line height for each, code extras and presets"
+    "description": "Interface and conversation fonts, size, weight and line height, CJK type shaping (tracking, paragraph gaps, first-line indent), code extras and presets"
   }
 }

package/locale/zh.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "字体增强（dsh-fonttune）",
-    "description": "界面与对话字体、各自的字号/字重/行高，代码增强与预设方案"
+    "description": "界面与对话字体、字号/字重/行高，字距/段距/首行缩进等中文排印，代码增强与预设方案"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-fonttune",
-  "version": "0.4.2",
+  "version": "0.6.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",
@@ -18,7 +18,9 @@
     "README.en.md",
     "CHANGELOG.md",
     "CHANGELOG.en.md",
-    "LICENSE"
+    "LICENSE",
+    "docs/panel.jpg",
+    "docs/card-shaping.jpg"
   ],
   "engines": {
     "dsh": ">=0.1.7-alpha.1 <0.3.0-0"