@progen-labs/spectra 0.0.0-stage → 0.1.1

package/server/explore/evaluate.js

@@ -0,0 +1,165 @@
+/**
+ * Evaluation orchestrator: the engine behind `spectra performance`.
+ *
+ * Connects once, records a baseline page-load, discovers the actionable
+ * surface, synthesizes golden paths, and runs each path as its own live
+ * recording. Every path therefore produces a standard report (persisted by the
+ * recorder to REPORTS_DIR) that the dashboard renders with all existing
+ * features — culprits, PDF export, commit compare. The aggregate returned here
+ * is the performance matrix across those reports.
+ */
+import { PerfSession, readReport } from '../recorder.js';
+import { TARGET_NAME } from '../config.js';
+import { discoverActionables } from './discover.js';
+import { synthesizePaths } from './paths.js';
+import { runPath } from './runner.js';
+
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+function summarizeReport(report) {
+  const v = report.vitals || {};
+  const top = (report.findings || [])[0];
+  return {
+    tbtMs: v.tbtMs ?? null,
+    longTaskCount: v.longTaskCount ?? null,
+    lcpMs: v.lcpMs ?? null,
+    fcpMs: v.fcpMs ?? null,
+    cls: v.cls ?? null,
+    forcedLayoutCount: report.totals?.forcedLayoutCount ?? null,
+    findingCount: (report.findings || []).length,
+    topFinding: top
+      ? { severity: top.severity, category: top.category, title: top.title }
+      : null,
+  };
+}
+
+/** Record the baseline page load (load mode self-stops after settle). */
+function recordBaseline(session) {
+  return new Promise((resolve, reject) => {
+    const onReport = r => {
+      cleanup();
+      resolve(r.id);
+    };
+    const onState = s => {
+      if (s.error) {
+        cleanup();
+        reject(new Error(s.error));
+      }
+    };
+    const cleanup = () => {
+      session.off('report', onReport);
+      session.off('state', onState);
+    };
+    session.on('report', onReport);
+    session.on('state', onState);
+    session.start({ mode: 'load' }).catch(err => {
+      cleanup();
+      reject(err);
+    });
+  });
+}
+
+/**
+ * @param {object} opts
+ * @param {string} opts.url            start URL (already reachable)
+ * @param {boolean} [opts.headless]    default true
+ * @param {number} [opts.limit]        max golden paths (default 12)
+ * @param {string[]} [opts.allow]      selectors of destructive actions to permit
+ * @param {string} [opts.signIn]       sign-in URL template
+ * @param {(ev:object)=>void} [opts.onProgress]
+ */
+export async function runEvaluation({
+  url,
+  headless = true,
+  limit = 12,
+  allow = [],
+  signIn,
+  onProgress,
+} = {}) {
+  const log = onProgress || (() => {});
+  const session = new PerfSession();
+  const results = [];
+  try {
+    await session.connect({ mode: 'launch', url, headless, signIn });
+    // Auto-dismiss alert/confirm/beforeunload dialogs so a journey can't hang.
+    if (session.page) {
+      session.page.on('dialog', d => d.dismiss().catch(() => {}));
+    }
+    await sleep(1200);
+    await session.reload(); // make sure the probe is installed before load
+    await sleep(800);
+
+    // 1) Baseline page-load profile.
+    log({ phase: 'baseline' });
+    const loadId = await recordBaseline(session);
+    const baseline = {
+      id: loadId,
+      title: 'Initial page load',
+      kind: 'load',
+      ok: true,
+      steps: [],
+      summary: summarizeReport(readReport(loadId)),
+    };
+
+    // 2) Discover the actionable surface on the loaded page.
+    log({ phase: 'discover' });
+    const inventory = await discoverActionables(session.page, { allow });
+
+    // 3) Synthesize golden paths.
+    const paths = synthesizePaths(inventory, { limit });
+    log({
+      phase: 'synthesized',
+      discovered: inventory.ranked.length,
+      skipped: inventory.skipped.length,
+      paths: paths.length,
+    });
+
+    // 4) Run each golden path as its own live recording.
+    for (let i = 0; i < paths.length; i++) {
+      const p = paths[i];
+      log({ phase: 'path', index: i + 1, total: paths.length, title: p.title });
+      let runRes = null;
+      let report = null;
+      let error = null;
+      try {
+        await session.navigate(url, signIn);
+        await sleep(500);
+        await session.start({ mode: 'live' });
+        runRes = await runPath(session.page, p);
+        report = await session.stop();
+      } catch (err) {
+        error = err.message;
+        if (session.state === 'recording') {
+          try {
+            report = await session.stop();
+          } catch {
+            /* ignore */
+          }
+        }
+      }
+      results.push({
+        id: report ? report.id : null,
+        title: p.title,
+        kind: p.kind,
+        ok: !!(runRes && runRes.ok) && !error,
+        steps: runRes ? runRes.steps : [],
+        error,
+        summary: report ? summarizeReport(report) : null,
+      });
+    }
+
+    return {
+      url,
+      target: TARGET_NAME,
+      baseline,
+      discovered: inventory.ranked.length,
+      skippedDestructive: inventory.skipped.map(s => ({
+        name: s.name,
+        selector: s.selector,
+      })),
+      paths: results,
+    };
+  } finally {
+    await session.disconnect();
+  }
+}

