Skip to content

Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.

C++
8.6 KB
Raw Blame
#!/usr/bin/env node
/**
 * Strata motion budget.
 *
 *   node scripts/motionbudget.mjs
 *
 * The plans ask for one thing about the scroll-driven effects that a static
 * audit cannot answer: what do they cost while you actually scroll? Six rules
 * are bound to the transcript's scroll timeline, and "it looks smooth" is not a
 * measurement.
 *
 * So this scrolls a real transcript twice — once as shipped, once with the
 * scroll-driven animations switched off — and compares p95 frame time. The
 * budget is 1.2x, taken from plan 15. A ratio rather than an absolute figure
 * because absolute frame times depend on the machine running the check.
 *
 * Requires the dev server.
 */
import { chromium } from 'playwright-core';
import { existsSync } from 'node:fs';
import { join } from 'node:path';
import { homedir } from 'node:os';

const BASE = process.env.STRATA_URL ?? 'http://localhost:5199';
const BUDGET = 1.2;

const executablePath = [
  join(homedir(), 'Library/Caches/ms-playwright/chromium-1234/chrome-mac-arm64/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing'),
  join(homedir(), 'Library/Caches/ms-playwright/chromium_headless_shell-1234/chrome-headless-shell-mac-arm64/chrome-headless-shell'),
].find((p) => existsSync(p));

if (!executablePath) {
  console.error('No cached Chromium found. Run `npm run shot -- x.png <url>` once to confirm the harness.');
  process.exit(2);
}

const browser = await chromium.launch({ executablePath, args: ['--no-sandbox'] });

/**
 * Confirms the harness can see a cost at all, before trusting it to report one.
 *
 * This was written after the check passed with a deliberately expensive effect
 * injected — blur, saturation and scale bound to every message's scroll
 * timeline — and the ratio did not move. In this environment, programmatic
 * scrolling does not appear to drive scroll-timeline paint cost, so the
 * measurement cannot distinguish cheap from expensive here.
 *
 * A budget check that cannot detect a six-fold increase in per-frame work is
 * worse than no check: it reports "within budget" with confidence it has not
 * earned. So it measures a known-expensive case first and says so when it
 * cannot see the difference.
 */
async function canDiscriminate() {
  const page = await browser.newPage({ viewport: { width: 1512, height: 700 } });
  await page.goto(`${BASE}/#/chat`, { waitUntil: 'domcontentloaded' });
  await page.waitForTimeout(1500);
  await page.click('button.nav-new');
  await page.waitForTimeout(400);
  for (const m of ['write a paragraph about tides', 'and another about the moon']) {
    await page.fill('textarea', m);
    await page.keyboard.press('Enter');
    await page.waitForTimeout(8000);
    await page.keyboard.press('Enter').catch(() => {});
    await page.waitForTimeout(3500);
  }
  await scrollProfile(page);
  const before = await scrollProfile(page);
  await page.addStyleTag({
    content: `@keyframes probe-expensive { from { filter: blur(0px); } to { filter: blur(8px) saturate(2); } }
              .st-msg { scroll-timeline: --probe block; animation: probe-expensive linear both; animation-timeline: --probe; }`,
  });
  await scrollProfile(page);
  const after = await scrollProfile(page);
  await page.close();
  return { before: stats(before.frames), after: stats(after.frames) };
}

/**
 * Scrolls the transcript and returns the frame deltas.
 *
 * Deliberately drives the scroll from inside the page on rAF: driving it over
 * the protocol would measure the round-trip rather than the rendering.
 */
async function scrollProfile(page) {
  return page.evaluate(
    () =>
      new Promise((resolve) => {
        const el = document.querySelector('.main__body.chat');
        if (!el) return resolve(null);
        const frames = [];
        let last = performance.now();
        const started = last;
        let dir = 1;
        const step = () => {
          const now = performance.now();
          frames.push(now - last);
          last = now;
          // sweep down then up, so both directions are represented
          el.scrollTop += dir * 24;
          if (el.scrollTop <= 0) dir = 1;
          if (el.scrollTop >= el.scrollHeight - el.clientHeight) dir = -1;
          if (frames.length < 240) requestAnimationFrame(step);
          else resolve({ frames: frames.slice(5), wall: performance.now() - started });
        };
        requestAnimationFrame(step);
      }),
  );
}

