@citisen/dsh-font 0.1.0 → 0.2.0

package/lib/index.js

@@ -27,6 +27,18 @@ export const FONT_SETTINGS_NAMESPACE = 'ui-font'
 export const UI_FONT_FAMILY_FIELD = 'uiFontFamily'
 /** Field: CSS font-family list for code, terminal, and monospace text. */
 export const CODE_FONT_FAMILY_FIELD = 'codeFontFamily'
+/** Field: numeric `font-weight` for code, terminal, and monospace text. */
+export const CODE_FONT_WEIGHT_FIELD = 'codeFontWeight'
+/**
+ * Field: numeric `font-weight` for interface text.
+ *
+ * Unlike the code weight this one is opted into: `400` — the value every
+ * untouched install resolves to — is the design system's own base, so the
+ * plugin emits no weight rule at all for it. Anything else is written as an
+ * explicit override, which is why "not set" and "set to 400" are the same
+ * state rather than two.
+ */
+export const UI_FONT_WEIGHT_FIELD = 'uiFontWeight'
 /** Field: scale applied to every interface font size, as a unitless number. */
 export const UI_FONT_SCALE_FIELD = 'uiFontScale'
 /** Field: conversation content font size in px (owns `--dsh-content-font-size`). */
@@ -41,6 +53,36 @@ export const DEFAULT_UI_FONT_FAMILY =
 export const DEFAULT_CODE_FONT_FAMILY =
   '"SF Mono", "JetBrains Mono", "Fira Code", Consolas, "Liberation Mono", Menlo, Courier, "PingFang SC", "Microsoft YaHei"'
 
+/**
+ * Weights the code font may be set to.
+ *
+ * The design system ships **no** weight token — every `font: …` declaration in
+ * the interface is a literal, and the code ladder is literally `400`. So the
+ * weight is delivered as a `font-weight` override the plugin owns, and it is a
+ * closed list rather than a free number: a `font-weight` a family does not have
+ * is synthesized by the browser (faux-bold), and offering that silently would
+ * be a poor default. The list is the CSS Fonts keyword scale, which is also the
+ * scale the Local Font Access API reports individual faces on.
+ *
+ * Kept in sync by hand with the browser half's table in `src/client.js`; the
+ * two halves are separate bundles and share no module.
+ */
+export const FONT_WEIGHTS = [100, 200, 300, 400, 500, 600, 700, 800, 900]
+
+/**
+ * The shipped code weight. Matches the design system's own literal (`400` in
+ * every `--dsw-font-markdown-code*` token), so "no customization" is the
+ * default and an untouched install paints exactly what it painted before.
+ */
+export const DEFAULT_CODE_FONT_WEIGHT = 400
+
+/**
+ * The shipped interface weight. Identical to {@link DEFAULT_CODE_FONT_WEIGHT}
+ * for the same reason: it is what the shipped interface already computes, so an
+ * untouched install paints exactly what it painted before this field existed.
+ */
+export const DEFAULT_UI_FONT_WEIGHT = 400
+
 /** Accepted interface scale range (1 = the shipped sizes). */
 export const UI_FONT_SCALE_MIN = 0.75
 /** Accepted interface scale range upper bound. */