package/server/explore/paths.js

@@ -0,0 +1,105 @@
+/**
+ * Golden-path synthesis: turn a ranked, classified element inventory (from
+ * discover.js) into a small set of automation journeys the runner can drive.
+ *
+ * Heuristic and deterministic — no AI, no network. Safe by default: a journey
+ * only submits a form when that form's submit is non-destructive, and
+ * destructive controls are never clicked unless the caller allowlisted them
+ * (partitionSafe has already filtered those into `skipped`).
+ *
+ * A path:
+ *   { id, title, kind, steps: [ { action, selector, value?, label } ] }
+ * Step actions: 'navigate' (click a link), 'click', 'fill', 'choose', 'submit'.
+ */
+
+/** A plausible synthetic value for a text-like input, from its type/name. */
+export function syntheticValue(d) {
+  const type = (d.type || '').toLowerCase();
+  const hint = `${d.name || ''} ${d.label || ''} ${d.id || ''}`.toLowerCase();
+  if (type === 'email' || /e-?mail/.test(hint)) return 'test@example.com';
+  if (type === 'password' || /pass/.test(hint)) return 'Password123!';
+  if (type === 'number' || /\b(age|qty|quantity|count|amount)\b/.test(hint)) return '1';
+  if (type === 'tel' || /phone|mobile|tel/.test(hint)) return '5551234567';
+  if (type === 'url' || /url|website|link/.test(hint)) return 'https://example.com';
+  if (type === 'date') return '2024-01-01';
+  if (type === 'search' || /search|query/.test(hint)) return 'test';
+  if (/name/.test(hint)) return 'Test User';
+  return 'test';
+}
+
+function navPaths(safe, limit) {
+  return safe
+    .filter(e => e.kind === 'nav-link')
+    .slice(0, limit)
+    .map((e, i) => ({
+      id: `nav-${i + 1}`,
+      title: `Navigate to "${e.name}"`,
+      kind: 'navigation',
+      steps: [{ action: 'navigate', selector: e.selector, label: e.name }],
+    }));
+}
+
+function clickPaths(safe, limit) {
+  return safe
+    .filter(e => e.kind === 'button' && e.formIndex === -1)
+    .slice(0, limit)
+    .map((e, i) => ({
+      id: `click-${i + 1}`,
+      title: `Click "${e.name}"`,
+      kind: 'interaction',
+      steps: [{ action: 'click', selector: e.selector, label: e.name }],
+    }));
+}
+
+function formPaths(safe, limit) {
+  // Group safe, fillable controls by the form they belong to.
+  const byForm = new Map();
+  for (const e of safe) {
+    if (e.formIndex === -1) continue;
+    if (!byForm.has(e.formIndex)) byForm.set(e.formIndex, []);
+    byForm.get(e.formIndex).push(e);
+  }
+  const paths = [];
+  let i = 0;
+  for (const [, members] of byForm) {
+    if (paths.length >= limit) break;
+    const steps = [];
+    for (const e of members) {
+      if (e.kind === 'text-input') {
+        steps.push({ action: 'fill', selector: e.selector, value: syntheticValue(e), label: e.name });
+      } else if (e.kind === 'toggle') {
+        steps.push({ action: 'choose', selector: e.selector, label: e.name });
+      } else if (e.kind === 'select') {
+        steps.push({ action: 'choose', selector: e.selector, value: '', label: e.name });
+      }
+    }
+    if (!steps.length) continue;
+    // Submit only if this form's submit survived the safe filter.
+    const submit = members.find(e => e.kind === 'submit');
+    if (submit) {
+      steps.push({ action: 'submit', selector: submit.selector, label: submit.name });
+    }
+    const title = submit
+      ? `Fill & submit the "${steps[0].label || 'form'}" form`
+      : `Fill the "${steps[0].label || 'form'}" form`;
+    paths.push({ id: `form-${++i}`, title, kind: 'form', steps });
+  }
+  return paths;
+}
+
+/**
+ * Synthesize golden paths from a discovery result (`{ safe, ... }`).
+ *
+ * @param {{ safe: object[] }} discovery
+ * @param {{ limit?: number }} [opts]  max total paths (default 12)
+ */
+export function synthesizePaths(discovery, { limit = 12 } = {}) {
+  const safe = discovery.safe || [];
+  // Forms are the highest-value journeys, then navigation, then lone buttons.
+  const forms = formPaths(safe, Math.min(limit, 5));
+  const remaining1 = limit - forms.length;
+  const navs = navPaths(safe, Math.min(remaining1, 6));
+  const remaining2 = remaining1 - navs.length;
+  const clicks = clickPaths(safe, Math.max(0, remaining2));
+  return [...forms, ...navs, ...clicks].slice(0, limit);
+}

