@weft-js/cli 0.1.1 → 0.1.3

package/src/mutate.mjs

@@ -8,12 +8,22 @@ import { parse } from './tests.mjs'
 
 const K = ts.SyntaxKind
 const swaps = new Map([
-  [K.EqualsEqualsEqualsToken, ['!==']], [K.ExclamationEqualsEqualsToken, ['===']],
-  [K.EqualsEqualsToken, ['!=']], [K.ExclamationEqualsToken, ['==']],
-  [K.LessThanToken, ['<=', '>=']], [K.LessThanEqualsToken, ['<', '>']],
-  [K.GreaterThanToken, ['>=', '<=']], [K.GreaterThanEqualsToken, ['>', '<']],
-  [K.AmpersandAmpersandToken, ['||']], [K.BarBarToken, ['&&']], [K.QuestionQuestionToken, ['&&']],
-  [K.PlusToken, ['-']], [K.MinusToken, ['+']], [K.AsteriskToken, ['/']], [K.SlashToken, ['*']], [K.PercentToken, ['*']],
+  [K.EqualsEqualsEqualsToken, ['!==']],
+  [K.ExclamationEqualsEqualsToken, ['===']],
+  [K.EqualsEqualsToken, ['!=']],
+  [K.ExclamationEqualsToken, ['==']],
+  [K.LessThanToken, ['<=', '>=']],
+  [K.LessThanEqualsToken, ['<', '>']],
+  [K.GreaterThanToken, ['>=', '<=']],
+  [K.GreaterThanEqualsToken, ['>', '<']],
+  [K.AmpersandAmpersandToken, ['||']],
+  [K.BarBarToken, ['&&']],
+  [K.QuestionQuestionToken, ['&&']],
+  [K.PlusToken, ['-']],
+  [K.MinusToken, ['+']],
+  [K.AsteriskToken, ['/']],
+  [K.SlashToken, ['*']],
+  [K.PercentToken, ['*']],
 ])
 
 /** Lines (1-based) of `after` that are new or changed since `before` (null: every line). LCS over lines. */
@@ -24,17 +34,30 @@ export function changedLines(before, after) {
   // Trim the common head and tail; the middle is usually small.
   let start = 0
   while (start < a.length && start < b.length && a[start] === b[start]) start++
-  let ea = a.length, eb = b.length
-  while (ea > start && eb > start && a[ea - 1] === b[eb - 1]) { ea--; eb-- }
-  const A = a.slice(start, ea), B = b.slice(start, eb)
+  let ea = a.length,
+    eb = b.length
+  while (ea > start && eb > start && a[ea - 1] === b[eb - 1]) {
+    ea--
+    eb--
+  }
+  const A = a.slice(start, ea),
+    B = b.slice(start, eb)
   const out = new Set()
-  if (A.length * B.length > 4e6) { for (let i = start; i < eb; i++) out.add(i + 1); return out }
+  if (A.length * B.length > 4e6) {
+    for (let i = start; i < eb; i++) out.add(i + 1)
+    return out
+  }
   const dp = Array.from({ length: A.length + 1 }, () => new Uint32Array(B.length + 1))
-  for (let i = A.length - 1; i >= 0; i--) for (let j = B.length - 1; j >= 0; j--) dp[i][j] = A[i] === B[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1])
-  let i = 0, j = 0
+  for (let i = A.length - 1; i >= 0; i--)
+    for (let j = B.length - 1; j >= 0; j--)
+      dp[i][j] = A[i] === B[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1])
+  let i = 0,
+    j = 0
   while (j < B.length) {
-    if (i < A.length && A[i] === B[j]) { i++; j++ }
-    else if (i < A.length && dp[i + 1][j] >= dp[i][j + 1]) i++
+    if (i < A.length && A[i] === B[j]) {
+      i++
+      j++
+    } else if (i < A.length && dp[i + 1][j] >= dp[i][j + 1]) i++
     else out.add(start + ++j)
   }
   return out