@@ -67,6 +109,8 @@ export const FONT_STYLE_ID = 'dsh-font/variables'
 export const FontSettingsSchema = z.object({
   [UI_FONT_FAMILY_FIELD]: z.string().default(DEFAULT_UI_FONT_FAMILY),
   [CODE_FONT_FAMILY_FIELD]: z.string().default(DEFAULT_CODE_FONT_FAMILY),
+  [CODE_FONT_WEIGHT_FIELD]: z.union(FONT_WEIGHTS).default(DEFAULT_CODE_FONT_WEIGHT),
+  [UI_FONT_WEIGHT_FIELD]: z.union(FONT_WEIGHTS).default(DEFAULT_UI_FONT_WEIGHT),
   [UI_FONT_SCALE_FIELD]: z
     .number()
     .min(UI_FONT_SCALE_MIN)
@@ -108,10 +152,9 @@ function uiScaleRules(scale) {
  * Build the pre-paint stylesheet for one resolved settings section.
  *
  * This is the subset of the browser half's sheet that must exist before any
- * plugin runs: the interface scale and the conversation text size. Families are
- * handled separately (see {@link fontBootstrapScript}) because the design
- * system resolves them through `var()` chains the shell's own `body` rule
- * already reads.
+ * plugin runs: the interface scale and the conversation text size. Families and
+ * the code weight are handled separately (see {@link fontBootstrapScript})
+ * because the design system resolves them through the token chain.
  *
  * Written as a `<style>` element rather than inline custom properties because
  * `ui-layout`'s theme presenter owns `document.body.style` and rewrites the
@@ -126,6 +169,19 @@ export function fontStyleSheet(section) {
   const uiScale = section[UI_FONT_SCALE_FIELD]
   const contentSize = section[CONTENT_FONT_SIZE_FIELD]
   const codeSize = section[CODE_FONT_SIZE_FIELD]
+  const codeWeight = section[CODE_FONT_WEIGHT_FIELD]
+  const uiWeight = section[UI_FONT_WEIGHT_FIELD]
+
+  // The interface weight is the one field that is *not* always emitted: at the
+  // shipped 400 the rule would be a no-op (`normal` inherits as 400 anyway), and
+  // leaving it out keeps a default install's first frame byte-identical to the
+  // shipped one. The browser half repeats this rule in its own — larger — sheet,
+  // which replaces this one the moment the plugin activates; both exist so the
+  // weight cannot flash between the two.
+  const uiWeightRules =
+    uiWeight === undefined || uiWeight === DEFAULT_UI_FONT_WEIGHT
+      ? []
+      : [`html body{font-weight:${String(uiWeight)}}`]
 
   return [
     '/* dsh-font: pre-paint variables and interface scale */',
@@ -133,7 +189,9 @@ export function fontStyleSheet(section) {
     `--dsh-font-ui-scale:${String(uiScale)};`,
     `--dsh-font-content-size:${String(contentSize)}px;`,
     `--dsh-font-code-size:${String(codeSize)}px;`,
+    `--dsh-font-code-weight:${String(codeWeight)};`,
     '}',
+    ...uiWeightRules,
     'html body,html body *{',
     uiScaleRules(uiScale),
     '}',
@@ -161,6 +219,7 @@ function escapeForScript(text) {
 export function fontBootstrapScript(section) {
   const uiFamily = JSON.stringify(section[UI_FONT_FAMILY_FIELD])
   const codeFamily = JSON.stringify(section[CODE_FONT_FAMILY_FIELD])
+  const codeWeight = JSON.stringify(String(section[CODE_FONT_WEIGHT_FIELD]))
   // Keep the stylesheet after the user-controlled family strings so the
   // `</`-escaping cannot be defeated by a family value that itself contains a
   // script-closing sequence.
@@ -181,6 +240,7 @@ export function fontBootstrapScript(section) {
     const root = document.documentElement.style
     root.setProperty('--dsw-font-family', ${uiFamily})
     root.setProperty('--ds-font-family-code', ${codeFamily})
+    root.setProperty('--dsh-font-code-weight', ${codeWeight})
   } catch (error) {
     console.warn('dsh-font: pre-paint bootstrap failed', error)
   }
@@ -210,6 +270,8 @@ function readSection(ctx) {
   const fallback = {
     [UI_FONT_FAMILY_FIELD]: DEFAULT_UI_FONT_FAMILY,
     [CODE_FONT_FAMILY_FIELD]: DEFAULT_CODE_FONT_FAMILY,
+    [CODE_FONT_WEIGHT_FIELD]: DEFAULT_CODE_FONT_WEIGHT,
+    [UI_FONT_WEIGHT_FIELD]: DEFAULT_UI_FONT_WEIGHT,
     [UI_FONT_SCALE_FIELD]: 1,
     [CONTENT_FONT_SIZE_FIELD]: 14,
     [CODE_FONT_SIZE_FIELD]: 12,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@citisen/dsh-font",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "DeepSeek Harness plugin: customize the Web GUI fonts (interface family, code family, and three font-size axes) from Settings",
   "type": "module",
   "license": "MIT",
@@ -49,7 +49,10 @@
     "build": "node scripts/build-client.mjs",
     "watch": "node scripts/build-client.mjs --watch",
     "verify": "node scripts/verify-host.mjs && node scripts/verify-client.mjs",
-    "check": "node scripts/build-client.mjs --check && npm run verify"
+    "check": "node scripts/build-client.mjs --check && npm run verify",
+    "check:all": "npm run check && node scripts/verify-profile.mjs",
+    "release": "node scripts/release.mjs",
+    "prepublishOnly": "npm run check"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.2"
@@ -72,5 +75,8 @@
     "theme",
     "web-ui",
     "web-gui"
-  ]
+  ],
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.2"
+  }
 }

package/scripts/build-client.mjs

@@ -38,7 +38,30 @@ const PACKAGE_NAME = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')
  * what the loader consumes; the rest exist so the verifier can unit-test the
  * pure builders without re-parsing the source.
  */
-const ENVELOPE_EXPORTS = ['apply', 'inject', 'fontStyleSheet', 'applyFonts']
+const ENVELOPE_EXPORTS = [
+  'apply',
+  'inject',
+  'fontStyleSheet',
+  'applyFonts',
+  'parseFamilyList',
+  'serializeFamilyList',
+  'normalizeWeight',
+  'weightWord',
+  'faceWeights',
+  'emphasisWeight',
+  'parseFontQuery',
+  'fontQueryTokens',
+  'serializeFontQuery',
+  'queryContextAt',
+  'querySuggestions',
+  'applySuggestion',
+  'moveFontQueryEntry',
+  'queryTokenClass',
+  'clampHighlight',
+  'describeDiagnostic',
+  'rankFamilyMatches',
+  'FontQueryEditor',
+]
 
 /**
  * `import [default][, { named }] from 'spec'`, with no nested braces.

package/scripts/release.mjs

@@ -0,0 +1,91 @@
+/**
+ * Maintainer-side release helper.
+ *
+ * Publishing is split in two on purpose: CI stages a tarball (see
+ * `.github/workflows/stage.yml`), and a human approves it here, where npm
+ * demands that human's 2FA. A compromised runner or a malicious commit can
+ * therefore stage but never publish.
+ *
+ * `npm stage` needs npm >= 11.6 (12 for the current subcommands) and Node 22.22
+ * / 24.15 / 26+, which the local Node may not satisfy. So rather than requiring
+ * a global npm upgrade, this delegates to `npx npm@12`, and borrows the system
+ * `git` for the OTP flow npm uses for a 2FA-gated web approval.
+ *
+ * Usage:
+ *   node scripts/release.mjs list [package]
+ *   node scripts/release.mjs view <stage-id>
+ *   node scripts/release.mjs approve <stage-id>
+ *   node scripts/release.mjs reject <stage-id>
+ *   node scripts/release.mjs download <stage-id> [--dry-run]
+ */
+
+import { spawnSync } from 'node:child_process'
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '..')
+const [, , subcommand, ...rest] = process.argv
+
+const PACKAGE_NAME = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')).name
+const VERSION = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')).version
+
+/** npm CLI major to run; `npm stage` needs 12 for `list`/`approve`. */
+const NPM_SPEC = 'npm@12'
+
+const USAGE = `usage: node scripts/release.mjs <command> [args]
+
+  list [package]            staged versions (default: ${PACKAGE_NAME})
+  view <stage-id>           details of one staged version
+  approve <stage-id>        publish it — REQUIRES your 2FA
+  reject <stage-id>         discard it
+  download <stage-id>       fetch the staged tarball for inspection
+
+Nothing here publishes without an approval, which is the point: CI can only
+stage.`
+
+const KNOWN = new Set(['list', 'view', 'approve', 'reject', 'download'])
+
+if (subcommand === undefined || subcommand === '--help' || subcommand === '-h') {
+  console.log(USAGE)
+  process.exit(0)
+}
+if (!KNOWN.has(subcommand)) {
+  console.error(`release: unknown command "${subcommand}"\n\n${USAGE}`)
+  process.exit(2)
+}
+if (subcommand !== 'list' && rest.length === 0) {
+  console.error(`release: "${subcommand}" needs a stage-id\n\n${USAGE}`)
+  process.exit(2)
+}
+
+const args = [NPM_SPEC, 'stage', subcommand]
+if (subcommand === 'list') args.push(rest[0] ?? PACKAGE_NAME)
+else args.push(...rest)
+
+console.log(`release: npx ${args.join(' ')}`)
+if (subcommand === 'approve') {
+  console.log('release: approving publishes to the registry and requires your 2FA')
+}
+
+const result = spawnSync('npx', ['--yes', ...args], {
+  cwd: root,
+  stdio: 'inherit',
+  shell: process.platform === 'win32',
+})
+
+if (result.error !== undefined) {
+  if (result.error.code === 'ENOENT') {
+    console.error('release: npx not found on PATH — install Node.js')
+    process.exit(127)
+  }
+  throw result.error
+}
+const exitCode = result.status ?? 1
+
+if (exitCode === 0 && subcommand === 'list') {
+  console.log(`\nrelease: nothing is installable until a stage is approved.`)
+  console.log(`release: a local release runs \`npm run release -- approve <stage-id>\` from v${VERSION}.`)
+}
+
+process.exit(exitCode)