package/server/explore/runner.js

@@ -0,0 +1,94 @@
+/**
+ * Journey runner: drive one synthesized golden path against a live puppeteer
+ * Page. Each step is attempted in order; the first failure stops the journey
+ * (you cannot meaningfully continue a flow past a broken step) and the rest are
+ * marked skipped. Returns a per-step result and an overall pass/fail.
+ */
+
+const STEP_TIMEOUT = 8000;
+const SETTLE_MS = 600;
+
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+async function waitFor(page, selector) {
+  return page.waitForSelector(selector, { timeout: STEP_TIMEOUT, visible: true });
+}
+
+async function runStep(page, step) {
+  const el = await waitFor(page, step.selector);
+  switch (step.action) {
+    case 'navigate': {
+      // A link click that may trigger a navigation; tolerate SPA (no nav).
+      await Promise.race([
+        page.waitForNavigation({ timeout: STEP_TIMEOUT, waitUntil: 'domcontentloaded' }).catch(() => {}),
+        el.click(),
+      ]);
+      await sleep(SETTLE_MS);
+      break;
+    }
+    case 'click': {
+      await el.click();
+      await sleep(SETTLE_MS);
+      break;
+    }
+    case 'fill': {
+      await el.click({ clickCount: 3 }).catch(() => {}); // select existing text
+      await el.type(String(step.value ?? ''), { delay: 10 });
+      break;
+    }
+    case 'choose': {
+      const tag = await page.evaluate(e => e.tagName.toLowerCase(), el);
+      if (tag === 'select') {
+        // Pick the first non-empty option.
+        const value = await page.evaluate(e => {
+          const opt = Array.from(e.options).find(o => o.value) || e.options[0];
+          return opt ? opt.value : '';
+        }, el);
+        if (value) await page.select(step.selector, value);
+      } else {
+        await el.click(); // checkbox / radio / switch
+      }
+      await sleep(SETTLE_MS);
+      break;
+    }
+    case 'submit': {
+      await Promise.race([
+        page.waitForNavigation({ timeout: STEP_TIMEOUT, waitUntil: 'domcontentloaded' }).catch(() => {}),
+        el.click(),
+      ]);
+      await sleep(SETTLE_MS);
+      break;
+    }
+    default:
+      throw new Error(`unknown step action "${step.action}"`);
+  }
+}
+
+/**
+ * Run a path's steps on `page`. Does not start/stop recording — the caller
+ * wraps this in a PerfSession window.
+ *
+ * @returns {Promise<{ ok: boolean, steps: Array<{ action, label, selector, ok, error?, skipped? }> }>}
+ */
+export async function runPath(page, path) {
+  const results = [];
+  let failed = false;
+  for (const step of path.steps) {
+    if (failed) {
+      results.push({ ...stepMeta(step), ok: false, skipped: true });
+      continue;
+    }
+    try {
+      await runStep(page, step);
+      results.push({ ...stepMeta(step), ok: true });
+    } catch (err) {
+      failed = true;
+      results.push({ ...stepMeta(step), ok: false, error: err.message });
+    }
+  }
+  return { ok: !failed, steps: results };
+}
+
+function stepMeta(step) {
+  return { action: step.action, label: step.label || '', selector: step.selector };
+}

