@biffo/design-tokens 0.267.8 → 0.268.0

package/bin/scale-guard-lib.mjs

@@ -0,0 +1,279 @@
+// Pure functions for `biffo-scale-guard` (see scale-guard.mjs for the CLI
+// shell). Kept dependency-free and side-effect-free on purpose: every
+// consuming repo installs this transitively via @biffo/design-tokens, so it
+// adds no new packages to anyone's tree, and it is unit-testable without
+// touching the filesystem or a real tokens.css.
+//
+// ## Where this came from
+//
+// Relocated from `@tabsii-com/ui`'s `bin/scale-guard.mjs` (tabsii-platform#377
+// Phase 2), where it was built and proved against a real, shipped Material-3
+// scale. That version resolved its own package's `dist/tokens.css` by walking
+// up from itself -- correct for a repo with exactly one scale to check
+// against, wrong for a template meant to sit under every Biffo instance, each
+// of which may define (or not yet define) its own scale. THIS file is the
+// generic relocation: every function below is unchanged in behaviour, but the
+// CLI shell (scale-guard.mjs) takes the token source as a `--tokens <path>`
+// argument instead of assuming it. See that file's header for the mechanism/
+// values split this enforces.
+//
+// Design note (tabsii-platform#377 Phase 2, carried forward unchanged): this
+// checker reads the target repo's *hardcoded* CSS/TSX declarations and
+// compares them against the scale -- not the other way around. A guard that
+// only asserts "the scale in tokens.css is well-formed" would be worthless:
+// tabsii-marketplace's ~15 off-scale sizes proved consumers ignore an
+// existing scale regardless. Only reading call sites catches that class.
+
+const IGNORED_DIR_NAMES = new Set([
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  '.next',
+  'out',
+  'coverage',
+  '.turbo',
+  '.worktrees',
+  '.vercel',
+])
+
+const SCANNABLE_EXTENSIONS = new Set(['.css', '.tsx', '.jsx'])
+
+/**
+ * Recursively lists files under `rootDir` matching SCANNABLE_EXTENSIONS,
+ * skipping IGNORED_DIR_NAMES. Takes a `readDirFn`/`isDirFn` pair so tests can
+ * supply an in-memory tree instead of touching disk.
+ */
+export function collectScannableFiles(rootDir, { readDirEntries, joinPath = defaultJoin } = {}) {
+  const results = []
+  const stack = [rootDir]
+
+  while (stack.length > 0) {
+    const dir = stack.pop()
+    const entries = readDirEntries(dir)
+    for (const entry of entries) {
+      if (entry.isDirectory) {
+        if (!IGNORED_DIR_NAMES.has(entry.name)) {
+          stack.push(joinPath(dir, entry.name))
+        }
+        continue
+      }
+      const ext = extname(entry.name)
+      if (SCANNABLE_EXTENSIONS.has(ext)) {
+        results.push(joinPath(dir, entry.name))
+      }
+    }
+  }
+  return results.sort()
+}
+
+function extname(name) {
+  const i = name.lastIndexOf('.')
+  return i === -1 ? '' : name.slice(i)
+}
+
+function defaultJoin(a, b) {
+  return `${a}/${b}`
+}
+
+/** Converts a `{value, unit}` pair to px. Returns null for an unhandled unit. */
+export function toPx(value, unit) {
+  if (unit === 'px') return value
+  if (unit === 'rem') return value * 16 // documented assumption: 1rem == 16px root font-size
+  return null
+}
+
+// The numeric group below is deliberately NOT `[0-9]*\.?[0-9]+` -- that shape
+// has two quantifiers (`*` and `+`) running over the SAME character class
+// with nothing but an OPTIONAL literal between them, so a run of digits with
+// no unit suffix (e.g. a hand-crafted "gap:00000000...") has O(n) equally
+// valid ways to split between the two, and the engine tries all of them
+// before giving up when `(px|rem)` fails to follow -- polynomial blowup on
+// attacker- or generator-controlled CSS, flagged by CodeQL's
+// js/polynomial-redos on this exact shape (high severity, all three
+// instances of it in this file, tabsii-platform#377 follow-up). The fix
+// removes the ambiguity rather than papering over it: `[0-9]+(?:\.[0-9]+)?`
+// greedily consumes every digit in one pass with a SINGLE quantifier, and
+// the trailing `(?:\.[0-9]+)?` is only ever entered by matching a literal
+// "." first -- so on a dot-free digit run it resolves to "no match" in one
+// O(1) check with nothing left to backtrack into. `|\.[0-9]+` keeps
+// `.5rem`-style CSS (a leading-dot decimal with no integer part) matching,
+// as an alternative that starts on a DIFFERENT character (".") to the first
+// branch (a digit) -- so the two branches never compete over the same
+// characters either.
+const NUMBER_RE_SOURCE = '(?:[0-9]+(?:\\.[0-9]+)?|\\.[0-9]+)'
+
+const CSS_PROPERTY_RE = new RegExp(
+  `(font-size|line-height|gap|row-gap|column-gap)\\s*:\\s*(${NUMBER_RE_SOURCE})(px|rem)\\b`,
+  'g',
+)
+
+const TAILWIND_ARBITRARY_RE = new RegExp(
+  `\\b(text|leading|gap|row-gap|column-gap)-\\[(${NUMBER_RE_SOURCE})(px|rem)\\]`,
+  'g',
+)
+
+const CATEGORY_BY_CSS_PROPERTY = {
+  'font-size': 'fontSize',
+  'line-height': 'lineHeight',
+  gap: 'spacing',
+  'row-gap': 'spacing',
+  'column-gap': 'spacing',
+}
+
+const CATEGORY_BY_TAILWIND_PREFIX = {
+  text: 'fontSize',
+  leading: 'lineHeight',
+  gap: 'spacing',
+  'row-gap': 'spacing',
+  'column-gap': 'spacing',
+}
+
+/**
+ * Scans one file's text for hardcoded font-size/line-height/spacing
+ * declarations -- plain CSS properties and Tailwind arbitrary-value classes
+ * alike -- and returns one entry per match with its resolved px value.
+ * Unitless and keyword values (`line-height: 1.5`, `gap: normal`) are not
+ * comparable to a px scale and are deliberately not matched.
+ */
+export function extractDeclarations(filePath, fileText) {
+  const declarations = []
+  const lines = fileText.split('\n')
+
+  lines.forEach((line, idx) => {
+    const lineNumber = idx + 1
+
+    CSS_PROPERTY_RE.lastIndex = 0
+    let match
+    while ((match = CSS_PROPERTY_RE.exec(line))) {
+      const [, property, rawValue, unit] = match
+      const px = toPx(parseFloat(rawValue), unit)
+      declarations.push({
+        file: filePath,
+        line: lineNumber,
+        category: CATEGORY_BY_CSS_PROPERTY[property],
+        source: `${property}: ${rawValue}${unit}`,
+        px,
+      })
+    }
+
+    TAILWIND_ARBITRARY_RE.lastIndex = 0
+    while ((match = TAILWIND_ARBITRARY_RE.exec(line))) {
+      const [, prefix, rawValue, unit] = match
+      const px = toPx(parseFloat(rawValue), unit)
+      declarations.push({
+        file: filePath,
+        line: lineNumber,
+        category: CATEGORY_BY_TAILWIND_PREFIX[prefix],
+        source: `${prefix}-[${rawValue}${unit}]`,
+        px,
+      })
+    }
+  })
+
+  return declarations
+}
+
+// Originally `([a-z0-9-]+?)(-line-height)?:` -- a LAZY key-name quantifier
+// immediately followed by an OPTIONAL literal that starts with a character
+// ("-") already inside the lazy group's own class. CodeQL flagged this too
+// ("may run slow on strings starting with '--text--:' and with many
+// repetitions"): a run of hyphens gives the engine many equally-valid points
+// to stop growing the lazy group and try the optional suffix, all of which
+// fail identically when no ":" ever follows (a malformed/attacker line).
+// Fixed the same way as the numeric patterns above -- remove the ambiguity
+// rather than bound it: capture the WHOLE key with a single greedy
+// quantifier bounded by the mandatory ":", then peel the "-line-height"
+// suffix off in plain JS below, where a `String.endsWith` is O(1) against
+// the engine, not a second regex quantifier competing for the same text.
+const TOKEN_LINE_RE = new RegExp(`^\\s*--(text|space)-([a-z0-9-]+):\\s*(${NUMBER_RE_SOURCE})px;`)
+
+const LINE_HEIGHT_KEY_SUFFIX = '-line-height'
+
+/**
+ * Parses a tokens.css file into the three allowed-value sets a scanned
+ * declaration is checked against, using the fixed `--text-<key>` /
+ * `--text-<key>-line-height` / `--space-<key>` naming convention. This
+ * convention -- not any particular set of values -- is the generic contract
+ * between the guard and whatever token source an instance configures: the
+ * MECHANISM (this file) is generic, and lives in biffo-template; the VALUES
+ * are per-instance, and live in whatever `--tokens` points at. See
+ * scale-guard.mjs's header for why nothing Tabsii- or instance-specific
+ * belongs in this file.
+ *
+ * Reading the shipped CSS rather than re-declaring the scale here is what
+ * keeps this checker from drifting from the source of truth the way the
+ * consumers it checks already have.
+ */
+export function parseAllowedScale(tokensCssText) {
+  const fontSize = new Set()
+  const lineHeight = new Set()
+  const spacing = new Set()
+
+  for (const rawLine of tokensCssText.split('\n')) {
+    const match = TOKEN_LINE_RE.exec(rawLine)
+    if (!match) continue
+    const [, kind, key, value] = match
+    const px = parseFloat(value)
+    if (kind === 'text') {
+      if (key.endsWith(LINE_HEIGHT_KEY_SUFFIX)) lineHeight.add(px)
+      else fontSize.add(px)
+    } else if (kind === 'space') {
+      spacing.add(px)
+    }
+  }
+
+  return { fontSize, lineHeight, spacing }
+}
+
+/**
+ * True when `allowedScale` declares no tokens in any of the three
+ * categories -- i.e. the token source this guard was pointed at exists and
+ * parses, but simply has not adopted a type scale yet. This is the "no token
+ * source configured" case scale-guard.mjs's header discusses: deliberately
+ * NOT the same fact as a missing/unreadable tokens file (that stays a hard,
+ * blocking "cannot tell" -- see loadTokensCss in scale-guard.mjs), because a
+ * brand-new Biffo sibling is expected to be in this state, and a guard that
+ * cannot tell "broken" from "not adopted yet" cannot treat them differently.
+ */
+export function isScaleConfigured(allowedScale) {
+  return allowedScale.fontSize.size + allowedScale.lineHeight.size + allowedScale.spacing.size > 0
+}
+
+const EPSILON = 0.01
+
+function isAllowed(px, allowedSet) {
+  if (px === null) return true // unhandled unit -- not this checker's job to judge
+  for (const allowedPx of allowedSet) {
+    if (Math.abs(allowedPx - px) < EPSILON) return true
+  }
+  return false
+}
+
+/**
+ * Filters `declarations` down to those whose px value is outside
+ * `allowedScale`. When a category's allowed set is EMPTY (no scale adopted
+ * yet for that category), every declaration in that category is flagged --
+ * correct, not a bug: with no scale to conform to, "declare nothing
+ * hardcoded" is the only rule available, and this is exactly what turns the
+ * ratchet from inert into a real guard the moment code starts appearing. See
+ * isScaleConfigured() for the label this state gets in the CLI's output.
+ */
+export function findViolations(declarations, allowedScale) {
+  return declarations.filter((d) => !isAllowed(d.px, allowedScale[d.category]))
+}
+
+/**
+ * Compares a current violation count against a recorded baseline. This is
+ * the ratchet: a rise fails, a fall or a hold passes, and a fall says so
+ * explicitly rather than silently banking the improvement.
+ */
+export function compareToBaseline(currentCount, baselineCount) {
+  if (currentCount > baselineCount) {
+    return { verdict: 'fail', currentCount, baselineCount }
+  }
+  if (currentCount < baselineCount) {
+    return { verdict: 'improved', currentCount, baselineCount }
+  }
+  return { verdict: 'pass', currentCount, baselineCount }
+}

