@citisen/dsh-font 0.1.0 → 0.2.0

package/scripts/verify-host.mjs

@@ -12,14 +12,15 @@
 import assert from 'node:assert/strict'
 import { existsSync } from 'node:fs'
 import { createRequire } from 'node:module'
-import { dirname, join } from 'node:path'
+import { dirname, join, resolve } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { fileURLToPath } from 'node:url'
 
 const root = join(dirname(fileURLToPath(import.meta.url)), '..')
 
 /**
- * Import `lib/index.js` through the installed profile when one exists.
+ * Import `lib/index.js`, either from a path given on the command line or from
+ * an installed profile.
  *
  * The host half imports `@deepseek-ai/schemastery`, which dsh supplies to a
  * plugin from the installation's module fallback rather than from the plugin's
@@ -27,8 +28,16 @@ const root = join(dirname(fileURLToPath(import.meta.url)), '..')
  * this check also proves the plugin's runtime dependencies actually resolve at
  * the place dsh will load it from. Falling back to the direct path keeps the
  * check usable in a bare checkout.
+ *
+ * Note that importing through a directory junction resolves to its real path,
+ * so pass the installed `lib/index.js` explicitly to exercise a published copy
+ * rather than a linked one.
  */
 async function importHost() {
+  const explicit = process.argv[2] ?? process.env.DSH_FONT_HOST
+  if (explicit !== undefined) {
+    return { host: await import(pathToFileURL(resolve(explicit)).href), via: resolve(explicit) }
+  }
   const dshHome = process.env.DSH_HOME
   const profile = process.env.DSH_PROFILE ?? 'web'
   if (dshHome !== undefined) {
@@ -37,7 +46,7 @@ async function importHost() {
       try {
         // Resolve the bare specifier: `exports` maps "." to lib/index.js, and a
         // direct `dsh-font/lib/index.js` path is deliberately not exported.
-        const resolved = createRequire(anchor).resolve('dsh-font')
+        const resolved = createRequire(anchor).resolve('@citisen/dsh-font')
         return { host: await import(pathToFileURL(resolved).href), via: resolved }
       } catch {
         /* not installed in that profile; fall through to the direct import */
@@ -56,6 +65,9 @@ const {
   FontSettingsSchema,
   DEFAULT_UI_FONT_FAMILY,
   DEFAULT_CODE_FONT_FAMILY,
+  DEFAULT_CODE_FONT_WEIGHT,
+  DEFAULT_UI_FONT_WEIGHT,
+  FONT_WEIGHTS,
   FONT_STYLE_ID,
   fontStyleSheet,
   fontBootstrapScript,
@@ -70,28 +82,61 @@ assert.equal(FONT_SETTINGS_NAMESPACE, 'ui-font')
 const defaults = FontSettingsSchema({})
 assert.equal(defaults.uiFontFamily, DEFAULT_UI_FONT_FAMILY)
 assert.equal(defaults.codeFontFamily, DEFAULT_CODE_FONT_FAMILY)
+assert.equal(defaults.codeFontWeight, DEFAULT_CODE_FONT_WEIGHT)
+assert.equal(defaults.uiFontWeight, DEFAULT_UI_FONT_WEIGHT)
+assert.equal(DEFAULT_UI_FONT_WEIGHT, 400, 'the shipped interface weight is the design system base')
 assert.equal(defaults.uiFontScale, 1)
 assert.equal(defaults.contentFontSize, 14)
 assert.equal(defaults.codeFontSize, 12)
 
+// The weight is a closed vocabulary, not a free number: a weight no family is
+// guaranteed to have would be synthesized by the browser (faux-bold), so it
+// must be rejected at the wire boundary rather than painted.
+assert.deepEqual(FONT_WEIGHTS, [100, 200, 300, 400, 500, 600, 700, 800, 900])
+for (const weight of FONT_WEIGHTS) {
+  assert.equal(FontSettingsSchema({ codeFontWeight: weight }).codeFontWeight, weight)
+  assert.equal(FontSettingsSchema({ uiFontWeight: weight }).uiFontWeight, weight)
+}
+assert.throws(() => FontSettingsSchema({ codeFontWeight: 550 }))
+assert.throws(() => FontSettingsSchema({ codeFontWeight: 0 }))
+assert.throws(() => FontSettingsSchema({ codeFontWeight: '500' }))
+assert.throws(() => FontSettingsSchema({ uiFontWeight: 550 }))
+assert.throws(() => FontSettingsSchema({ uiFontWeight: 'medium' }))
+
 // Out-of-range values must be rejected at the wire boundary.
 assert.throws(() => FontSettingsSchema({ contentFontSize: 99 }))
 assert.throws(() => FontSettingsSchema({ uiFontScale: 0.1 }))
 
 // The pre-paint sheet carries the scale and both size axes, one rule per
-// hard-coded UI text step.
+// hard-coded UI text step — and the code weight, which the design system has no
+// token of its own for.
 const sheet = fontStyleSheet(defaults)
 assert.match(sheet, /--dsh-font-ui-scale:1;/)
 assert.match(sheet, /--dsh-font-content-size:14px/)
 assert.match(sheet, /--dsh-font-code-size:12px/)
+assert.match(sheet, /--dsh-font-code-weight:400;/)
 assert.match(sheet, /font-size:calc\(14px \* var\(--dsh-font-ui-scale,1\)\) !important/)
 for (const step of [11, 12, 13, 14, 16, 20, 24]) {
   assert.ok(sheet.includes(`calc(${String(step)}px * `), `missing scale rule for ${String(step)}px`)
 }
 
+// The interface weight is opted into: the shipped 400 emits no rule at all, so
+// a default install's first frame is exactly what the design system paints.
+assert.ok(
+  !/font-weight:/.test(sheet),
+  'the shipped interface weight must not emit a weight rule',
+)
+const heavy = fontStyleSheet({ ...defaults, uiFontWeight: 500 })
+assert.match(heavy, /html body\{font-weight:500\}/)
+
 const script = fontBootstrapScript(defaults)
 assert.ok(script.includes(JSON.stringify(FONT_STYLE_ID)), 'bootstrap must key on the stylesheet id')
 assert.ok(!script.includes('</script'), 'bootstrap must not close its own script element')
+assert.ok(!script.includes('font-weight'), 'the default bootstrap must carry no weight rule')
+assert.ok(
+  fontBootstrapScript({ ...defaults, uiFontWeight: 500 }).includes('font-weight:500'),
+  'a set interface weight must reach the pre-paint bootstrap',
+)
 
 // Execute the bootstrap against a DOM stub and read back what it wrote.
 const appended = []
@@ -124,12 +169,21 @@ assert.match(created[0].textContent, /--dsh-font-ui-scale:1;/)
 assert.equal(appended.length, 1)
 assert.equal(rootStyle.get('--dsw-font-family'), DEFAULT_UI_FONT_FAMILY)
 assert.equal(rootStyle.get('--ds-font-family-code'), DEFAULT_CODE_FONT_FAMILY)
+assert.equal(rootStyle.get('--dsh-font-code-weight'), '400')
 delete globalThis.document
 
 // A non-default section must flow through both the sheet and the script.
-const custom = { ...defaults, uiFontScale: 1.25, contentFontSize: 16, codeFontSize: 13 }
+const custom = {
+  ...defaults,
+  uiFontScale: 1.25,
+  contentFontSize: 16,
+  codeFontSize: 13,
+  codeFontWeight: 500,
+}
 assert.match(fontStyleSheet(custom), /--dsh-font-content-size:16px/)
+assert.match(fontStyleSheet(custom), /--dsh-font-code-weight:500;/)
 assert.match(fontStyleSheet(custom), /font-size:calc\(16px \* var\(--dsh-font-ui-scale,1\)\)/)
+assert.ok(fontBootstrapScript(custom).includes('--dsh-font-code-weight'))
 
 const injection = fontInjection(defaults)
 assert.equal(injection.kind, 'script')

package/scripts/verify-profile.mjs

@@ -1,41 +1,89 @@
 /**
  * End-to-end profile composition check.
  *
- * Loads the real `web` profile through dsh's own profile loader and asserts the
+ * Loads a real dsh profile through dsh's own profile loader and asserts the
  * composed entry list contains this bundle's row. This is the check that
  * catches the failure modes a browser never explains: a bundle the loader
  * cannot resolve, a patch file with the wrong shape, or a row that never made
  * it into `dsh.profile.bundles`.
  *
+ * It needs a dsh installation and an initialized profile, so it SKIPS (exit 0)
+ * when neither is present — a clean CI runner has no dsh, and a release must
+ * not fail merely because this check cannot run there. Set `DSH_REQUIRE=1` to
+ * turn a skip into a failure.
+ *
  * Usage:
  *   node scripts/verify-profile.mjs [profile-name]
+ *
+ * Environment:
+ *   DSH_HOME      Harness home holding profiles/ (default ~/.dsh)
+ *   DSH_PROFILE   Profile name (default web; a command-line argument wins)
+ *   DSH_CHECKOUT  dsh installation's node_modules/@deepseek-ai
+ *   DSH_REQUIRE   Set to 1 to fail instead of skipping when dsh is unavailable
  */
 
-import { readFileSync, statSync } from 'node:fs'
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
 import { createRequire } from 'node:module'
 import { dirname, join } from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 
-/** The dsh installation whose own loader and composition rules this check uses. */
-const DSH_ROOT =
-  process.env.DSH_CHECKOUT ??
-  join(
-    process.env.LOCALAPPDATA ?? 'C:/Users/Administrator/AppData/Local',
-    'npm-cache/_npx/1e7f6d9597241db0/node_modules/@deepseek-ai',
+/** This plugin's package name, as declared by its own manifest. */
+const OWN_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..')
+const PACKAGE_NAME = JSON.parse(readFileSync(join(OWN_ROOT, 'package.json'), 'utf8')).name
+
+const HOME = process.env.USERPROFILE ?? process.env.HOME ?? ''
+const DSH_HOME = process.env.DSH_HOME ?? (HOME === '' ? undefined : join(HOME, '.dsh'))
+
+/** Give up (or fail, under DSH_REQUIRE) because dsh is not usable here. */
+function skip(reason) {
+  console.log(`verify-profile: SKIP — ${reason}`)
+  if (process.env.DSH_REQUIRE === '1') {
+    console.error('verify-profile: DSH_REQUIRE=1, treating the skip as a failure')
+    process.exit(1)
+  }
+  process.exit(0)
+}
+
+/**
+ * Locate the dsh installation whose loader and composition rules this check
+ * uses. `npx` caches live under a version-hashed directory, so discover the
+ * path rather than pin one: a pinned path rots on the next install and would
+ * silently turn this check into a no-op.
+ * @returns the `@deepseek-ai` directory, or undefined when none is present.
+ */
+function findCheckout() {
+  if (process.env.DSH_CHECKOUT !== undefined) return process.env.DSH_CHECKOUT
+  const candidates = []
+  const npxRoot = join(HOME, 'AppData', 'Local', 'npm-cache', '_npx')
+  if (existsSync(npxRoot)) {
+    for (const entry of readdirSync(npxRoot)) {
+      candidates.push(join(npxRoot, entry, 'node_modules', '@deepseek-ai'))
+    }
+  }
+  candidates.push(join(HOME, 'node_modules', '@deepseek-ai'))
+  return candidates.find((candidate) =>
+    existsSync(join(candidate, 'dsh-app-boot', 'lib', 'index.js')),
   )
-const INSTALL_ANCHOR = `${DSH_ROOT}/dsh/package.json`
+}
+
+const DSH_ROOT = findCheckout()
+if (DSH_ROOT === undefined) {
+  skip('no dsh installation found (set DSH_CHECKOUT to point at one)')
+}
 
-const profileName = process.argv[2] ?? 'web'
+const INSTALL_ANCHOR = join(DSH_ROOT, 'dsh', 'package.json')
+const profileName = process.argv[2] ?? process.env.DSH_PROFILE ?? 'web'
 
 const { loadProfile, composeEntries } = await import(
-  pathToFileURL(`${DSH_ROOT}/dsh-app-boot/lib/index.js`).href
+  pathToFileURL(join(DSH_ROOT, 'dsh-app-boot', 'lib', 'index.js')).href
 )
 
-const profile = loadProfile('dsh', profileName, INSTALL_ANCHOR)
-
-/** This plugin's package name, as declared by its own manifest. */
-const OWN_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..')
-const PACKAGE_NAME = JSON.parse(readFileSync(join(OWN_ROOT, 'package.json'), 'utf8')).name
+let profile
+try {
+  profile = loadProfile('dsh', profileName, INSTALL_ANCHOR, DSH_HOME)
+} catch (error) {
+  skip(`profile "${profileName}" is not available: ${String(error)}`)
+}
 
 const layers = profile.layers.map((layer) => layer.packageName)
 console.log(`verify-profile: profile "${profileName}" at ${profile.dir}`)