package/server/explore/test-explore.js

@@ -0,0 +1,139 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  classifyElement,
+  isInternalHref,
+  isDestructive,
+  labelOf,
+  scoreElement,
+  rankElements,
+  partitionSafe,
+} from './classify.js';
+
+const desc = (over = {}) => ({
+  tag: 'button',
+  type: '',
+  role: '',
+  label: 'Click me',
+  href: '',
+  name: '',
+  id: '',
+  selector: 'button.cta',
+  inForm: false,
+  formMethod: '',
+  formAction: '',
+  disabled: false,
+  visible: true,
+  rect: [0, 0, 100, 40],
+  ...over,
+});
+
+test('classifyElement maps tags, input types and ARIA roles to a kind/action', () => {
+  assert.deepEqual(classifyElement(desc({ tag: 'a', href: '/pricing' })), {
+    kind: 'nav-link',
+    actionType: 'navigate',
+  });
+  assert.deepEqual(classifyElement(desc({ tag: 'a', href: 'https://x.com' })), {
+    kind: 'link',
+    actionType: 'navigate',
+  });
+  assert.deepEqual(classifyElement(desc({ tag: 'input', type: 'email' })), {
+    kind: 'text-input',
+    actionType: 'fill',
+  });
+  assert.deepEqual(classifyElement(desc({ tag: 'input', type: 'submit' })), {
+    kind: 'submit',
+    actionType: 'submit',
+  });
+  assert.deepEqual(classifyElement(desc({ tag: 'input', type: 'checkbox' })), {
+    kind: 'toggle',
+    actionType: 'choose',
+  });
+  assert.deepEqual(classifyElement(desc({ tag: 'div', role: 'button' })), {
+    kind: 'button',
+    actionType: 'click',
+  });
+  assert.deepEqual(classifyElement(desc({ tag: 'select' })), {
+    kind: 'select',
+    actionType: 'choose',
+  });
+  // hidden inputs and unknown elements carry no action
+  assert.equal(classifyElement(desc({ tag: 'input', type: 'hidden' })).actionType, null);
+  assert.equal(classifyElement(desc({ tag: 'span', role: '' })).actionType, null);
+});
+
+test('isInternalHref distinguishes in-app navigation from external/non-nav', () => {
+  assert.equal(isInternalHref('/dashboard'), true);
+  assert.equal(isInternalHref('./settings'), true);
+  assert.equal(isInternalHref('products'), true);
+  assert.equal(isInternalHref('#section'), false);
+  assert.equal(isInternalHref('https://example.com'), false);
+  assert.equal(isInternalHref('mailto:a@b.com'), false);
+  assert.equal(isInternalHref('javascript:void(0)'), false);
+});
+
+test('isDestructive flags mutating labels, logout hrefs and POST submits', () => {
+  assert.equal(isDestructive(desc({ label: 'Delete account' })), true);
+  assert.equal(isDestructive(desc({ label: 'Pay now' })), true);
+  assert.equal(isDestructive(desc({ label: 'Log out' })), true);
+  assert.equal(isDestructive(desc({ tag: 'a', href: '/logout' })), true);
+  assert.equal(
+    isDestructive(desc({ tag: 'input', type: 'submit', inForm: true, formMethod: 'post' })),
+    true,
+  );
+  // a GET form submit (e.g. a search) is not destructive
+  assert.equal(
+    isDestructive(desc({ tag: 'input', type: 'submit', inForm: true, formMethod: 'get', label: 'Search' })),
+    false,
+  );
+  // an ordinary navigation / click is safe
+  assert.equal(isDestructive(desc({ tag: 'a', href: '/pricing', label: 'Pricing' })), false);
+});
+
+test('labelOf prefers accessible text, then name/href, then kind, and truncates', () => {
+  assert.equal(labelOf(desc({ label: '  Buy   now ' })), 'Buy now');
+  assert.equal(labelOf(desc({ label: '', name: 'email', tag: 'input', type: 'email' })), 'email');
+  assert.equal(labelOf(desc({ label: '', name: '', tag: 'a', href: '/x' })), '/x');
+  const long = 'x'.repeat(80);
+  const truncated = labelOf(desc({ label: long }));
+  assert.ok(truncated.length <= 60);
+  assert.ok(truncated.endsWith('…'));
+});
+
+test('scoreElement rewards visible, labelled, primary entry points over noise', () => {
+  const primaryNav = desc({ tag: 'a', href: '/dashboard', label: 'Dashboard', selector: 'a#nav-dash' });
+  const hiddenThing = desc({ visible: false, label: '' });
+  const tinyIcon = desc({ rect: [0, 0, 2, 2], label: '' });
+  assert.ok(scoreElement(primaryNav) > scoreElement(hiddenThing));
+  assert.ok(scoreElement(primaryNav) > scoreElement(tinyIcon));
+  // unknown / non-actionable sinks to -Infinity
+  assert.equal(scoreElement(desc({ tag: 'span', role: '' })), -Infinity);
+});
+
+test('rankElements classifies, de-dupes by selector and sorts by score', () => {
+  const input = [
+    desc({ tag: 'a', href: '/dashboard', label: 'Dashboard', selector: 'a#nav-dash' }),
+    desc({ tag: 'a', href: '/dashboard', label: 'Dashboard', selector: 'a#nav-dash' }), // dup
+    desc({ tag: 'span', role: '', selector: 'span.x' }), // non-actionable, dropped
+    desc({ tag: 'button', label: 'OK', selector: 'button.ok' }),
+  ];
+  const ranked = rankElements(input, { limit: 10 });
+  assert.equal(ranked.length, 2); // dup collapsed, non-actionable removed
+  assert.ok(ranked.every(r => 'kind' in r && 'actionType' in r && 'destructive' in r));
+  // sorted descending by score
+  for (let i = 1; i < ranked.length; i++) assert.ok(ranked[i - 1].score >= ranked[i].score);
+});
+
+test('partitionSafe holds back destructive actions unless allowlisted', () => {
+  const ranked = rankElements([
+    desc({ label: 'Pricing', tag: 'a', href: '/pricing', selector: 'a#price' }),
+    desc({ label: 'Delete', selector: 'button#del' }),
+  ]);
+  const { safe, skipped } = partitionSafe(ranked);
+  assert.deepEqual(safe.map(s => s.selector), ['a#price']);
+  assert.deepEqual(skipped.map(s => s.selector), ['button#del']);
+
+  const allowed = partitionSafe(ranked, { allow: ['button#del'] });
+  assert.equal(allowed.skipped.length, 0);
+  assert.equal(allowed.safe.length, 2);
+});