package/bin/scale-guard.mjs

@@ -0,0 +1,281 @@
+#!/usr/bin/env node
+// biffo-scale-guard -- fails a consuming repo's CI when it declares a
+// font-size, line-height or spacing value outside its configured type scale.
+//
+// ## Where this came from, and why it moved
+//
+// Built and proved first in `@tabsii-com/ui` as `tabsii-scale-guard`
+// (tabsii-platform#377 Phase 2) against a real, shipped Material-3 scale. That
+// version hardcoded its own package's `dist/tokens.css` as the thing being
+// checked against -- correct for a repo with exactly one scale, wrong for a
+// mechanism meant to sit under every Biffo instance. tabsii-platform#377's own
+// text is explicit that the recurrence this exists to close -- "a new sibling
+// is born with no scale and no guard" -- can only be fixed upstream, in
+// biffo-template, because that is the only place a change reaches every future
+// sibling rather than one already-built Tabsii app.
+//
+// So the MECHANISM relocated here, generalised to take its token source as an
+// argument (`--tokens`) instead of assuming it. The VALUES did not move, and
+// must not: `@tabsii-com/ui`'s Material-3 scale is Tabsii's, and shipping it
+// into biffo-template would be the ownership boundary in reverse -- every
+// other Biffo instance would inherit Tabsii's design opinions along with the
+// mechanism meant to be instance-agnostic. `@biffo/design-tokens` (this
+// package) currently ships colour/radius/shadow tokens only and no type
+// scale at all -- seeding one is a design decision for whoever builds Biffo's
+// own visual system, not something this guard's relocation should smuggle in.
+//
+// **There is now exactly one implementation.** `@tabsii-com/ui`'s copy is the
+// one to either delete in favour of consuming this package, or reduce to a
+// thin wrapper -- tracked as a separate PR in that repo (it is a different
+// repo with its own release cycle; this one cannot make that change). Until
+// that PR lands, two copies exist in the estate for one release cycle, same
+// as any upstream-then-distribute change; the point is that nobody should
+// extend tabsii-ui's copy independently in the meantime, and the follow-up
+// PR is what prevents a second, silent fork the way `_extract_detail` became
+// one (tabsii-platform#1107/#1108).
+//
+// ## What happens with no type scale configured yet (the design decision)
+//
+// A brand-new Biffo sibling has `@biffo/design-tokens` as a dependency, but
+// that package declares no `--text-*`/`--space-*` tokens today -- so a fresh
+// scaffold's token source parses to three EMPTY allowed-value sets. Two
+// tempting answers were rejected:
+//
+//   - Treating this as "cannot tell" (like a missing tokens file) would fail
+//     every new sibling's CI from day one, on a check that never observed
+//     anything real. A guard that is red on day-one residue trains people to
+//     stop reading it (this is the same argument `scripts/protection-audit.sh`
+//     makes about ratchets generally).
+//   - Silently skipping the check when the scale is empty would be fail-open
+//     -- this estate's dominant defect class -- and would make the guard inert
+//     exactly when a founder starts hardcoding the sizes it exists to catch.
+//
+// Neither is needed. `findViolations` (scale-guard-lib.mjs) already does the
+// right thing with an empty allowed set: nothing is exempted, so any hardcoded
+// font-size/line-height/gap is flagged, and a fresh scaffold's real source
+// (checked at relocation time) declares none, so a freshly-baselined sibling
+// starts at 0 and passes for real, not by construction. The guard therefore
+// needs no third "not configured" exit code and no special CI-side handling:
+// it runs the SAME ratchet either way, and the moment code with a hardcoded
+// size lands, it fails -- correctly, because with no scale adopted yet
+// "nothing hardcoded" is the only rule there is to enforce. What changes is
+// only the MESSAGE: every run -- pass or fail -- states plainly how many
+// scale tokens it found for each category, so "0/0/0, this guard is
+// currently enforcing 'nothing hardcoded' rather than 'on an established
+// scale'" is never left implicit. See isScaleConfigured() in
+// scale-guard-lib.mjs.
+//
+// ## The rest of the design (unchanged from the relocated version)
+//
+//   - Reads the token source passed via `--tokens` (default: this package's
+//     own tokens.css) so the checker cannot drift from the scale it is
+//     checking against.
+//   - Fails loudly, never silently, when it genuinely cannot do its job: no
+//     files found to scan, no tokens file to read, no baseline recorded. Each
+//     of those is a distinct exit-2 "cannot tell", following the convention
+//     `scripts/claim.sh`/`wait-for-checks.sh` already use estate-wide --
+//     never a pass. This is different from "scale not configured yet" above:
+//     those are environment/setup defects, this is an expected, valid state.
+//   - Ratchets rather than blocks on day-one residue: a repo's current
+//     violation count is recorded in a committed baseline file, the guard
+//     fails only when that count *rises*, and a fall is reported (not
+//     silently banked) with an instruction to lower the baseline.
+//
+// Exit codes: 0 pass, 1 fail (violations rose above baseline), 2 cannot tell.
+
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from 'node:fs'
+import { join, dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import {
+  collectScannableFiles,
+  extractDeclarations,
+  parseAllowedScale,
+  isScaleConfigured,
+  findViolations,
+  compareToBaseline,
+} from './scale-guard-lib.mjs'
+
+function parseArgs(argv) {
+  const args = { dir: process.cwd(), tokens: null, baseline: null, init: false }
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    if (arg === '--dir') args.dir = resolve(argv[++i])
+    else if (arg === '--tokens') args.tokens = resolve(argv[++i])
+    else if (arg === '--baseline') args.baseline = resolve(argv[++i])
+    else if (arg === '--init') args.init = true
+    else if (arg === '--help' || arg === '-h') args.help = true
+  }
+  if (!args.baseline) args.baseline = join(args.dir, 'scale-guard-baseline.json')
+  if (!args.tokens) {
+    // Default: this package's own tokens.css, sitting one level up from bin/.
+    // Any instance pointing --tokens elsewhere is exactly the "guard reads
+    // whatever token source an instance configures" mechanism/values split --
+    // this default is just the common case (a sibling that depends on
+    // @biffo/design-tokens and never overrides it).
+    const pkgRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+    args.tokens = join(pkgRoot, 'tokens.css')
+  }
+  return args
+}
+
+function readDirEntries(dir) {
+  return readdirSync(dir).map((name) => {
+    const full = join(dir, name)
+    return { name, isDirectory: statSync(full).isDirectory() }
+  })
+}
+
+function loadTokensCss(tokensPath) {
+  if (!existsSync(tokensPath)) {
+    console.error(
+      `biffo-scale-guard: cannot tell -- no tokens file at ${tokensPath}. Pass --tokens ` +
+        `<path> to point at the CSS file declaring your --text-*/--space-* scale, or check ` +
+        `that @biffo/design-tokens (or whatever ships this bin) installed correctly.`,
+    )
+    process.exit(2)
+  }
+  return readFileSync(tokensPath, 'utf8')
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2))
+
+  if (args.help) {
+    console.log(
+      [
+        'biffo-scale-guard [--dir <path>] [--tokens <path>] [--baseline <path>] [--init]',
+        '',
+        '  --dir       Repo root to scan for .css/.tsx/.jsx files (default: cwd)',
+        '  --tokens    Path to the tokens.css declaring the --text-*/--space-* scale',
+        "              (default: this package's own tokens.css)",
+        '  --baseline  Path to the baseline JSON file (default: <dir>/scale-guard-baseline.json)',
+        '  --init      Write the baseline file from the current violation count and exit',
+      ].join('\n'),
+    )
+    process.exit(0)
+  }
+
+  const tokensCssText = loadTokensCss(args.tokens)
+  const allowedScale = parseAllowedScale(tokensCssText)
+  const configured = isScaleConfigured(allowedScale)
+
+  // Printed on EVERY run, pass or fail -- the observability half of the
+  // "no token source configured" design decision above. A reader must never
+  // have to infer this from a bare PASS.
+  console.log(
+    `biffo-scale-guard: scale source ${args.tokens} -- ${allowedScale.fontSize.size} ` +
+      `fontSize / ${allowedScale.lineHeight.size} lineHeight / ${allowedScale.spacing.size} ` +
+      `spacing token(s).` +
+      (configured
+        ? ''
+        : ' No scale adopted yet in any category -- this guard is currently enforcing ' +
+          '"nothing hardcoded" rather than "on an established scale". That is expected for ' +
+          'a freshly-scaffolded sibling; it stops being the whole story the moment a scale ' +
+          'is added to the token source above.'),
+  )
+
+  if (!existsSync(args.dir)) {
+    console.error(`biffo-scale-guard: cannot tell -- scan directory does not exist: ${args.dir}`)
+    process.exit(2)
+  }
+
+  const files = collectScannableFiles(args.dir, { readDirEntries })
+
+  if (files.length === 0) {
+    console.error(
+      `biffo-scale-guard: cannot tell -- found 0 .css/.tsx/.jsx files under ${args.dir} ` +
+        `(node_modules, dist, build, .next, out, coverage, .turbo, .worktrees and .vercel ` +
+        `are skipped). Either this repo has no scannable frontend source at that path, or ` +
+        `--dir points at the wrong place -- either way, a guard that "passes" here would be ` +
+        `passing because it never ran.`,
+    )
+    process.exit(2)
+  }
+
+  const declarations = files.flatMap((file) =>
+    extractDeclarations(file, readFileSync(file, 'utf8')),
+  )
+  const violations = findViolations(declarations, allowedScale)
+
+  if (args.init) {
+    const baseline = {
+      count: violations.length,
+      recordedAt: new Date().toISOString(),
+      note:
+        'Baseline for the biffo-scale-guard ratchet (tabsii-platform#377 Phase 2 systemic ' +
+        'half). Lower this only when real violations are fixed -- never raise it to silence ' +
+        'a new one.',
+    }
+    writeFileSync(args.baseline, JSON.stringify(baseline, null, 2) + '\n')
+    console.log(
+      `biffo-scale-guard: wrote ${args.baseline} with count=${violations.length}. Commit this file.`,
+    )
+    process.exit(0)
+  }
+
+  if (!existsSync(args.baseline)) {
+    console.error(
+      `biffo-scale-guard: cannot tell -- no baseline file at ${args.baseline}. Current scan ` +
+        `found ${violations.length} violation(s) across ${files.length} file(s). Run with ` +
+        `--init to record that count and commit the baseline file, then re-run without --init.`,
+    )
+    process.exit(2)
+  }
+
+  let baseline
+  try {
+    baseline = JSON.parse(readFileSync(args.baseline, 'utf8'))
+  } catch (err) {
+    console.error(
+      `biffo-scale-guard: cannot tell -- ${args.baseline} is not valid JSON: ${err.message}`,
+    )
+    process.exit(2)
+  }
+
+  if (typeof baseline.count !== 'number') {
+    console.error(
+      `biffo-scale-guard: cannot tell -- ${args.baseline} has no numeric "count" field.`,
+    )
+    process.exit(2)
+  }
+
+  const result = compareToBaseline(violations.length, baseline.count)
+
+  if (result.verdict === 'fail') {
+    console.error(
+      `biffo-scale-guard: FAIL -- ${result.currentCount} off-scale declaration(s), ` +
+        `above the baseline of ${result.baselineCount}:\n`,
+    )
+    for (const v of violations) {
+      console.error(`  ${v.file}:${v.line}  ${v.source}  (category: ${v.category})`)
+    }
+    console.error(
+      configured
+        ? '\nEither bring these back onto the configured scale, or -- if they are genuinely ' +
+            'new, deliberate departures -- that is a design conversation, not something to ' +
+            'fix by raising the baseline.'
+        : '\nNo scale is adopted yet for at least one of these categories (see the scale ' +
+            'source line above), so each is flagged as hardcoded-with-nothing-to-check-it-' +
+            'against rather than off-an-established-scale. Either add these values as ' +
+            'tokens in the token source and reference them, or -- if the count is accepted ' +
+            'debt -- raise the baseline deliberately, in the open, rather than silently.',
+    )
+    process.exit(1)
+  }
+
+  if (result.verdict === 'improved') {
+    console.log(
+      `biffo-scale-guard: PASS -- ${result.currentCount} off-scale declaration(s), down from ` +
+        `a baseline of ${result.baselineCount}. Lower the baseline: set "count" to ` +
+        `${result.currentCount} in ${args.baseline} and commit it.`,
+    )
+    process.exit(0)
+  }
+
+  console.log(
+    `biffo-scale-guard: PASS -- ${result.currentCount} off-scale declaration(s), at baseline.`,
+  )
+  process.exit(0)
+}
+
+main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biffo/design-tokens",
-  "version": "0.267.8",
+  "version": "0.268.0",
   "description": "Biffo's design tokens — one definition of the platform's visual language, for the portal, sibling apps and plugin frontends.",
   "license": "MIT",
   "repository": {
@@ -15,8 +15,13 @@
     "./tokens.css": "./tokens.css",
     "./package.json": "./package.json"
   },
+  "bin": {
+    "biffo-scale-guard": "./bin/scale-guard.mjs"
+  },
   "files": [
-    "tokens.css"
+    "tokens.css",
+    "bin/scale-guard.mjs",
+    "bin/scale-guard-lib.mjs"
   ],
   "publishConfig": {
     "access": "public"