dsh-fonttune 0.7.4 → 0.7.6

package/CHANGELOG.en.md

@@ -2,6 +2,16 @@
 
 All notable changes to **dsh-fonttune** are documented here. Chinese version: [CHANGELOG.md](CHANGELOG.md).
 
+## [0.7.6] - 2026-11-04
+
+### Fixed
+- **The plugin did not actually load on some hosts**: the Font tune settings card and the first-frame type stylesheet were missing while the conversation still looked completely normal, so it was easy to miss; the plugin now waits for its dependency to finish loading before it registers, and no longer starts half-loaded.
+
+## [0.7.5] - 2026-11-01
+
+### Fixed
+- **The floating dot covered the composer in a new session**: before conversation text appeared, the dot could remain over the input area; it now moves to the lower-left of the main content area, clear of both the composer and the sidebar.
+
 ## [0.7.4] - 2026-10-30
 
 ### Fixed

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 **dsh-fonttune** 的重要变更都记录在这里。英文版见 [CHANGELOG.en.md](CHANGELOG.en.md)。
 
+## [0.7.6] - 2026-11-04
+
+### 修复
+- **部分环境下插件启动后没有真正加载**：字体增强的设置卡片与首帧字体样式会缺失，而对话外观看起来一切正常，所以很难发现；现在启动时会等依赖就绪再注册，不再出现这种「看着正常、其实没加载」的状态。
+
+## [0.7.5] - 2026-11-01
+
+### 修复
+- **新会话中的悬浮圆点遮挡输入框**：对话正文尚未出现时，圆点可能停在输入框内；现在会将这类位置移至主内容区左下角，避开输入框与侧栏。
+
 ## [0.7.4] - 2026-10-30
 
 ### 修复

package/lib/client.js

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

package/lib/index.js

@@ -22,7 +22,7 @@
  */
 import { createRequire } from "node:module";
 import { dirname, sep } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 // Default import, not named: `shared.cjs` is a CommonJS module, and Node's
 // CJS-to-ESM interop only guarantees `module.exports` as the default binding
 // (statically-detected named exports would break this half at boot).
@@ -47,26 +47,73 @@ import shared from "./shared.cjs";
  * entry (its `node_modules` holds the authoritative copy); anything resolving
  * back inside THIS package is skipped, so the offline suites — which have no
  * host — still fall through to the devDependency.
- * @returns {object} the schemastery export.
+ *
+ * RESOLVE with `require`, LOAD with the ESM loader. The package resolves to its
+ * CommonJS build, and that build `require`s `@deepseek-ai/cosmokit`, which ships
+ * as ES module only. Requiring it while the host is still loading that same
+ * module graph throws `ERR_REQUIRE_ESM_RACE_CONDITION` — "Cannot require() ES
+ * Module … because it is not yet fully loaded" — and then the whole host half
+ * fails to import: no settings namespace, no first-frame stylesheet, while the
+ * browser half keeps working and hides the damage (issue #7, reproduced here).
+ * `import()` waits for the graph instead of racing it, and it lands on the same
+ * instance: a `.cjs` file loaded through the ESM loader goes through the
+ * CommonJS cache, so the host's copy is still the only copy.
+ * @returns {Promise<object>} the schemastery export.
  */
-function loadSchemastery() {
+async function loadSchemastery() {
   const own = dirname(dirname(fileURLToPath(import.meta.url))) + sep;
   const bases = [process.argv[1], fileURLToPath(import.meta.url)];
   for (const base of bases) {
     if (typeof base !== "string" || base === "") continue;
-    try {
-      const from = createRequire(base);
-      if (!from.resolve("@deepseek-ai/schemastery").startsWith(own)) {
-        return from("@deepseek-ai/schemastery");
-      }
-    } catch {
-      // Not resolvable from that anchor: try the next one.
-    }
+    const resolved = resolveSchemastery(createRequire(base), own);
+    if (resolved !== null) return importSchemastery(resolved);
+  }
+  // Nothing outside this package offers it (the offline suites have no host), so
+  // the devDependency is the answer — still loaded through the ESM loader.
+  const fallback = resolveSchemastery(createRequire(import.meta.url), "");
+  if (fallback === null) {
+    throw new Error("@deepseek-ai/schemastery is not resolvable from the host or this package");
+  }
+  return importSchemastery(fallback);
+}
+
+/**
+ * Locate the schema library from one anchor WITHOUT loading it.
+ *
+ * Only the resolution is anchored to the host: `createRequire(base).resolve()`
+ * answers "which file would the host use", while nothing is executed. An answer
+ * that points back inside this package is refused, so a linked install cannot
+ * shadow the host's copy with this package's devDependency.
+ * @param {NodeRequire} from - the resolver anchored at the host entry.
+ * @param {string} own - this package's directory prefix, "" to accept anything.
+ * @returns {string|null} the file to load, or null when this anchor cannot offer it.
+ */
+function resolveSchemastery(from, own) {
+  try {
+    const resolved = from.resolve("@deepseek-ai/schemastery");
+    if (typeof resolved !== "string" || resolved === "") return null;
+    if (own !== "" && resolved.startsWith(own)) return null;
+    return resolved;
+  } catch {
+    // Not resolvable from that anchor (or has no `require` entry): try the next.
+    return null;
   }
-  return createRequire(import.meta.url)("@deepseek-ai/schemastery");
 }
 
-const z = loadSchemastery();
+/**
+ * Load one resolved file through the ESM loader.
+ *
+ * A CommonJS build arrives as its `default` binding, which is the module's own
+ * `module.exports`; a build that is already ESM answers with itself.
+ * @param {string} resolved - an absolute path, from `resolveSchemastery`.
+ * @returns {Promise<object>} the schemastery export.
+ */
+async function importSchemastery(resolved) {
+  const loaded = await import(pathToFileURL(resolved).href);
+  return loaded.default ?? loaded;
+}
+
+const z = await loadSchemastery();
 
 const {
   buildFontCss,

package/lib/shared.cjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-fonttune",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "description": "Font plugin for the DeepSeek Harness Web GUI: the conversation gets its own font, size, line height and weight, the interface font and weight follow it, code keeps its own axis with ligature control, and whole setups save as presets.",
   "type": "module",
   "icon": "icon.svg",