package/server/explore/test-paths.js

@@ -0,0 +1,75 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { syntheticValue, synthesizePaths } from './paths.js';
+
+test('syntheticValue derives plausible values from type and name hints', () => {
+  assert.equal(syntheticValue({ type: 'email' }), 'test@example.com');
+  assert.equal(syntheticValue({ type: 'text', name: 'userEmail' }), 'test@example.com');
+  assert.equal(syntheticValue({ type: 'password' }), 'Password123!');
+  assert.equal(syntheticValue({ type: 'search' }), 'test');
+  assert.equal(syntheticValue({ type: 'date' }), '2024-01-01');
+  assert.equal(syntheticValue({ type: 'tel' }), '5551234567');
+  assert.equal(syntheticValue({ type: 'text', name: 'fullName' }), 'Test User');
+  assert.equal(syntheticValue({ type: 'text' }), 'test');
+});
+
+const el = (over) => ({
+  kind: 'button',
+  selector: 'button',
+  name: 'x',
+  formIndex: -1,
+  type: '',
+  ...over,
+});
+
+test('synthesizePaths builds a fill+submit journey for a form', () => {
+  const safe = [
+    el({ kind: 'text-input', type: 'email', selector: '#email', name: 'email', formIndex: 0 }),
+    el({ kind: 'text-input', type: 'password', selector: '#pw', name: 'password', formIndex: 0 }),
+    el({ kind: 'toggle', selector: '#remember', name: 'remember', formIndex: 0 }),
+    el({ kind: 'submit', selector: '#login', name: 'Log in', formIndex: 0 }),
+  ];
+  const [form] = synthesizePaths({ safe });
+  assert.equal(form.kind, 'form');
+  const actions = form.steps.map(s => s.action);
+  assert.deepEqual(actions, ['fill', 'fill', 'choose', 'submit']);
+  assert.equal(form.steps[0].value, 'test@example.com');
+  assert.equal(form.steps[1].value, 'Password123!');
+  assert.match(form.title, /submit/i);
+});
+
+test('a form with no safe submit is filled but not submitted', () => {
+  const safe = [
+    el({ kind: 'text-input', type: 'search', selector: '#q', name: 'q', formIndex: 0 }),
+  ];
+  const [form] = synthesizePaths({ safe });
+  assert.deepEqual(form.steps.map(s => s.action), ['fill']);
+  assert.match(form.title, /^Fill the/);
+});
+
+test('synthesizePaths makes navigation and click journeys and honors the limit', () => {
+  const safe = [
+    el({ kind: 'nav-link', selector: 'a#a', name: 'Home' }),
+    el({ kind: 'nav-link', selector: 'a#b', name: 'Pricing' }),
+    el({ kind: 'button', selector: 'button#c', name: 'Open menu' }),
+  ];
+  const paths = synthesizePaths({ safe }, { limit: 2 });
+  assert.equal(paths.length, 2);
+  const all = synthesizePaths({ safe });
+  assert.deepEqual(
+    all.map(p => p.kind),
+    ['navigation', 'navigation', 'interaction'],
+  );
+  assert.equal(all[0].steps[0].action, 'navigate');
+  assert.equal(all[2].steps[0].action, 'click');
+});
+
+test('forms are prioritized over navigation and lone buttons', () => {
+  const safe = [
+    el({ kind: 'nav-link', selector: 'a#a', name: 'Home' }),
+    el({ kind: 'text-input', type: 'email', selector: '#e', name: 'email', formIndex: 0 }),
+    el({ kind: 'submit', selector: '#s', name: 'Subscribe-less', formIndex: 0 }),
+  ];
+  const paths = synthesizePaths({ safe });
+  assert.equal(paths[0].kind, 'form');
+});