@@ -53,10 +76,26 @@ export function mutants(text, rel, lines) {
     if (!lines.has(line)) return
     const original = text.slice(start, end)
     if (original === replacement) return
-    out.push({ id: `${rel}:${line}:${column}:${op}:${out.length}`, file: rel, line, column, op, start, end, original, replacement })
+    out.push({
+      id: `${rel}:${line}:${column}:${op}:${out.length}`,
+      file: rel,
+      line,
+      column,
+      op,
+      start,
+      end,
+      original,
+      replacement,
+    })
   }
-  const skip = n => ts.isImportDeclaration(n) || ts.isExportDeclaration(n) || ts.isTypeNode(n) || ts.isInterfaceDeclaration(n) || ts.isTypeAliasDeclaration(n) || ts.isEnumDeclaration(n)
-  const visit = n => {
+  const skip = (n) =>
+    ts.isImportDeclaration(n) ||
+    ts.isExportDeclaration(n) ||
+    ts.isTypeNode(n) ||
+    ts.isInterfaceDeclaration(n) ||
+    ts.isTypeAliasDeclaration(n) ||
+    ts.isEnumDeclaration(n)
+  const visit = (n) => {
     if (skip(n)) return
     if (ts.isBinaryExpression(n)) {
       for (const r of swaps.get(n.operatorToken.kind) ?? []) add(n.operatorToken, 'operator', r)
@@ -67,7 +106,11 @@ export function mutants(text, rel, lines) {
     } else if (ts.isNumericLiteral(n)) {
       const v = Number(n.text)
       if (Number.isFinite(v)) add(n, 'number', String(v === 0 ? 1 : v + 1))
-    } else if ((ts.isStringLiteral(n) || ts.isNoSubstitutionTemplateLiteral(n)) && n.text && !isKey(n)) {
+    } else if (
+      (ts.isStringLiteral(n) || ts.isNoSubstitutionTemplateLiteral(n)) &&
+      n.text &&
+      !isKey(n)
+    ) {
       add(n, 'string', '""')
     } else if (ts.isConditionalExpression(n)) {
       add(n.condition, 'condition', 'true')
@@ -75,12 +118,22 @@ export function mutants(text, rel, lines) {
     } else if (ts.isIfStatement(n)) {
       add(n.expression, 'condition', 'true')
       add(n.expression, 'condition', 'false')
-    } else if (ts.isExpressionStatement(n) && ts.isCallExpression(unparen(n.expression)) && !isDirective(n)) {
+    } else if (
+      ts.isExpressionStatement(n) &&
+      ts.isCallExpression(unparen(n.expression)) &&
+      !isDirective(n)
+    ) {
       add(n, 'call', ';')
     } else if (ts.isJsxText(n) && n.text.trim()) {
       const start = n.pos + n.text.indexOf(n.text.trim()) // JSX text: `text` starts at `pos`, before any trivia
       add(n, 'jsx-text', '', start, start + n.text.trim().length)
-    } else if (ts.isReturnStatement(n) && n.expression && isFn(n.parent?.parent) && !ts.isJsxElement(unparen(n.expression)) && !ts.isJsxFragment(unparen(n.expression))) {
+    } else if (
+      ts.isReturnStatement(n) &&
+      n.expression &&
+      isFn(n.parent?.parent) &&
+      !ts.isJsxElement(unparen(n.expression)) &&
+      !ts.isJsxFragment(unparen(n.expression))
+    ) {
       add(n.expression, 'return', 'undefined')
     }
     ts.forEachChild(n, visit)
@@ -89,14 +142,29 @@ export function mutants(text, rel, lines) {
   return out
 }
 
-const unparen = n => { while (ts.isParenthesizedExpression(n)) n = n.expression; return n }
-const isFn = n => n && (ts.isFunctionDeclaration(n) || ts.isFunctionExpression(n) || ts.isArrowFunction(n) || ts.isMethodDeclaration(n))
-const isDirective = n => ts.isStringLiteral(n.expression)
+const unparen = (n) => {
+  while (ts.isParenthesizedExpression(n)) n = n.expression
+  return n
+}
+const isFn = (n) =>
+  n &&
+  (ts.isFunctionDeclaration(n) ||
+    ts.isFunctionExpression(n) ||
+    ts.isArrowFunction(n) ||
+    ts.isMethodDeclaration(n))
+const isDirective = (n) => ts.isStringLiteral(n.expression)
 /** Strings that name things rather than being data: property keys, element-access keys, `import()` specifiers. */
-const isKey = n => {
+const isKey = (n) => {
   const p = n.parent
-  return (ts.isPropertyAssignment(p) && p.name === n) || ts.isElementAccessExpression(p) || ts.isLiteralTypeNode(p) || ts.isExternalModuleReference(p) ||
-    (ts.isCallExpression(p) && p.expression.kind === K.ImportKeyword) || ts.isJsxAttribute(p) && /^(key|class|className|style|id|type|role|for|htmlFor|name)$/.test(p.name.getText())
+  return (
+    (ts.isPropertyAssignment(p) && p.name === n) ||
+    ts.isElementAccessExpression(p) ||
+    ts.isLiteralTypeNode(p) ||
+    ts.isExternalModuleReference(p) ||
+    (ts.isCallExpression(p) && p.expression.kind === K.ImportKeyword) ||
+    (ts.isJsxAttribute(p) &&
+      /^(key|class|className|style|id|type|role|for|htmlFor|name)$/.test(p.name.getText()))
+  )
 }
 
 export const apply = (text, m) => text.slice(0, m.start) + m.replacement + text.slice(m.end)
@@ -114,7 +182,12 @@ export function sample(list, max) {
   const out = []
   for (let round = 0; out.length < max; round++) {
     let any = false
-    for (const q of queues) if (q[round]) { out.push(q[round]); any = true; if (out.length >= max) break }
+    for (const q of queues)
+      if (q[round]) {
+        out.push(q[round])
+        any = true
+        if (out.length >= max) break
+      }
     if (!any) break
   }
   return out
@@ -125,16 +198,27 @@ export function suggest(m) {
   const at = `${m.file}:${m.line}`
   switch (m.op) {
     case 'operator':
-      if (/^[<>]=?$/.test(m.original)) return `${at}: \`${m.original}\` → \`${m.replacement}\` survives. Assert the boundary: the value exactly at the limit.`
-      if (/^(&&|\|\||\?\?)$/.test(m.original)) return `${at}: \`${m.original}\` → \`${m.replacement}\` survives. Assert a case where only one side of the condition holds.`
-      if (/^[!=]=/.test(m.original)) return `${at}: \`${m.original}\` → \`${m.replacement}\` survives. Assert both the matching and the non-matching case.`
+      if (/^[<>]=?$/.test(m.original))
+        return `${at}: \`${m.original}\` → \`${m.replacement}\` survives. Assert the boundary: the value exactly at the limit.`
+      if (/^(&&|\|\||\?\?)$/.test(m.original))
+        return `${at}: \`${m.original}\` → \`${m.replacement}\` survives. Assert a case where only one side of the condition holds.`
+      if (/^[!=]=/.test(m.original))
+        return `${at}: \`${m.original}\` → \`${m.replacement}\` survives. Assert both the matching and the non-matching case.`
       return `${at}: \`${m.original}\` → \`${m.replacement}\` survives. Assert the computed value, not only that something rendered.`
-    case 'boolean': case 'condition': case 'negation':
+    case 'boolean':
+    case 'condition':
+    case 'negation':
       return `${at}: \`${m.original}\` → \`${m.replacement}\` survives. Assert what the user sees on the branch this condition guards.`
-    case 'number': return `${at}: ${m.original} → ${m.replacement} survives. Assert the exact value this number produces.`
-    case 'string': case 'jsx-text': return `${at}: the text ${JSON.stringify(m.original.slice(0, 40))} can be blanked. Assert the text the user sees.`
-    case 'call': return `${at}: removing \`${m.original.slice(0, 60)}\` survives. Assert the effect of that call.`
-    case 'return': return `${at}: returning undefined survives. Assert what this function's result shows.`
-    default: return `${at}: ${m.op} survives`
+    case 'number':
+      return `${at}: ${m.original} → ${m.replacement} survives. Assert the exact value this number produces.`
+    case 'string':
+    case 'jsx-text':
+      return `${at}: the text ${JSON.stringify(m.original.slice(0, 40))} can be blanked. Assert the text the user sees.`
+    case 'call':
+      return `${at}: removing \`${m.original.slice(0, 60)}\` survives. Assert the effect of that call.`
+    case 'return':
+      return `${at}: returning undefined survives. Assert what this function's result shows.`
+    default:
+      return `${at}: ${m.op} survives`
   }
 }

package/src/plugin-checks.mjs

@@ -16,13 +16,14 @@ import { importOf, scanJsx } from './jsx-scan.mjs'
  */
 export async function pluginChecks(root, loaded, { files, exclude = [] }) {
   const out = []
-  const texts = new Map(files.map(f => [f.rel, f.text]))
-  const read = rel => {
-    if (!texts.has(rel)) texts.set(rel, existsSync(join(root, rel)) ? readFileSync(join(root, rel), 'utf8') : '')
+  const texts = new Map(files.map((f) => [f.rel, f.text]))
+  const read = (rel) => {
+    if (!texts.has(rel))
+      texts.set(rel, existsSync(join(root, rel)) ? readFileSync(join(root, rel), 'utf8') : '')
     return texts.get(rel)
   }
   const scans = new Map()
-  const jsx = rel => {
+  const jsx = (rel) => {
     if (!scans.has(rel)) {
       try {
         scans.set(rel, scanJsx(read(rel), rel))
@@ -39,9 +40,12 @@ export async function pluginChecks(root, loaded, { files, exclude = [] }) {
     const include = hook.include ?? ['**/*.{tsx,jsx}']
     const wanted = matcher(include)
     /** @type {Set<string>} */
-    const chosen = new Set([...files.map(f => f.rel).filter(wanted), ...discover(root, { include, exclude })])
+    const chosen = new Set([
+      ...files.map((f) => f.rel).filter(wanted),
+      ...discover(root, { include, exclude }),
+    ])
     const rels = [...chosen].sort()
-    const declared = new Map((c.manifest.diagnostics ?? []).map(d => [d.code, d]))
+    const declared = new Map((c.manifest.diagnostics ?? []).map((d) => [d.code, d]))
     const ctx = Object.freeze({
       root,
       files: rels,
@@ -49,26 +53,47 @@ export async function pluginChecks(root, loaded, { files, exclude = [] }) {
       jsx,
       importOf,
       slots: loaded.slots ?? {},
-      exists: rel => existsSync(join(root, rel)),
-      bytes: rel => (existsSync(join(root, rel)) ? new Uint8Array(readFileSync(join(root, rel))) : undefined),
+      exists: (rel) => existsSync(join(root, rel)),
+      bytes: (rel) =>
+        existsSync(join(root, rel)) ? new Uint8Array(readFileSync(join(root, rel))) : undefined,
     })
     let found
     try {
       found = (await hook.run(ctx)) ?? []
     } catch (error) {
-      out.push(diagnostic({ code: 'P119', owner: c.name, file: 'weft.config.ts', why: `\`${c.name}\`'s check hook threw: ${String(error?.message ?? error).split('\n')[0]}` }))
+      out.push(
+        diagnostic({
+          code: 'P119',
+          owner: c.name,
+          file: 'weft.config.ts',
+          why: `\`${c.name}\`'s check hook threw: ${String(error?.message ?? error).split('\n')[0]}`,
+        }),
+      )
       continue
     }
-    for (const d of found) {
-      if (!d.code.startsWith(c.namespace)) {
-        out.push(diagnostic({ code: 'P111', file: 'weft.config.ts', why: `\`${c.name}\`'s check reported \`${d.code}\`, outside its namespace \`${c.namespace}\`.` }))
-        continue
-      }
-      const text = read(d.file)
-      const pos = positions(text)
-      const [start, end] = [d.start ?? 0, d.end ?? d.start ?? 0]
-      const meta = declared.get(d.code)
-      out.push(diagnostic({
+    appendFindings({ found, c, out, declared, read })
+  }
+  return out
+}
+
+function appendFindings({ found, c, out, declared, read }) {
+  for (const d of found) {
+    if (!d.code.startsWith(c.namespace)) {
+      out.push(
+        diagnostic({
+          code: 'P111',
+          file: 'weft.config.ts',
+          why: `\`${c.name}\`'s check reported \`${d.code}\`, outside its namespace \`${c.namespace}\`.`,
+        }),
+      )
+      continue
+    }
+    const text = read(d.file)
+    const pos = positions(text)
+    const [start, end] = [d.start ?? 0, d.end ?? d.start ?? 0]
+    const meta = declared.get(d.code)
+    out.push(
+      diagnostic({
         code: d.code,
         owner: c.name,
         severity: d.severity ?? meta?.severity ?? 'error',
@@ -80,10 +105,14 @@ export async function pluginChecks(root, loaded, { files, exclude = [] }) {
         fix: d.fix && {
           description: d.fix.description,
           safe: d.fix.safe === true,
-          edits: d.fix.edits.map(e => ({ file: e.file ?? d.file, span: positions(read(e.file ?? d.file)).span(e.start, e.end), offset: [e.start, e.end], text: e.text })),
+          edits: d.fix.edits.map((e) => ({
+            file: e.file ?? d.file,
+            span: positions(read(e.file ?? d.file)).span(e.start, e.end),
+            offset: [e.start, e.end],
+            text: e.text,
+          })),
         },
-      }))
-    }
+      }),
+    )
   }
-  return out
 }

package/src/plugins.mjs

@@ -7,15 +7,16 @@ import { loadConfig } from './load-config.mjs'
 import { slotDef } from './slots.mjs'
 
 const byName = (a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0)
-const header = '// Generated from weft.config.ts. Do not edit: change weft.config.ts and run `weft plugins sync`.'
+const header =
+  '// Generated from weft.config.ts. Do not edit: change weft.config.ts and run `weft plugins sync`.'
 
-const posix = p => p.split('\\').join('/')
-const slotFile = id => `.weft/slots/${id}.ts`
+const posix = (p) => p.split('\\').join('/')
+const slotFile = (id) => `.weft/slots/${id}.ts`
 
 /** The ProviderRef a bound plugin declared for `slot` (and `key`). */
 function providerRef(loaded, plugin, slot, key = '') {
-  const c = loaded.contributions.find(x => x.name === plugin)
-  return c?.manifest.provides?.find(p => p.slot.id === slot && (p.key ?? '') === key) ?? null
+  const c = loaded.contributions.find((x) => x.name === plugin)
+  return c?.manifest.provides?.find((p) => p.slot.id === slot && (p.key ?? '') === key) ?? null
 }
 
 /** `module` relative to `.weft/slots/` when the plugin gave a relative path from the project root. */
@@ -28,28 +29,55 @@ function specifier(root, module) {
 
 function loader(root, ref) {
   const side = ref.sides.client ?? ref.sides[Object.keys(ref.sides).sort()[0]]
-  if (!side) return { comment: 'no sides', code: `() => Promise.reject(new Error('provider declares no module'))` }
-  const call = side.options === undefined ? `m[${JSON.stringify(side.export)}]` : `m[${JSON.stringify(side.export)}](${JSON.stringify(side.options)})`
-  return { comment: Object.keys(ref.sides).sort().join(', '), code: `() => import(${JSON.stringify(specifier(root, side.module))}).then(m => ${call})` }
+  if (!side)
+    return {
+      comment: 'no sides',
+      code: `() => Promise.reject(new Error('provider declares no module'))`,
+    }
+  const call =
+    side.options === undefined
+      ? `m[${JSON.stringify(side.export)}]`
+      : `m[${JSON.stringify(side.export)}](${JSON.stringify(side.options)})`
+  return {
+    comment: Object.keys(ref.sides).sort().join(', '),
+    code: `() => import(${JSON.stringify(specifier(root, side.module))}).then(m => ${call})`,
+  }
 }
 
-const unbound = id =>
+const unbound = (id) =>
   `export const provider = null\nexport const load = (): never => {\n  throw Object.assign(new Error(${JSON.stringify(`P101 ${id}: nothing provides this slot. Add a plugin that provides it to \`plugins\` in weft.config.ts.`)}), { code: 'P101' })\n}\n`
 const builtin = (id, name) =>
   `export const provider = ${JSON.stringify(name)}\nexport const load = (): never => {\n  throw new Error(${JSON.stringify(`${id}: built in, provided by weft (${name}).`)})\n}\n`
 
+function addCssEntries(files, c) {
+  const t = c.manifest.tokens
+  if (t?.cssEntries === undefined) return
+  if (!t.cssEntries || typeof t.cssEntries !== 'object' || Array.isArray(t.cssEntries))
+    throw new TypeError('tokens.cssEntries must be an object')
+  for (const [name, css] of Object.entries(t.cssEntries)) {
+    if (!/^[a-z][a-z0-9-]*$/.test(name) || typeof css !== 'string')
+      throw new TypeError(`Invalid tokens.cssEntries entry: ${name}`)
+    files[`.weft/tokens/${t.namespace}.${name}.css`] =
+      `/* Generated from weft.config.ts (${c.name}). Do not edit. */\n${css}`
+  }
+}
+
 /** File contents for every slot module, the slots.d.ts and token CSS, keyed by path relative to the root. */
 export function generated(root, loaded) {
   const files = {}
   const typed = []
   for (const [id, binding] of Object.entries(loaded.slots).sort(([a], [b]) => (a < b ? -1 : 1))) {
-    const def = slotDef(id) ?? { version: 1, cardinality: typeof binding === 'object' && binding ? 'keyed' : 'one' }
+    const def = slotDef(id) ?? {
+      version: 1,
+      cardinality: typeof binding === 'object' && binding ? 'keyed' : 'one',
+    }
     let body
     if (def.cardinality === 'one') {
-      const ref = binding && !binding.startsWith('weft:default') ? providerRef(loaded, binding, id) : null
+      const ref =
+        binding && !binding.startsWith('weft:default') ? providerRef(loaded, binding, id) : null
       if (ref) {
         const l = loader(root, ref)
-        const plugin = loaded.contributions.find(x => x.name === binding)
+        const plugin = loaded.contributions.find((x) => x.name === binding)
         body = `// provider: ${binding}@${plugin.version} · implements ${id}@${ref.versions.join(',')} · sides: ${l.comment}\nexport const provider = ${JSON.stringify({ plugin: binding, version: plugin.version, interface: Math.max(...ref.versions) })} as const\nexport const load = ${l.code}\n`
         typed.push(id)
       } else if (binding?.startsWith('weft:default')) body = builtin(id, binding)
@@ -58,8 +86,9 @@ export function generated(root, loaded) {
       const lines = []
       const providers = {}
       for (const [key, name] of Object.entries(binding ?? {})) {
-        const ref = name && !name.startsWith('weft:default') ? providerRef(loaded, name, id, key) : null
-        providers[key] = ref ? name : name ?? null
+        const ref =
+          name && !name.startsWith('weft:default') ? providerRef(loaded, name, id, key) : null
+        providers[key] = ref ? name : (name ?? null)
         if (ref) lines.push(`  ${JSON.stringify(key)}: ${loader(root, ref).code},`)
       }
       body = `export const providers = ${JSON.stringify(providers)} as const\nconst loaders: Record<string, () => Promise<unknown>> = {\n${lines.join('\n')}${lines.length ? '\n' : ''}}\nexport const load = (key: string): Promise<unknown> => {\n  const l = loaders[key]\n  if (l) return l()\n  throw Object.assign(new Error(\`P101 ${id} key \${key}: \${providers[key as keyof typeof providers] ? 'built in, provided by weft' : 'nothing provides it'}.\`), { code: 'P101' })\n}\n`
@@ -72,26 +101,45 @@ export function generated(root, loaded) {
     if (binding && typeof binding === 'object') {
       const keys = {}
       for (const [key, name] of Object.entries(binding)) {
-        const side = name && !name.startsWith('weft:default') ? providerRef(loaded, name, id, key)?.sides.build : null
-        if (side) keys[key] = { plugin: name, module: side.module, export: side.export, options: side.options }
+        const side =
+          name && !name.startsWith('weft:default')
+            ? providerRef(loaded, name, id, key)?.sides.build
+            : null
+        if (side)
+          keys[key] = {
+            plugin: name,
+            module: side.module,
+            export: side.export,
+            options: side.options,
+          }
       }
-      if (Object.keys(keys).length) files[`.weft/slots/${id}.build.json`] = `${JSON.stringify({ keys }, null, 2)}\n`
+      if (Object.keys(keys).length)
+        files[`.weft/slots/${id}.build.json`] = `${JSON.stringify({ keys }, null, 2)}\n`
       continue
     }
     if (typeof binding !== 'string' || binding.startsWith('weft:default')) continue
     const side = providerRef(loaded, binding, id)?.sides.build
     if (!side) continue
-    const plugin = loaded.contributions.find(x => x.name === binding)
+    const plugin = loaded.contributions.find((x) => x.name === binding)
     const module = side.module.startsWith('.') ? posix(resolve(root, side.module)) : side.module
-    files[`.weft/slots/${id}.build.json`] = `${JSON.stringify({ plugin: binding, version: plugin.version, module, export: side.export, ...(side.options === undefined ? {} : { options: side.options }) }, null, 2)}\n`
+    files[`.weft/slots/${id}.build.json`] =
+      `${JSON.stringify({ plugin: binding, version: plugin.version, module, export: side.export, ...(side.options === undefined ? {} : { options: side.options }) }, null, 2)}\n`
   }
-  files['.weft/slots.d.ts'] = `${header}\n// Only bound slots are declared: importing an unbound one is a type error (P101).\n${typed
-    .map(id => `declare module 'weft:slot/${id}' {\n  export const provider: unknown\n  export const providers: Record<string, unknown>\n  export const load: (key?: string) => Promise<any>\n}\n`)
-    .join('')}`
+  files['.weft/slots.d.ts'] =
+    `${header}\n// Only bound slots are declared: importing an unbound one is a type error (P101).\n${typed
+      .map(
+        (id) =>
+          `declare module 'weft:slot/${id}' {\n  export const provider: unknown\n  export const providers: Record<string, unknown>\n  export const load: (key?: string) => Promise<any>\n}\n`,
+      )
+      .join('')}`
   for (const c of loaded.contributions) {
     const t = c.manifest.tokens
-    if (t?.css) files[`.weft/tokens/${t.namespace}.css`] = `/* Generated from weft.config.ts (${c.name}). Do not edit. */\n${t.css}`
-    if (t?.alias) files[`.weft/tokens/${t.namespace}.alias.json`] = `${JSON.stringify(t.alias, null, 2)}\n`
+    if (t?.css)
+      files[`.weft/tokens/${t.namespace}.css`] =
+        `/* Generated from weft.config.ts (${c.name}). Do not edit. */\n${t.css}`
+    addCssEntries(files, c)
+    if (t?.alias)
+      files[`.weft/tokens/${t.namespace}.alias.json`] = `${JSON.stringify(t.alias, null, 2)}\n`
   }
   return files
 }
@@ -120,14 +168,21 @@ export function sync(root, loaded) {
 export async function list(root) {
   root = resolve(root)
   const loaded = await loadConfig(root)
-  const unique = (loaded.config.plugins ?? []).filter((p, i, all) => all.findIndex(q => q.name === p.name) === i)
-  const plugins = [...unique].sort(byName).map(p => {
-    const c = loaded.contributions.find(x => x.name === p.name)
-    const provides = (p.provides ?? []).map(item => {
+  const unique = (loaded.config.plugins ?? []).filter(
+    (p, i, all) => all.findIndex((q) => q.name === p.name) === i,
+  )
+  const plugins = [...unique].sort(byName).map((p) => {
+    const c = loaded.contributions.find((x) => x.name === p.name)
+    const provides = (p.provides ?? []).map((item) => {
       const { slot, key } = typeof item === 'string' ? { slot: item } : item
       const binding = loaded.slots[slot]
       const bound = key ? binding?.[key] === p.name : binding === p.name
-      return { slot, ...(key ? { key } : {}), interface: providerRef(loaded, p.name, slot, key)?.versions ?? null, bound }
+      return {
+        slot,
+        ...(key ? { key } : {}),
+        interface: providerRef(loaded, p.name, slot, key)?.versions ?? null,
+        bound,
+      }
     })
     return {
       name: p.name,
@@ -135,38 +190,69 @@ export async function list(root) {
       provides,
       permissions: c?.permissions ?? {},
       namespace: c?.namespace ?? null,
-      diagnostics: (c?.manifest.diagnostics ?? []).map(d => d.code),
+      diagnostics: (c?.manifest.diagnostics ?? []).map((d) => d.code),
       tokens: c?.manifest.tokens?.namespace ?? null,
-      catalog: (c?.manifest.catalog ?? []).map(e => e.name),
+      catalog: (c?.manifest.catalog ?? []).map((e) => e.name),
       agents: c?.manifest.agents?.title ?? null,
     }
   })
-  return { ok: !loaded.diagnostics.some(d => d.severity === 'error'), plugins, slots: loaded.slots, diagnostics: loaded.diagnostics }
+  return {
+    ok: !loaded.diagnostics.some((d) => d.severity === 'error'),
+    plugins,
+    slots: loaded.slots,
+    diagnostics: loaded.diagnostics,
+  }
 }
 
 /** `weft plugins explain <slot> --json`: config entry → plugin → module → generated file. */
 export async function explain(root, id) {
   root = resolve(root)
   const loaded = await loadConfig(root)
-  if (!id || !(id in loaded.slots)) throw Object.assign(new Error(`unknown slot ${id ?? '(none)'}; known: ${Object.keys(loaded.slots).join(', ')}`), { code: 'E_USAGE' })
+  if (!id || !(id in loaded.slots))
+    throw Object.assign(
+      new Error(`unknown slot ${id ?? '(none)'}; known: ${Object.keys(loaded.slots).join(', ')}`),
+      { code: 'E_USAGE' },
+    )
   const binding = loaded.slots[id]
   const def = slotDef(id) ?? null
-  const chain = key => {
+  const chain = (key) => {
     const name = key === undefined ? binding : binding?.[key]
     if (!name) return { provider: null, why: 'nothing provides it (P101 for consumers)' }
-    if (name.startsWith('weft:default')) return { provider: name, why: 'built in, provided by weft' }
+    if (name.startsWith('weft:default'))
+      return { provider: name, why: 'built in, provided by weft' }
     const ref = providerRef(loaded, name, id, key ?? '')
     const side = ref && (ref.sides.client ?? ref.sides[Object.keys(ref.sides).sort()[0]])
     return {
       config: loaded.file ? posix(relative(root, loaded.file)) : null,
       chosenBy: loaded.config.slots?.[id] ? 'slots' : 'only provider',
       plugin: name,
-      version: loaded.contributions.find(c => c.name === name)?.version ?? null,
+      version: loaded.contributions.find((c) => c.name === name)?.version ?? null,
       interface: ref?.versions ?? null,
       sides: ref ? Object.keys(ref.sides).sort() : [],
-      module: side ? { module: side.module, export: side.export, ...(side.options === undefined ? {} : { options: side.options }) } : null,
+      module: side
+        ? {
+            module: side.module,
+            export: side.export,
+            ...(side.options === undefined ? {} : { options: side.options }),
+          }
+        : null,
     }
   }
-  const bindings = def?.cardinality === 'keyed' || (binding && typeof binding === 'object') ? Object.fromEntries(Object.keys(binding ?? {}).sort().map(k => [k, chain(k)])) : chain()
-  return { slot: id, version: def?.version ?? null, cardinality: def?.cardinality ?? 'one', sides: def?.sides ?? [], binding: bindings, file: slotFile(id), import: `weft:slot/${id}` }
+  const bindings =
+    def?.cardinality === 'keyed' || (binding && typeof binding === 'object')
+      ? Object.fromEntries(
+          Object.keys(binding ?? {})
+            .sort()
+            .map((k) => [k, chain(k)]),
+        )
+      : chain()
+  return {
+    slot: id,
+    version: def?.version ?? null,
+    cardinality: def?.cardinality ?? 'one',
+    sides: def?.sides ?? [],
+    binding: bindings,
+    file: slotFile(id),
+    import: `weft:slot/${id}`,
+  }
 }