/**
 * What is measured, and why not p95 frame time.
 *
 * The first version of this compared p95 frame deltas and reported a ratio of
 * exactly 1.000 — then still reported 1.006 against a deliberately expensive
 * scroll-driven effect (blur, saturation and scale on every message). p95 sits
 * at the 60fps frame cap in both runs, so it is saturated: any cost that fits
 * inside a frame reads as free. A check that cannot detect a six-fold increase
 * in per-frame work is not measuring the thing it claims to.
 *
 * What does discriminate is **total scripting time for a fixed amount of
 * scrolling**, which accumulates work that individual frames hide.
 */
const stats = (xs) => {
  const sorted = [...xs].sort((a, b) => a - b);
  const at = (q) => sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * q))];
  return { p50: at(0.5), p95: at(0.95), total: xs.reduce((a, b) => a + b, 0), n: xs.length };
};

async function makeTranscript() {
  const page = await browser.newPage({ viewport: { width: 1512, height: 700 } });
  await page.goto(`${BASE}/#/chat`, { waitUntil: 'domcontentloaded' });
  await page.waitForTimeout(1500);
  await page.click('button.nav-new');
  await page.waitForTimeout(400);
  for (const m of ['write a paragraph about tides', 'and another about the moon', 'and one about the wind']) {
    await page.fill('textarea', m);
    await page.keyboard.press('Enter');
    await page.waitForTimeout(8000);
    await page.keyboard.press('Enter').catch(() => {});
    await page.waitForTimeout(3500);
  }
  return page;
}

/* ---- run ---------------------------------------------------------------- */

// First: can this harness see a cost at all? Without this the check would
// report "within budget" whether or not it was measuring anything.
const probe = await canDiscriminate();
const probeRatio = probe.before.total > 0 ? probe.after.total / probe.before.total : 1;
const blind = probeRatio < 1.05;

console.log('self-check: known-expensive effect');
console.log(`  total frame time ${probe.before.total.toFixed(0)}ms -> ${probe.after.total.toFixed(0)}ms (${probeRatio.toFixed(3)}x)`);

if (blind) {
  console.log('  the harness cannot see a deliberately expensive effect, so it cannot');
  console.log('  measure the real one either. Reporting nothing rather than passing.');
  console.log('\nmotion budget: NOT MEASURED — see plan 15');
  await browser.close();
  process.exit(3);
}
console.log('  detected, so the measurement below is meaningful\n');

const page = await makeTranscript();
const room = await page.evaluate(() => {
  const el = document.querySelector('.main__body.chat');
  return el ? el.scrollHeight - el.clientHeight : 0;
});

if (room < 200) {
  console.log(`motion budget: not enough transcript to scroll (${room}px) — skipped`);
  await browser.close();
  process.exit(0);
}

// warm up so the first pass is not paying for layout the second one gets free
await scrollProfile(page);
const shipped = await scrollProfile(page);

// the same page, with the scroll-driven animations switched off
await page.addStyleTag({
  content: `*, *::before, *::after { animation-timeline: none !important; animation-name: none !important; }`,
});
await scrollProfile(page);
const withoutEffects = await scrollProfile(page);

await browser.close();

const a = stats(shipped.frames);
const b = stats(withoutEffects.frames);
// Compared on total frame time for the same number of scroll steps.
const ratio = b.total > 0 ? a.total / b.total : 1;
// Reported alongside, to show whether the p95 was saturated.
const p95Ratio = b.p95 > 0 ? a.p95 / b.p95 : 1;

console.log(`scroll room           : ${Math.round(room)}px`);
console.log(`frames sampled        : ${a.n} (${Math.round(shipped.wall)}ms as shipped, ${Math.round(withoutEffects.wall)}ms without)`);
console.log(`total frame time      : ${a.total.toFixed(0)}ms shipped vs ${b.total.toFixed(0)}ms without`);
console.log(`p95 frame             : ${a.p95.toFixed(2)}ms vs ${b.p95.toFixed(2)}ms (ratio ${p95Ratio.toFixed(3)}x — usually saturated at the frame cap)`);
console.log(`ratio                 : ${ratio.toFixed(3)}x (budget ${BUDGET}x)`);

if (ratio > BUDGET) {
  console.log(`\nmotion budget: FAIL — scroll-driven effects cost ${ratio.toFixed(2)}x, over the ${BUDGET}x budget`);
  process.exit(1);
}
console.log('\nmotion budget: within budget');