package/server/framework.js

@@ -0,0 +1,67 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+function readPkg(root) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+    return pkg;
+  } catch {
+    return null;
+  }
+}
+
+export function detectFramework(root) {
+  const pkg = readPkg(root) || {};
+  const deps = Object.assign({}, pkg.dependencies, pkg.devDependencies);
+  const files = new Set(fs.readdirSync(root).map(f => f.toLowerCase()));
+
+  const result = {
+    framework: 'unknown',
+    bundler: 'unknown',
+    isSSR: false,
+    hints: [],
+  };
+
+  if (deps['next'] || files.has('next.config.js') || fs.existsSync(path.join(root, 'pages'))) {
+    result.framework = 'next';
+    result.bundler = 'webpack';
+    result.isSSR = true;
+    result.hints.push('next');
+    return result;
+  }
+
+  if (deps['react'] && deps['react-dom']) {
+    result.framework = 'react';
+    result.hints.push('react');
+  }
+  if (deps['vue'] || files.has('vue.config.js')) {
+    result.framework = 'vue';
+    result.hints.push('vue');
+  }
+  if (deps['svelte'] || files.has('svelte.config.js')) {
+    result.framework = 'svelte';
+    result.hints.push('svelte');
+  }
+  if (deps['@angular/core'] || files.has('angular.json')) {
+    result.framework = 'angular';
+    result.hints.push('angular');
+  }
+
+  if (files.has('vite.config.js') || files.has('vite.config.ts') || deps['vite']) {
+    result.bundler = 'vite';
+    result.hints.push('vite');
+  }
+  if (files.has('webpack.config.js') || deps['webpack']) {
+    result.bundler = 'webpack';
+    result.hints.push('webpack');
+  }
+  if (files.has('rollup.config.js') || deps['rollup']) {
+    result.bundler = 'rollup';
+    result.hints.push('rollup');
+  }
+
+  // Some frameworks bundle SSR runtimes but still have client bundles.
+  if (result.framework === 'next') result.isSSR = true;
+
+  return result;
+}