@techninja/clearstack 0.4.7 → 0.4.8

package/lib/check.js

@@ -4,24 +4,23 @@
  * @module lib/check
  */
 
-import { existsSync, readdirSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { runCmd } from './spec-utils.js';
 import { countFiles, checkFileLines, checkImports } from './spec-scan.js';
 import { checkI18n } from './spec-i18n.js';
 import { loadConfig, buildCmds, detectRunner } from './spec-config.js';
+import { findTypeConfigs } from './spec-types.js';
 
 export { runCmd, elapsed } from './spec-utils.js';
 export { findFiles, countFiles, checkFileLines, checkImports } from './spec-scan.js';
 export { checkI18n } from './spec-i18n.js';
 export { loadConfig, buildCmds, detectRunner } from './spec-config.js';
 
+/** @typedef {{ key: string, name: string, parent?: string, watchExts?: string[], fix?: () => void, run: (opts?: object) => (boolean | import('./spec-utils.js').CheckResult | Promise<import('./spec-utils.js').CheckResult>) }} Check */
+
 /**
- * Load project-level spec extensions from `clearstack.spec.js` in the project root.
- * The file may export a default array of Check objects. Any check whose key matches
- * a built-in check replaces it; new keys are appended.
- * @param {string} projectDir
- * @returns {Promise<Check[]>}
+ *
  */
 async function loadExtensions(projectDir) {
   const extPath = resolve(projectDir, 'clearstack.spec.js');
@@ -29,10 +28,7 @@ async function loadExtensions(projectDir) {
   try {
     const mod = await import(extPath);
     const exts = mod.default ?? [];
-    if (!Array.isArray(exts)) {
-      console.warn('⚠ clearstack.spec.js default export must be an array — extensions ignored');
-      return [];
-    }
+    if (!Array.isArray(exts)) { console.warn('⚠ clearstack.spec.js default export must be an array — extensions ignored'); return []; }
     return exts;
   } catch (e) {
     console.warn(`⚠ Failed to load clearstack.spec.js: ${e.message}`);
@@ -40,56 +36,28 @@ async function loadExtensions(projectDir) {
   }
 }
 
-/** @typedef {{ key: string, name: string, parent?: string, watchExts?: string[], run: (opts?: object) => (boolean | import('./spec-utils.js').CheckResult | Promise<import('./spec-utils.js').CheckResult>) }} Check */
-
-/** Find all jsconfig.json files — main config + subdirectories. */
-function findTypeConfigs(dir, runner) {
-  const main = resolve(dir, '.configs/jsconfig.json');
-  const configs = [];
-  if (existsSync(main)) configs.push({ key: 'frontend', label: 'Frontend', path: main });
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === 'node_modules') continue;
-    const p = resolve(dir, entry.name, 'jsconfig.json');
-    if (existsSync(p)) configs.push({ key: entry.name, label: entry.name, path: p });
-  }
-  return configs.map((c) => ({
-    key: c.key, name: `JSDoc types — ${c.label}`, parent: 'types',
-    run: (o) => runCmd(`Types (${c.label})`, `${runner} tsc --project ${c.path} --noEmit`, dir, undefined, o),
-  }));
-}
-
-/**
- * Build the unified checks array. Children have a `parent` key.
- * Extensions from clearstack.spec.js are merged in: same key = replace, new key = append.
- * @returns {Promise<Check[]>}
- */
+/** Build the unified checks array. Extensions from clearstack.spec.js are merged in. */
 export async function buildChecks(dir, cfg, cmds) {
   const js = () => countFiles(dir, ['.js'], cfg.ignore);
   const css = () => countFiles(dir, ['.css'], cfg.ignore);
   const md = () => countFiles(dir, ['.md'], cfg.ignore);
   const runner = detectRunner(dir);
   const builtin = [
-    { key: 'es', name: 'ESLint', parent: 'lint',
-      run: (o) => runCmd('ESLint', cmds.lint, dir, `${js()} files`, o) },
-    { key: 'css', name: 'Stylelint', parent: 'lint',
-      run: (o) => runCmd('Stylelint', cmds.stylelint, dir, `${css()} files`, o) },
-    { key: 'md', name: 'Markdown lint', parent: 'lint',
-      run: (o) => runCmd('Markdown', cmds.mdlint, dir, `${md()} files`, o) },
-    { key: 'prettier', name: 'Prettier', parent: 'format',
-      run: (o) => runCmd('Prettier', cmds.prettier, dir, `${js()} files`, o) },
-    { key: 'lines', name: `Code (max ${cfg.codeMax} lines)`, parent: 'code',
+    { key: 'es',      name: 'ESLint',      parent: 'lint',   run: (o) => runCmd('ESLint',      cmds.lint,      dir, `${js()} files`, o) },
+    { key: 'css',     name: 'Stylelint',   parent: 'lint',   run: (o) => runCmd('Stylelint',   cmds.stylelint, dir, `${css()} files`, o) },
+    { key: 'md',      name: 'Markdown lint', parent: 'lint', run: (o) => runCmd('Markdown',    cmds.mdlint,    dir, `${md()} files`, o) },
+    { key: 'prettier', name: 'Prettier',   parent: 'format', run: (o) => runCmd('Prettier',    cmds.prettier,  dir, `${js()} files`, o) },
+    { key: 'lines',   name: `Code (max ${cfg.codeMax} lines)`, parent: 'code',
       run: (o) => checkFileLines(dir, cfg.codeExt, cfg.codeMax, cfg.ignore, `Code (max ${cfg.codeMax} lines)`, { exclude: cfg.testPattern, ...o }) },
-    { key: 'i18n', name: 'i18n readiness', parent: 'code',
-      run: (o) => checkI18n(dir, cfg.ignore, 'i18n readiness', o) },
-    { key: 'tests', name: `Tests (max ${cfg.testMax} lines)`,
+    { key: 'i18n',    name: 'i18n readiness', parent: 'code', run: (o) => checkI18n(dir, cfg.ignore, 'i18n readiness', o) },
+    { key: 'tests',   name: `Tests (max ${cfg.testMax} lines)`,
       run: (o) => checkFileLines(dir, cfg.codeExt, cfg.testMax, cfg.ignore, `Tests (max ${cfg.testMax} lines)`, { include: cfg.testPattern, ...o }) },
-    { key: 'docs', name: `Docs (max ${cfg.docsMax} lines)`,
+    { key: 'docs',    name: `Docs (max ${cfg.docsMax} lines)`,
       run: (o) => checkFileLines(dir, cfg.docsExt, cfg.docsMax, cfg.ignore, `Docs (max ${cfg.docsMax} lines)`, o) },
     { key: 'imports', name: 'Import map aliases (no ../ imports)',
       run: (o) => checkImports(dir, cfg.ignore, 'Import map aliases (no ../ imports)', o) },
-    ...findTypeConfigs(dir, runner),
-    { key: 'audit', name: 'Security audit',
-      run: (o) => runCmd('Security audit', cmds.audit, dir, undefined, o) },
+    ...findTypeConfigs(dir, runner, cfg.ignore),
+    { key: 'audit',   name: 'Security audit', run: (o) => runCmd('Security audit', cmds.audit, dir, undefined, o) },
   ];
   const extensions = await loadExtensions(dir);
   if (!extensions.length) return builtin;
@@ -100,10 +68,7 @@ export async function buildChecks(dir, cfg, cmds) {
 /** Resolve a scope like 'lint', 'lint es', or 'code' to runnable check(s). */
 export function resolveChecks(checks, scope) {
   const [first, second] = scope.split(/\s+/);
-  if (second) {
-    const match = checks.find((c) => c.parent === first && c.key === second);
-    return match ? [match] : null;
-  }
+  if (second) { const match = checks.find((c) => c.parent === first && c.key === second); return match ? [match] : null; }
   const children = checks.filter((c) => c.parent === first);
   if (children.length) return children;
   const exact = checks.find((c) => c.key === first && !c.parent);
@@ -115,12 +80,11 @@ export function parentKeys(checks) {
   return [...new Set(checks.filter((c) => c.parent).map((c) => c.parent))];
 }
 
-/** Run the full spec compliance check (used by clearstack CLI and scripts/spec.js). */
+/** Run the full spec compliance check. */
 export async function check(projectDir, scope, opts) {
   const cfg = loadConfig(projectDir);
   const cmds = buildCmds(projectDir);
   const checks = await buildChecks(projectDir, cfg, cmds);
-
   if (scope && scope !== 'all') {
     const matched = resolveChecks(checks, scope);
     if (!matched) {
@@ -130,15 +94,12 @@ export async function check(projectDir, scope, opts) {
       process.exit(1);
     }
     const results = await Promise.all(matched.map((c) => c.run(opts)));
-    const ok = results.every((r) => typeof r === 'boolean' ? r : r.pass);
-    if (!ok) process.exit(1);
+    if (!results.every((r) => typeof r === 'boolean' ? r : r.pass)) process.exit(1);
     return;
   }
-
   console.log('🔍 Clearstack compliance checking now... 💙\n');
   const results = await Promise.all(checks.map((c) => c.run(opts)));
-  const passes = results.map((r) => typeof r === 'boolean' ? r : r.pass);
-  const passed = passes.filter(Boolean).length;
+  const passed = results.filter((r) => typeof r === 'boolean' ? r : r.pass).length;
   console.log(`\n${'='.repeat(40)}`);
   console.log(`${passed}/${results.length} checks passed.`);
   if (passed < results.length) process.exit(1);

package/lib/spec-types.js

@@ -0,0 +1,54 @@
+/**
+ * JSDoc type check helpers — jsconfig discovery and SPEC_IGNORE_DIRS merging.
+ * @module lib/spec-types
+ */
+
+import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { tmpdir } from 'node:os';
+import { runCmd } from './spec-utils.js';
+
+/**
+ * Merge cfg.ignore dirs into a jsconfig's exclude list and write a temp file.
+ * Ensures SPEC_IGNORE_DIRS is the single source of truth for all checks.
+ * @param {string} configPath
+ * @param {string[]} ignore
+ * @returns {string} path to temp jsconfig
+ */
+function mergedTypeConfig(configPath, ignore) {
+  const base = JSON.parse(readFileSync(configPath, 'utf-8'));
+  const root = dirname(configPath);
+  const existing = base.exclude ?? [];
+  const extra = ignore.map((d) => resolve(root, '..', d) + '/**');
+  const out = { ...base, exclude: [...new Set([...existing, ...extra])] };
+  const tmpDir = resolve(tmpdir(), 'clearstack-types');
+  mkdirSync(tmpDir, { recursive: true });
+  const tmpPath = resolve(tmpDir, configPath.replace(/[/\\:]/g, '_') + '.json');
+  writeFileSync(tmpPath, JSON.stringify(out));
+  return tmpPath;
+}
+
+/**
+ * Find all jsconfig.json files and return type check descriptors.
+ * @param {string} dir
+ * @param {string} runner
+ * @param {string[]} ignore
+ * @returns {object[]}
+ */
+export function findTypeConfigs(dir, runner, ignore) {
+  const main = resolve(dir, '.configs/jsconfig.json');
+  const configs = [];
+  if (existsSync(main)) configs.push({ key: 'frontend', label: 'Frontend', path: main });
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+    const p = resolve(dir, entry.name, 'jsconfig.json');
+    if (existsSync(p)) configs.push({ key: entry.name, label: entry.name, path: p });
+  }
+  return configs.map((c) => {
+    const merged = mergedTypeConfig(c.path, ignore);
+    return {
+      key: c.key, name: `JSDoc types — ${c.label}`, parent: 'types',
+      run: (o) => runCmd(`Types (${c.label})`, `${runner} tsc --project ${merged} --noEmit`, dir, undefined, o),
+    };
+  });
+}

package/lib/watch-runner.js

@@ -0,0 +1,97 @@
+/**
+ * Watch runner — check execution, scheduling, and fix dispatch.
+ * @module lib/watch-runner
+ */
+
+import { execSync } from 'node:child_process';
+import { FAST_CHECKS } from './spec-config.js';
+import { render, extractViolations } from './watch-ui.js';
+import { setOnFix } from './watch-widgets.js';
+
+/**
+ * @param {object[]} specRows
+ * @param {Set<string>} keys
+ * @param {{ rows: object[], lastCheck: { value: string }, watchDirs: string[], currentViolations: { value: string[][] }, projectDir: string }} ctx
+ */
+export function runKeys(specRows, keys, ctx) {
+  const { rows, lastCheck, watchDirs, currentViolations, projectDir } = ctx;
+  const toRun = specRows.filter((r) => keys.has(r.key));
+  if (!toRun.length) return;
+  let i = 0;
+  /**
+   *
+   */
+  async function next() {
+    if (i >= toRun.length) {
+      const now = new Date();
+      lastCheck.value = `${now.getHours()}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}`;
+      render(rows, lastCheck.value, watchDirs, currentViolations.value);
+      return;
+    }
+    const row = toRun[i++];
+    row.pass = null;
+    row.detail = '';
+    render(rows, lastCheck.value, watchDirs, currentViolations.value);
+    const t0 = Date.now();
+    const raw = await row.run({ quiet: true });
+    const elapsed = ((Date.now() - t0) / 1000).toFixed(1) + 's';
+    row.result = typeof raw === 'boolean' ? { pass: raw } : raw;
+    row.pass = row.result.pass;
+    row.detail = row.pass
+      ? `${row.result.detail ?? (row.result.files ? `${row.result.files} files` : '')} (${elapsed})`
+      : (row.result.violations?.length
+          ? `${row.result.violations.length} violation(s) (${elapsed})`
+          : (() => { const errs = row.result.errors ?? []; const n = errs.filter((l) => /\.(js|ts|css|md)/.test(l)).length || errs.length; return `${n} error(s) (${elapsed})`; })());
+    currentViolations.value = specRows.flatMap((r) => extractViolations(r, projectDir));
+    render(rows, lastCheck.value, watchDirs, currentViolations.value);
+    setImmediate(next);
+  }
+  setImmediate(next);
+}
+
+/**
+ * @param {object[]} specRows
+ * @param {object} ctx
+ * @param {{ fast: Set<string>, slow: Set<string> }} pending
+ * @param {{ fast: ReturnType<typeof setTimeout>|null, slow: ReturnType<typeof setTimeout>|null }} timers
+ * @param {(keys: Set<string>) => void} run
+ */
+export function schedule(specRows, ctx, pending, timers, run, checksForExt, ext) {
+  for (const k of checksForExt(ext)) {
+    const row = specRows.find((r) => r.key === k);
+    if (row) row.pass = null;
+    if (FAST_CHECKS.has(k)) pending.fast.add(k);
+    else pending.slow.add(k);
+  }
+  render(ctx.rows, ctx.lastCheck.value, ctx.watchDirs, ctx.currentViolations.value);
+  if (pending.fast.size) { clearTimeout(timers.fast); timers.fast = setTimeout(() => { const keys = new Set(pending.fast); pending.fast.clear(); run(keys); }, 50); }
+  if (pending.slow.size) { clearTimeout(timers.slow); timers.slow = setTimeout(() => { const keys = new Set(pending.slow); pending.slow.clear(); run(keys); }, 1500); }
+}
+
+/**
+ * @param {object[]} specRows
+ * @param {object} cmds
+ * @param {object} ctx
+ * @param {{ slow: Set<string> }} pending
+ * @param {{ slow: ReturnType<typeof setTimeout>|null }} timers
+ * @param {(keys: Set<string>) => void} run
+ */
+export function setupFix(specRows, cmds, ctx, pending, timers, run) {
+  setOnFix(() => {
+    const fixable = specRows.filter((r) => !r.pass && (cmds.fix?.[r.key] || r.fix));
+    if (!fixable.length) return;
+    for (const row of fixable) {
+      row.pass = null;
+      pending.slow.add(row.key);
+    }
+    render(ctx.rows, ctx.lastCheck.value, ctx.watchDirs, ctx.currentViolations.value);
+    for (const row of fixable) {
+      try {
+        if (row.fix) row.fix();
+        else execSync(cmds.fix[row.key], { cwd: ctx.projectDir, stdio: 'pipe' });
+      } catch { /* fixer may exit 1 even after fixing */ }
+    }
+    clearTimeout(timers.slow);
+    timers.slow = setTimeout(() => { const keys = new Set(pending.slow); pending.slow.clear(); run(keys); }, 100);
+  });
+}

package/lib/watch.js

@@ -1,28 +1,25 @@
 /**
  * Spec watch dashboard — continuous compliance monitoring.
- * Runs affected checks on file change with 500ms debounce.
- * UI rendering lives in watch-ui.js.
+ * Execution logic lives in watch-runner.js, UI in watch-ui.js.
  * @module lib/watch
  */
 
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { execSync } from 'node:child_process';
-import { loadConfig, buildCmds, makeExtMap, FAST_CHECKS } from './spec-config.js';
+import { loadConfig, buildCmds, makeExtMap } from './spec-config.js';
 import { buildChecks } from './check.js';
-import { render, extractViolations, renderNote } from './watch-ui.js';
+import { render, renderNote } from './watch-ui.js';
 import { spawnServer, detectServerCmd } from './server-proc.js';
 import { setupLifecycle } from './watch-lifecycle.js';
-import { setOnFix } from './watch-widgets.js';
+import { runKeys, schedule, setupFix } from './watch-runner.js';
 
-/** Adapt a Check from buildChecks into a watch row (adds pass/detail/result state). */
-function toRow(check) {
-  return { ...check, pass: null, detail: '', result: null };
-}
+/**
+ *
+ */
+function toRow(check) { return { ...check, pass: null, detail: '', result: null }; }
 
 /**
- * Start the spec watch dashboard.
- * @param {string} projectDir
+ *
  */
 export async function startWatch(projectDir) {
   const cfg = loadConfig(projectDir);
@@ -31,131 +28,41 @@ export async function startWatch(projectDir) {
   const specRows = checks.map(toRow);
   const checksForExt = makeExtMap(checks);
 
-  const watchDirs = ['src', 'scripts', 'docs'].filter((d) =>
-    existsSync(resolve(projectDir, d)),
-  );
-
-  let lastCheck = 'never';
-  let fastTimer = null;
-  let slowTimer = null;
-  /** @type {Set<string>} */
-  const fastPending = new Set();
-  /** @type {Set<string>} */
-  const slowPending = new Set();
+  const watchDirs = ['src', 'scripts', 'docs'].filter((d) => existsSync(resolve(projectDir, d)));
 
-  // Render immediately — server spawns and checks run async behind it
   const serverCmd = detectServerCmd(projectDir, cfg);
-
-  /** @type {import('./server-proc.js').ServerRow|null} */
-  const serverRow = serverCmd ? { key: 'server', label: 'server', status: 'starting', pass: null, detail: 'starting…', kill: () => {} } : null;
+  const serverRow = serverCmd
+    ? { key: 'server', label: 'server', status: 'starting', pass: null, detail: 'starting…', kill: () => {} }
+    : null;
   const rows = serverRow ? [serverRow, ...specRows] : specRows;
 
-  /**
-   *
-   */
-  function spawnAndWatch() {
+  // Shared mutable state passed by reference into runner helpers
+  const lastCheck = { value: 'never' };
+  const currentViolations = { value: [] };
+  const pending = { fast: new Set(), slow: new Set() };
+  const timers = { fast: null, slow: null };
+  const ctx = { rows, lastCheck, watchDirs, currentViolations, projectDir };
+
+  const run = (keys) => runKeys(specRows, keys, ctx);
+
+  if (serverCmd) {
     const proc = spawnServer(serverCmd, projectDir, cfg.rawEnv, () => {
       serverRow.status = proc.status;
       serverRow.pass = proc.pass;
       serverRow.detail = proc.detail;
       serverRow.kill = proc.kill;
-      render(rows, lastCheck, watchDirs, currentViolations);
+      render(rows, lastCheck.value, watchDirs, currentViolations.value);
     });
   }
-  if (serverCmd) spawnAndWatch();
 
-  /** @type {string[][]} */
-  let currentViolations = [];
-  render(rows, lastCheck, watchDirs, currentViolations);
+  render(rows, lastCheck.value, watchDirs, currentViolations.value);
+  run(new Set(specRows.map((r) => r.key)));
 
-  /**
-   *
-   */
-  function runKeys(keys) {
-    const toRun = specRows.filter((r) => keys.has(r.key));
-    if (!toRun.length) return;
-    let i = 0;
-    /**
-     *
-     */
-    async function next() {
-      if (i >= toRun.length) {
-        const now = new Date();
-        lastCheck = `${now.getHours()}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}`;
-        render(rows, lastCheck, watchDirs, currentViolations);
-        return;
-      }
-      const row = toRun[i++];
-      row.pass = null;
-      row.detail = '';
-      render(rows, lastCheck, watchDirs, currentViolations);
-      const t0 = Date.now();
-      const raw = await row.run({ quiet: true });
-      const elapsed = ((Date.now() - t0) / 1000).toFixed(1) + 's';
-      row.result = typeof raw === 'boolean' ? { pass: raw } : raw;
-      row.pass = row.result.pass;
-      row.detail = row.pass
-        ? `${row.result.detail ?? (row.result.files ? `${row.result.files} files` : '')} (${elapsed})`
-        : (row.result.violations?.length
-            ? `${row.result.violations.length} violation(s) (${elapsed})`
-            : (() => { const errs = row.result.errors ?? []; const n = errs.filter((l) => /\.(js|ts|css|md)/.test(l)).length || errs.length; return `${n} error(s) (${elapsed})`; })());
-      // Rebuild violations from all currently-failed rows
-      currentViolations = specRows.flatMap((r) => extractViolations(r, projectDir));
-      render(rows, lastCheck, watchDirs, currentViolations);
-      setImmediate(next);
-    }
-    setImmediate(next);
-  }
-
-  /**
-   *
-   */
-  function runFast() { const keys = new Set(fastPending); fastPending.clear(); runKeys(keys); }
-  /**
-   *
-   */
-  function runSlow() { const keys = new Set(slowPending); slowPending.clear(); runKeys(keys); }
-
-  /**
-   *
-   */
-  function schedule(ext) {
-    for (const k of checksForExt(ext)) {
-      const row = specRows.find((r) => r.key === k);
-      if (row) row.pass = null; // show spinner while queued
-      if (FAST_CHECKS.has(k)) fastPending.add(k);
-      else slowPending.add(k);
-    }
-    render(rows, lastCheck, watchDirs, currentViolations);
-    if (fastPending.size) { clearTimeout(fastTimer); fastTimer = setTimeout(runFast, 50); }
-    if (slowPending.size) { clearTimeout(slowTimer); slowTimer = setTimeout(runSlow, 1500); }
-  }
-
-  runKeys(new Set(specRows.map((r) => r.key)));
-
-  // f key — run fix commands for all currently-failing fixable checks
-  // Checks can provide a fix via cmds.fix[key] (built-ins) or row.fix() (extensions)
-  setOnFix(() => {
-    const fixable = specRows.filter((r) => !r.pass && (cmds.fix?.[r.key] || r.fix));
-    if (!fixable.length) return;
-    for (const row of fixable) {
-      row.pass = null; // show spinner immediately
-      slowPending.add(row.key);
-    }
-    render(rows, lastCheck, watchDirs, currentViolations);
-    for (const row of fixable) {
-      try {
-        if (row.fix) row.fix();
-        else execSync(cmds.fix[row.key], { cwd: projectDir, stdio: 'pipe' });
-      } catch { /* fixer may exit 1 even after fixing */ }
-    }
-    clearTimeout(slowTimer);
-    slowTimer = setTimeout(runSlow, 100);
-  });
+  setupFix(specRows, cmds, ctx, pending, timers, run);
 
   setupLifecycle({
     serverRow, specRows, projectDir, watchDirs,
-    schedule,
-    renderNote: () => renderNote(rows, lastCheck, watchDirs),
+    schedule: (ext) => schedule(specRows, ctx, pending, timers, run, checksForExt, ext),
+    renderNote: () => renderNote(rows, lastCheck.value, watchDirs),
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@techninja/clearstack",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "type": "module",
   "description": "A no-build web component framework specification — scaffold, validate, and evolve spec-compliant projects",
   "bin": {