dsh-fonttune 0.2.2 → 0.2.4

package/lib/shared.cjs

@@ -152,9 +152,6 @@ var LIGATURES_DEFAULT = 0;
 var LIGATURES_ON = 1;
 var LIGATURES_OFF = 2;
 
-/** Marker on both injected style tags, used for scoping every rule we write. */
-var MARKER = "dfp";
-
 /** `data-plugin-css` value of the tag applying the configuration. */
 var STYLE_TAG = "dsh-fonttune";
 
@@ -187,20 +184,18 @@ var DEFAULTS = {
 };
 
 /**
- * The axis fields a preset snapshots: everything the card edits, excluding
- * the storage fields themselves.
+ * The axis fields a preset snapshots and the light/dark sets are compared
+ * over: everything the card edits, excluding the storage fields themselves.
  */
 var VALUE_FIELDS = [
   SANS_FIELD,
   STACK_DIALOG_FIELD,
   MONO_FIELD,
-  SIZE_FIELD,
   SIZE_DIALOG_FIELD,
   CODE_SIZE_FIELD,
   WEIGHT_FIELD,
   WEIGHT_DIALOG_FIELD,
   CODE_WEIGHT_FIELD,
-  LINE_HEIGHT_FIELD,
   LINE_HEIGHT_DIALOG_FIELD,
   CODE_LINE_HEIGHT_FIELD,
   LIGATURES_FIELD,
@@ -210,6 +205,25 @@ var VALUE_FIELDS = [
   UI_FOLLOWS_FIELD,
 ];
 
+/**
+ * Axes that are still stored but no longer render: the interface's own size
+ * and line-height.
+ *
+ * DSH 0.1.5-rc.2 publishes no interface size or line-height hook at all (the
+ * measurement lives in `buildAxisCss`), so these two fields inject nothing.
+ * A document written by 0.1.x still carries them, so they keep their schema
+ * entries and stay part of normalization — but they are not value axes: a
+ * preset no longer snapshots a dead field, and a light/dark pair that differs
+ * only here no longer counts as two sets. The card's "reset every axis" clears
+ * them too, so a value nothing shows cannot hide in a document forever.
+ */
+var RETIRED_FIELDS = [SIZE_FIELD, LINE_HEIGHT_FIELD];
+
+/**
+ * Every durable axis field, live and retired: what normalization covers.
+ */
+var DURABLE_FIELDS = VALUE_FIELDS.concat(RETIRED_FIELDS);
+
 /**
  * Longest accepted font stack, in characters (mirrored by the host schema).
  */
@@ -372,8 +386,8 @@ function normalizeField(field, value) {
 function normalizeConfig(value) {
   var source = value !== null && typeof value === "object" ? value : {};
   var config = {};
-  for (var index = 0; index < VALUE_FIELDS.length; index += 1) {
-    var field = VALUE_FIELDS[index];
+  for (var index = 0; index < DURABLE_FIELDS.length; index += 1) {
+    var field = DURABLE_FIELDS[index];
     config[field] = normalizeField(field, source[field]);
   }
   config[PER_THEME_FIELD] = toBool(source[PER_THEME_FIELD]);
@@ -1023,17 +1037,6 @@ function isShorthandName(name) {
   return true;
 }
 
-/**
- * Whether one token (name + value) is a `font` shorthand this plugin may
- * rewrite: a bare `--dsw-font-…` name whose value parses as a shorthand.
- * @param {string} name - custom property name.
- * @param {string} value - the token's untouched value.
- * @returns {boolean}
- */
-function isShorthandToken(name, value) {
-  return isShorthandName(name) && parseShorthand(value) !== null;
-}
-
 /**
  * Whether a token is one this plugin reads and re-declares at all.
  * @param {string} name - custom property name including the leading dashes.
@@ -1062,35 +1065,6 @@ function tokenNames(baseTokens) {
   return names;
 }
 
-/**
- * The interface PART size tokens: everything scalable except the code and
- * markdown families and the delta tokens (which the dialog offset shifts
- * additively, never multiplicatively).
- * @param {Record<string, string>} [baseTokens] - token name to value.
- * @returns {string[]} the names the interface offset re-declares.
- */
-function bodyTokenNames(baseTokens) {
-  return tokenNames(baseTokens).filter(function (name) {
-    return (
-      !isCodeToken(name) &&
-      !isMarkdownToken(name) &&
-      !isDeltaToken(name) &&
-      !isContentToken(name)
-    );
-  });
-}
-
-/**
- * The interface line-height PART tokens (non-code, non-markdown).
- * @param {Record<string, string>} [baseTokens] - token name to value.
- * @returns {string[]}
- */
-function uiLineTokenNames(baseTokens) {
-  return bodyTokenNames(baseTokens).filter(function (name) {
-    return name.indexOf("-line-height") >= 0;
-  });
-}
-
 /**
  * The markdown (dialog) PART tokens: sizes and line heights of the markdown
  * family, excluding code.
@@ -1101,30 +1075,6 @@ function markdownTokenNames(baseTokens) {
   return tokenNames(baseTokens).filter(isMarkdownToken);
 }
 
-/**
- * The markdown content-size DELTA tokens present in a base map.
- * @param {Record<string, string>} [baseTokens] - token name to value.
- * @returns {string[]}
- */
-function deltaTokenNames(baseTokens) {
-  if (baseTokens === null || typeof baseTokens !== "object") return [];
-  return Object.keys(baseTokens).filter(isDeltaToken);
-}
-
-/**
- * The code PART tokens: the `font` shorthands' size/height parts, when the
- * live stylesheets declare them. The shorthands themselves are handled by
- * `codeShorthandTokens`, so they are excluded here to avoid double
- * declarations.
- * @param {Record<string, string>} [baseTokens] - token name to value.
- * @returns {string[]}
- */
-function codeTokenNames(baseTokens) {
-  return tokenNames(baseTokens).filter(function (name) {
-    return isCodeToken(name) && !isShorthandName(name);
-  });
-}
-
 /**
  * Every `font` shorthand token in a base map that parses, sorted by name
  * length (families before variants, mirroring the part-token order).
@@ -1157,17 +1107,6 @@ function markdownShorthandTokens(baseTokens) {
   });
 }
 
-/**
- * The interface (non-markdown, non-code) `font` shorthand tokens.
- * @param {Record<string, string>} [baseTokens] - token name to value.
- * @returns {{name: string, parts: object}[]}
- */
-function uiShorthandTokens(baseTokens) {
-  return shorthandTokens(baseTokens).filter(function (entry) {
-    return !isMarkdownToken(entry.name) && !isCodeToken(entry.name);
-  });
-}
-
 /**
  * The code `font` shorthand tokens.
  * @param {Record<string, string>} [baseTokens] - token name to value.
@@ -1183,6 +1122,66 @@ function codeShorthandTokens(baseTokens) {
  * selectors
  * ------------------------------------------------------------------ */
 
+/**
+ * Build one exclusion that keeps a surface out of a rule.
+ *
+ * The whole list goes into a single `:not(…)`. The long form —
+ * `:not(pre):not(pre *)…` — repeats `:not(` and `)` per argument, and that
+ * chain is copied into both dialog alternatives and the interface rule, so the
+ * compact form saves roughly 120 bytes per copy.
+ *
+ * The trade is specificity: `:not(a):not(b)` SUMS its arguments while
+ * `:not(a, b)` takes the most specific one. Nothing here depends on that sum.
+ * Every rule below carries `!important`, which already beats the theme's
+ * non-important class rules whatever the specificity; the shipped DSH 0.1.5
+ * assets hold exactly one `!important` typography declaration
+ * (`font-size` on inline markdown code, and no size declaration is ever
+ * emitted from here); and the rules that could collide with each other are
+ * held apart by these very exclusions rather than by their weight. Verified
+ * against the shipped bundle and every installed plugin: no other
+ * `!important` `font-weight`/`font-family` rule exists to lose to.
+ *
+ * @param {string[]} selectors - the selectors to exclude.
+ * @returns {string} one `:not(…)` carrying the whole list.
+ */
+function excludeAll(selectors) {
+  return ":not(" + selectors.join(",") + ")";
+}
+
+/**
+ * A code surface, and its descendants: a highlight `<span>` inside a `<pre>`
+ * is not a `pre`, so an exclusion has to reach through ancestry.
+ */
+var CODE_SURFACE_SELECTORS = [
+  "pre",
+  "pre *",
+  "code",
+  "code *",
+  "kbd",
+  "kbd *",
+  "samp",
+  "samp *",
+  "var",
+  "var *",
+  "tt",
+  "tt *",
+  "textarea",
+  "textarea *",
+  '[class*="code" i]',
+  '[class*="code" i] *',
+  '[class*="terminal" i]',
+  '[class*="terminal" i] *',
+];
+
+/**
+ * Everything a code surface must be excluded from a DIALOG-scoped rule: the
+ * code elements themselves AND their descendants (a highlight `<span>` inside
+ * a `<pre>` is not a `pre`, so the exclusion has to reach through ancestry
+ * with a complex `:not()` argument — supported by the Chromium line DSH
+ * targets).
+ */
+var CODE_EXCLUDES = excludeAll(CODE_SURFACE_SELECTORS);
+
 /**
  * What counts as code text for the code axes.
  *
@@ -1221,38 +1220,6 @@ var CODE_SELECTOR = [
   })
   .join(",");
 
-/**
- * Everything a code surface must be excluded from a DIALOG-scoped rule:
- * the code elements themselves AND their descendants (a highlight `<span>`
- * inside a `<pre>` is not a `pre`, so the exclusion has to reach through
- * ancestry with complex `:not()` arguments — supported by the Chromium line
- * DSH targets).
- */
-var CODE_EXCLUDES = [
-  "pre",
-  "pre *",
-  "code",
-  "code *",
-  "kbd",
-  "kbd *",
-  "samp",
-  "samp *",
-  "var",
-  "var *",
-  "tt",
-  "tt *",
-  "textarea",
-  "textarea *",
-  '[class*="code" i]',
-  '[class*="code" i] *',
-  '[class*="terminal" i]',
-  '[class*="terminal" i] *',
-]
-  .map(function (selector) {
-    return ":not(" + selector + ")";
-  })
-  .join("");
-
 /**
  * The dialog surface: DSH renders the conversation markdown in a CSS-module
  * container whose class hashes per release (`_markdown_<hash>_…`). A
@@ -1284,11 +1251,57 @@ var DARK_ATTR = "body[data-ds-dark-theme]";
  * interface's own preview stays inside the rule, and `dfp-previewCode` is a
  * code surface like any other.
  */
-var INTERFACE_EXCLUDES =
-  CODE_EXCLUDES +
-  ":not(.cm-editor):not(.cm-editor *):not(.dfp-previewCode):not(.dfp-previewCode *)" +
-  ':not([class*="_markdown_" i]):not([class*="_markdown_" i] *)' +
-  ":not(.dfp-previewDialog):not(.dfp-previewDialog *)";
+var INTERFACE_EXCLUDES = excludeAll(
+  CODE_SURFACE_SELECTORS.concat([
+    ".cm-editor",
+    ".cm-editor *",
+    ".dfp-previewCode",
+    ".dfp-previewCode *",
+    '[class*="_markdown_" i]',
+    '[class*="_markdown_" i] *',
+    ".dfp-previewDialog",
+    ".dfp-previewDialog *",
+  ])
+);
+
+/**
+ * Split a selector list on its top-level commas only.
+ *
+ * The exclusions hold a selector LIST inside `:not(…)`, so a plain
+ * `split(",")` would cut a selector in half — and the per-theme rules prefix
+ * every selector in the list.
+ * @param {string} selectorList - a comma-separated selector list.
+ * @returns {string[]} the top-level parts, verbatim.
+ */
+function splitSelectorList(selectorList) {
+  var parts = [];
+  var current = "";
+  var depth = 0;
+  var quote = "";
+  for (var index = 0; index < selectorList.length; index += 1) {
+    var character = selectorList[index];
+    if (quote !== "") {
+      current += character;
+      if (character === quote) quote = "";
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      current += character;
+      continue;
+    }
+    if (character === "(" || character === "[") depth += 1;
+    if (character === ")" || character === "]") depth -= 1;
+    if (character === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += character;
+  }
+  parts.push(current);
+  return parts;
+}
 
 /**
  * Prefix every selector in a comma list, for the per-theme rules.
@@ -1297,7 +1310,7 @@ var INTERFACE_EXCLUDES =
  * @returns {string} the prefixed list.
  */
 function prefixSelector(selectorList, prefix) {
-  var parts = selectorList.split(",");
+  var parts = splitSelectorList(selectorList);
   var out = [];
   for (var index = 0; index < parts.length; index += 1) {
     out.push(prefix + " " + parts[index]);
@@ -1459,9 +1472,13 @@ function buildAxisCss(axis, baseTokens, isDark) {
    */
   function pushScopedCodeFamily() {
     var scopedCode = [];
-    var surfaces = CODE_SELECTOR.split(",");
+    var surfaces = splitSelectorList(CODE_SELECTOR);
     for (var cIndex = 0; cIndex < surfaces.length; cIndex += 1) {
-      scopedCode.push('[class*="_markdown_" i] ' + surfaces[cIndex]);
+      var scoped = '[class*="_markdown_" i] ' + surfaces[cIndex];
+      // The dark variant has to carry the theme attribute like every other
+      // rule here, or a per-theme set would re-assert the LIGHT code family
+      // inside the dark dialog.
+      scopedCode.push(isDark ? DARK_ATTR + " " + scoped : scoped);
     }
     declarations.push(scopedCode.join(",") + "{font-family:" + mono + " !important}");
   }
@@ -1558,8 +1575,8 @@ function buildAxisCss(axis, baseTokens, isDark) {
   // (secondary size, both deltas, delta-based heading sizes, heights) at their
   // body-computed values. The offset is therefore added once, at the source —
   // `--dsh-content-font-size` becomes "official base + offset" — and the whole
-  // ladder follows by derivation, with nothing counted twice. The interface
-  // axis never touches this chain (see `bodyTokenNames`), so the conversation
+  // ladder follows by derivation, with nothing counted twice. The retired
+  // interface size axis never touches this chain at all, so the conversation
   // moves only when this axis says so, and a dialog that FOLLOWS the interface
   // follows it through this value.
   var dialogOffsetValue = axis[SIZE_DIALOG_FIELD];
@@ -1971,18 +1988,137 @@ var PRESETS = {
 };
 
 /**
- * Legacy single-purpose helper kept for compatibility: scale the size and the
- * height inside one simple `size/height <family>` shorthand.
- * @param {string} value - a value shaped like `11px/19px var(--ds-font-family-code)`.
- * @param {number} scale - the ratio to apply.
- * @returns {string|null} the scaled shorthand, or null when the shape differs.
+ * The curated groups, in the order the picker lists them.
  */
-function scaleFontShorthand(value, scale) {
-  var parts = parseShorthand(value);
-  if (parts === null || parts.lead !== "") return null;
-  return (
-    "calc((" + parts.size + ") * " + scale + ")/calc((" + parts.height + ") * " + scale + ") " + parts.family
-  );
+var PRESET_GROUPS = [
+  { label: "stack.groupMono", families: PRESETS.mono },
+  { label: "stack.groupCjk", families: PRESETS.cjk },
+  { label: "stack.groupLatin", families: PRESETS.latin },
+  { label: "stack.groupGeneric", families: PRESETS.generic },
+];
+
+/**
+ * How many enumerated families the "installed on this machine" group shows.
+ * The curated groups are the short list; this one is the complete one, so the
+ * cap is only a guard against a machine with an absurd number of families.
+ */
+var MAX_LOCAL_FONTS = 240;
+
+/**
+ * Build the family picker's groups.
+ *
+ * The curated groups are ALWAYS listed: whether or not the browser enumerated
+ * local fonts, and whether or not a search is running. The old shape skipped
+ * them whenever a working catalog met a non-empty query, so a curated family
+ * this machine has not installed could not be found by name at all. Every
+ * family is listed in exactly one group — the local enumeration gives way to
+ * the curated headings rather than repeating what they already offer.
+ *
+ * @param {object} input - the picker's state.
+ * @param {string[]} [input.stack] - the families the stored value names.
+ * @param {boolean} [input.single] - single-pick mode (a West/CJK slot).
+ * @param {string} [input.query] - the search text.
+ * @param {{status: string, families: string[]}} [input.catalog] - enumeration.
+ * @param {number} [input.maxLocal] - cap on the local group's rows.
+ * @returns {Array<{label: string, families: string[]}>} the groups, in the
+ *   order the picker displays them.
+ */
+function pickerGroups(input) {
+  var stack = Array.isArray(input.stack) ? input.stack : [];
+  var single = input.single === true;
+  var query = typeof input.query === "string" ? input.query : "";
+  var catalog =
+    input.catalog && typeof input.catalog === "object"
+      ? input.catalog
+      : { status: "loading", families: [] };
+  var maxLocal = typeof input.maxLocal === "number" ? input.maxLocal : MAX_LOCAL_FONTS;
+  var needle = query.trim().toLowerCase();
+  var index;
+  var matches = function (name) {
+    return needle === "" || String(name).toLowerCase().indexOf(needle) >= 0;
+  };
+
+  // Which families the stack already names. In single mode the stack IS the
+  // one pick, and it stays visible in the curated groups (with its check mark)
+  // so the reader can see where it sits among its own kind.
+  var inStack = {};
+  if (!single) {
+    for (index = 0; index < stack.length; index += 1) {
+      inStack[String(stack[index]).toLowerCase()] = true;
+    }
+  }
+
+  // The curated groups are built FIRST, and the local list gives way to them:
+  // they are the short list the reader scans, and on a real Windows machine
+  // most of the Latin group is installed, so letting the local list win would
+  // empty the curated headings. Everything lands in exactly one group.
+  var curatedLower = {};
+  var curatedGroups = [];
+  for (index = 0; index < PRESET_GROUPS.length; index += 1) {
+    var curated = PRESET_GROUPS[index];
+    var rows = [];
+    for (var nameIndex = 0; nameIndex < curated.families.length; nameIndex += 1) {
+      var name = sanitizeFamily(curated.families[nameIndex]);
+      if (name === "" || !matches(name)) continue;
+      var key = name.toLowerCase();
+      if (inStack[key] === true || curatedLower[key] === true) continue;
+      curatedLower[key] = true;
+      rows.push(name);
+    }
+    if (rows.length > 0) curatedGroups.push({ label: curated.label, families: rows });
+  }
+
+  // Then the enumeration: the complete list, minus everything already offered
+  // by a heading above it.
+  var localRows = [];
+  if (catalog.status === "ready") {
+    var locals = Array.isArray(catalog.families) ? catalog.families : [];
+    for (index = 0; index < locals.length; index += 1) {
+      var localName = sanitizeFamily(locals[index]);
+      if (localName === "" || !matches(localName)) continue;
+      var localKey = localName.toLowerCase();
+      if (inStack[localKey] === true || curatedLower[localKey] === true) continue;
+      curatedLower[localKey] = true;
+      localRows.push(localName);
+      if (localRows.length >= maxLocal) break;
+    }
+  }
+
+  var groups = [];
+  var selectedRows = [];
+  for (index = 0; index < stack.length; index += 1) {
+    if (matches(stack[index])) selectedRows.push(stack[index]);
+  }
+  if (selectedRows.length > 0) {
+    groups.push({ label: "stack.groupSelected", families: selectedRows });
+  }
+  for (index = 0; index < curatedGroups.length; index += 1) {
+    groups.push(curatedGroups[index]);
+  }
+  if (localRows.length > 0) {
+    groups.push({ label: "stack.groupLocal", families: localRows });
+  }
+  return groups;
+}
+
+/**
+ * Whether a cached font-enumeration verdict may be asked for again.
+ *
+ * A working enumeration is final for the session, and a browser that has no
+ * such API at all will never grow one — but a refusal is not: the user can
+ * grant the font permission from the browser's prompt or its site settings.
+ * Retrying is cheap, because a still-blocked permission is rejected instantly
+ * instead of prompting again.
+ *
+ * @param {{status?: string, at?: number, permanent?: boolean}|null} cache - the cached verdict.
+ * @param {number} now - the current time, in milliseconds.
+ * @param {number} retryMs - how long a refusal is trusted.
+ * @returns {boolean} true when the enumeration should run again.
+ */
+function catalogRefreshDue(cache, now, retryMs) {
+  if (cache === null || cache === undefined) return true;
+  if (cache.permanent === true || cache.status === "ready") return false;
+  return now - (cache.at || 0) >= retryMs;
 }
 
 var shared = {
@@ -2009,6 +2145,8 @@ var shared = {
   ACTIVE_PRESET_FIELD: ACTIVE_PRESET_FIELD,
   UI_FOLLOWS_FIELD: UI_FOLLOWS_FIELD,
   VALUE_FIELDS: VALUE_FIELDS,
+  RETIRED_FIELDS: RETIRED_FIELDS,
+  DURABLE_FIELDS: DURABLE_FIELDS,
   SIZE_MIN: SIZE_MIN,
   SIZE_MAX: SIZE_MAX,
   WEIGHT_MIN: WEIGHT_MIN,
@@ -2021,7 +2159,6 @@ var shared = {
   LIGATURES_DEFAULT: LIGATURES_DEFAULT,
   LIGATURES_ON: LIGATURES_ON,
   LIGATURES_OFF: LIGATURES_OFF,
-  MARKER: MARKER,
   STYLE_TAG: STYLE_TAG,
   CARD_STYLE_TAG: CARD_STYLE_TAG,
   DEFAULTS: DEFAULTS,
@@ -2032,7 +2169,17 @@ var shared = {
   MAX_PRESET_NAME: MAX_PRESET_NAME,
   FALLBACK_TOKENS: FALLBACK_TOKENS,
   PRESETS: PRESETS,
+  PRESET_GROUPS: PRESET_GROUPS,
+  MAX_LOCAL_FONTS: MAX_LOCAL_FONTS,
+  pickerGroups: pickerGroups,
+  catalogRefreshDue: catalogRefreshDue,
   MARKDOWN_SELECTOR: MARKDOWN_SELECTOR,
+  CODE_SURFACE_SELECTORS: CODE_SURFACE_SELECTORS,
+  CODE_EXCLUDES: CODE_EXCLUDES,
+  INTERFACE_EXCLUDES: INTERFACE_EXCLUDES,
+  excludeAll: excludeAll,
+  splitSelectorList: splitSelectorList,
+  prefixSelector: prefixSelector,
   DARK_ATTR: DARK_ATTR,
   sanitize: sanitize,
   sanitizeFamily: sanitizeFamily,
@@ -2063,19 +2210,12 @@ var shared = {
   isMarkdownToken: isMarkdownToken,
   isDeltaToken: isDeltaToken,
   isShorthandName: isShorthandName,
-  isShorthandToken: isShorthandToken,
   isScaledToken: isScaledToken,
   tokenNames: tokenNames,
-  codeTokenNames: codeTokenNames,
   markdownTokenNames: markdownTokenNames,
-  bodyTokenNames: bodyTokenNames,
-  uiLineTokenNames: uiLineTokenNames,
-  deltaTokenNames: deltaTokenNames,
   shorthandTokens: shorthandTokens,
   markdownShorthandTokens: markdownShorthandTokens,
-  uiShorthandTokens: uiShorthandTokens,
   codeShorthandTokens: codeShorthandTokens,
-  scaleFontShorthand: scaleFontShorthand,
   isGenericFamilyName: isGenericFamilyName,
   isCJKFamilyName: isCJKFamilyName,
   setWestEntry: setWestEntry,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-fonttune",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "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",
@@ -19,7 +19,7 @@
     "LICENSE"
   ],
   "engines": {
-    "dsh": ">=0.1.5-rc.2"
+    "dsh": ">=0.1.5-rc.1 <0.1.7-0 || >=0.1.7-alpha.1 <0.2.0-0"
   },
   "dsh": {
     "bundle": {
@@ -30,13 +30,17 @@
     },
     "compatibility": {
       "dshReleases": {
-        "0.1.5-rc.2": "compatible"
+        "0.1.5-rc.1": "compatible",
+        "0.1.5-rc.2": "compatible",
+        "0.1.5-rc.3": "compatible",
+        "0.1.7-alpha.1": "compatible",
+        "0.1.7-alpha.2": "compatible"
       }
     }
   },
   "peerDependencies": {
-    "react": "^18.2.0",
-    "@deepseek-ai/schemastery": "^3.18.0"
+    "@deepseek-ai/schemastery": "^3.18.0",
+    "react": "^18.2.0"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/schemastery": {
@@ -44,13 +48,14 @@
     }
   },
   "devDependencies": {
-    "@deepseek-ai/schemastery": "^3.18.0"
+    "@deepseek-ai/schemastery": "^3.18.4"
   },
   "scripts": {
     "build": "node build.mjs",
     "watch": "node build.mjs --watch",
     "test": "node test/run.mjs && node test/render-card.mjs",
     "verify": "node test/run.mjs && node test/render-card.mjs && node test/artifacts.mjs",
+    "verify:browser": "node test/browser-verify.mjs",
     "prepublishOnly": "node build.mjs && node test/run.mjs && node test/render-card.mjs && node test/artifacts.mjs"
   },
   "license": "MIT",