@astryxdesign/cli 0.6.3 → 0.6.4-canary.06c8fa3

package/api/theme/build/build.mjs

@@ -12,9 +12,10 @@
  * - A .d.ts (plus an optional .variants.d.ts for custom prop values)
  *
  * It performs the writes and returns a `theme.build` receipt — its `warnings`
- * carry override problems and any fonts the theme names but does not load
- * (font-warning.mjs) — or `null` when the theme produced no CSS (nothing to
- * build). Errors throw AstryxError (with
+ * carry override problems, every declaration core's generator dropped because
+ * its value could not stay one CSS declaration, and any fonts the theme names
+ * but does not load (font-warning.mjs) — or `null` when the theme produced no
+ * CSS (nothing to build). Errors throw AstryxError (with
  * a stable code). Human progress is emitted through the shared `logger`
  * (silent by default), so the CLI keeps its exact output while a programmatic
  * caller stays quiet.
@@ -52,6 +53,7 @@ import {
 } from '../../../foundation/fs/path-safety.mjs';
 import {ERROR_CODES} from '../../../foundation/response/error-codes.mjs';
 import {AstryxError} from '../../error.mjs';
+import {applyWrites} from '../../integration/add-helpers.mjs';
 import {logger} from '../../logger.mjs';
 import {loadComponentDoc} from '../../../foundation/discovery/component-loader.mjs';
 import {
@@ -223,26 +225,15 @@ function staleBuildOutputs(writes, cwd) {
 /** @param {Array<{dest: string, content: string}>} writes */
 function writeBuildOutputs(writes) {
   if (writes.length === 0) return;
-  fs.mkdirSync(path.dirname(writes[0].dest), {recursive: true});
-  /** @type {Array<{tmp: string, dest: string}>} */
-  const staged = [];
   try {
-    for (const write of writes) {
-      const tmp = `${write.dest}.${process.pid}.tmp`;
-      fs.writeFileSync(tmp, write.content);
-      staged.push({tmp, dest: write.dest});
-    }
-    for (const stagedWrite of staged) {
-      fs.renameSync(stagedWrite.tmp, stagedWrite.dest);
-    }
+    applyWrites(
+      writes.map(write => ({
+        path: write.dest,
+        contents: write.content,
+        createOnly: false,
+      })),
+    );
   } catch (error) {
-    for (const stagedWrite of staged) {
-      try {
-        fs.rmSync(stagedWrite.tmp, {force: true});
-      } catch {
-        // Best effort: the command still fails and never reports success.
-      }
-    }
     const message = `Failed to write theme outputs: ${/** @type {Error} */ (error).message}`;
     throw new AstryxError(message, undefined, ERROR_CODES.ERR_WRITE_FAILED);
   }
@@ -1870,7 +1861,7 @@ function validatePrivateVars(themeDef) {
           if (prop.startsWith('--_')) {
             errors.push(
               `Component "${component}" (${[key, ...path].join(' ')}) sets private var "${prop}". ` +
-                `Private vars (--_*) are internal — use standard CSS properties ` +
+                `Private vars (--_*) are internal; use standard CSS properties ` +
                 `(e.g. borderRadius, padding) instead. The pipeline expands them automatically.`,
             );
           }
@@ -1930,20 +1921,7 @@ function getThemeComponentLayers(themeDef) {
  */
 function validateCustomHeadingTypes(themeDef) {
   const layers = getThemeComponentLayers(themeDef);
-  const customTypes = new Set();
-  for (const {components} of layers) {
-    const headingRules = components.heading;
-    if (!headingRules || typeof headingRules !== 'object') continue;
-
-    for (const key of Object.keys(headingRules)) {
-      for (const pair of key.split('+')) {
-        const colon = pair.indexOf(':');
-        if (colon === -1 || pair.slice(0, colon) !== 'type') continue;
-        const value = pair.slice(colon + 1);
-        if (value && !BUILTIN_HEADING_TYPES.has(value)) customTypes.add(value);
-      }
-    }
-  }
+  const customTypes = customHeadingTypes(themeDef);
 
   const errors = [];
   for (const type of customTypes) {
@@ -1970,10 +1948,65 @@ function validateCustomHeadingTypes(themeDef) {
   return errors;
 }
 
+/**
+ * Custom Heading type names declared on the root or media-surface component
+ * maps: the names the generated `HeadingTypeMap` augmentation enrolls.
+ *
+ * @param {{components?: Record<string, Record<string, unknown>>}} themeDef
+ * @returns {Set<string>}
+ */
+function customHeadingTypes(themeDef) {
+  /** @type {Set<string>} */
+  const customTypes = new Set();
+  for (const {components} of getThemeComponentLayers(themeDef)) {
+    const headingRules = components.heading;
+    if (!headingRules || typeof headingRules !== 'object') continue;
+
+    for (const key of Object.keys(headingRules)) {
+      for (const pair of key.split('+')) {
+        const colon = pair.indexOf(':');
+        if (colon === -1 || pair.slice(0, colon) !== 'type') continue;
+        const value = pair.slice(colon + 1);
+        if (value && !BUILTIN_HEADING_TYPES.has(value)) customTypes.add(value);
+      }
+    }
+  }
+  return customTypes;
+}
+
+/**
+ * Custom Heading types with no standalone rule in the generated CSS. A type
+ * whose every declaration the compiler dropped still passes the source check,
+ * and its augmentation would then name a type that has no styles.
+ *
+ * @param {Set<string>} types
+ * @param {string} css - Generated root component and media-surface rules.
+ * @returns {string[]}
+ */
+function headingTypesWithoutEmittedRule(types, css) {
+  /** @type {string[]} */
+  const missing = [];
+  for (const type of types) {
+    const selector = `.astryx-heading[data-type="${type}"]`;
+    let emitted = false;
+    for (
+      let at = css.indexOf(selector);
+      at !== -1 && !emitted;
+      at = css.indexOf(selector, at + 1)
+    ) {
+      // A following attribute is a combined selector, not the standalone rule.
+      emitted = css[at + selector.length] !== '[';
+    }
+    if (!emitted) missing.push(type);
+  }
+  return missing;
+}
+
 /**
  * Return true when a style object contains a declaration that the theme
- * generator can emit. Empty pseudo blocks do not count: they produce no CSS
- * and would leave the generated type augmentation without a usable rule.
+ * generator can emit. Empty pseudo blocks and blank values do not count: they
+ * produce no usable CSS and would leave the generated type augmentation
+ * without a usable rule.
  *
  * @param {unknown} styles
  * @returns {boolean}
@@ -1987,7 +2020,12 @@ function hasUsableStyleDeclaration(styles) {
       if (hasUsableStyleDeclaration(value)) return true;
       continue;
     }
-    if (value !== undefined && value !== null && typeof value !== 'object') {
+    if (
+      value !== undefined &&
+      value !== null &&
+      typeof value !== 'object' &&
+      String(value).trim() !== ''
+    ) {
       return true;
     }
   }
@@ -2162,14 +2200,14 @@ async function themeBuildInternal(
   const noticeMessages = [];
   for (const w of warnings) {
     warningMessages.push(w);
-    logger.warn(`  ⚠ ${w}`);
+    logger.warn(`  [warn] ${w}`);
   }
 
   // Validate no private vars are set directly
   const privateVarErrors = validatePrivateVars(themeDef);
   for (const e of privateVarErrors) {
     warningMessages.push(e);
-    logger.error(`  ✗ ${e}`);
+    logger.error(`  [error] ${e}`);
   }
   if (privateVarErrors.length > 0) {
     logger.error(
@@ -2195,7 +2233,7 @@ async function themeBuildInternal(
   // capability exports are checked against what the theme actually asks for.
   if (!_defineTheme || !_generateThemeRulesSplit) {
     throw new AstryxError(
-      'Could not load @astryxdesign/core/theme — `astryx theme build` requires a ' +
+      'Could not load @astryxdesign/core/theme: `astryx theme build` requires a ' +
         'built, resolvable @astryxdesign/core so it emits the same CSS as the ' +
         'runtime <Theme>. Build @astryxdesign/core first (e.g. `pnpm -F @astryxdesign/core ' +
         'build`)' +
@@ -2303,7 +2341,15 @@ async function themeBuildInternal(
     const scopeSelector = themeScopeStart(themeDef.name);
     const scopeTo = THEME_SCOPE_TO;
 
-    const {component, prose} = _generateThemeRulesSplit(resolvedTheme);
+    // Older cores ignore this optional collector. Current core writes the same
+    // warning text here that runtime callers receive on the console.
+    /** @type {string[]} */
+    const droppedDeclarations = [];
+
+    const {component, prose} = _generateThemeRulesSplit(
+      resolvedTheme,
+      droppedDeclarations,
+    );
     const cssParts = [];
     // Prose element defaults always ship — the `<Theme>` runtime
     // (generateThemeCSS) always emits them, so the build must too, or the
@@ -2322,7 +2368,7 @@ async function themeBuildInternal(
     let adaptationCss;
     try {
       adaptationCss = _generateAdaptationCSS
-        ? _generateAdaptationCSS(resolvedTheme)
+        ? _generateAdaptationCSS(resolvedTheme, droppedDeclarations)
         : {component: '', prose: ''};
     } catch (error) {
       const message =
@@ -2368,13 +2414,37 @@ async function themeBuildInternal(
     // adaptations on the same resolved leaf.
     let onMediaCss = '';
     if (_generateOnMediaCSS) {
-      onMediaCss = _generateOnMediaCSS(resolvedTheme);
+      onMediaCss = _generateOnMediaCSS(resolvedTheme, droppedDeclarations);
       if (onMediaCss) {
         cssParts.push(`@layer astryx-theme {\n${onMediaCss}\n}`);
       }
     }
+    for (const message of droppedDeclarations) {
+      const w = `Declaration ${message}. The generated CSS omits it; fix the value in the theme source.`;
+      warningMessages.push(w);
+      logger.warn(`  [warn] ${w}`);
+    }
+    const unemittedHeadingTypes = headingTypesWithoutEmittedRule(
+      customHeadingTypes(themeDef),
+      `${component.join('\n')}\n${onMediaCss}`,
+    );
+    if (unemittedHeadingTypes.length > 0) {
+      throw new AstryxError(
+        unemittedHeadingTypes
+          .map(
+            type =>
+              `Custom Heading type "${type}" has no declaration the theme ` +
+              `compiler could emit: every declaration in its standalone ` +
+              `"type:${type}" rule was dropped. Give that rule at least one ` +
+              'valid declaration.',
+          )
+          .join('\n'),
+        undefined,
+        ERROR_CODES.ERR_THEME_INVALID,
+      );
+    }
     if (cssParts.length === 0) {
-      logger.log('No overrides found — nothing to build.');
+      logger.log('No overrides found; nothing to build.');
       return null;
     }
     // The data-token defaults are theme-independent and go in @layer
@@ -2425,7 +2495,18 @@ async function themeBuildInternal(
     // Guard: relative paths must not escape cwd via `../`. Absolute paths are
     // trusted (the user explicitly controls where output goes, like gcc -o).
     if (!path.isAbsolute(options.out)) {
-      assertWithin(options.out, cwd, {label: 'output path'});
+      try {
+        assertWithin(options.out, cwd, {label: 'output path'});
+      } catch (err) {
+        if (err instanceof PathSafetyError) {
+          throw new AstryxError(
+            err.message,
+            undefined,
+            ERROR_CODES.ERR_PATH_TRAVERSAL,
+          );
+        }
+        throw err;
+      }
     }
   } else {
     outPath = path.join(path.dirname(filePath), `${baseName}.css`);
@@ -2534,10 +2615,10 @@ async function themeBuildInternal(
     const stale = staleBuildOutputs(writes, cwd);
     const upToDate = stale.length === 0;
     if (upToDate) {
-      logger.log(`\n✓ Theme outputs are up to date with ${sourceRelative}.`);
+      logger.log(`\n[ok] Theme outputs are up to date with ${sourceRelative}.`);
     } else {
       logger.error(
-        `\n✗ ${stale.length} theme output(s) are out of date with ${sourceRelative}:`,
+        `\n[fail] ${stale.length} theme output(s) are out of date with ${sourceRelative}:`,
       );
       for (const s of stale) {
         logger.error(
@@ -2559,17 +2640,17 @@ async function themeBuildInternal(
 
   writeBuildOutputs(writes);
 
-  logger.log(`\n✓ ${path.relative(cwd, outPath)}`);
+  logger.log(`\n[ok] ${path.relative(cwd, outPath)}`);
   logger.log(
     `  ${tokenCount} token overrides, ${componentCount} component overrides`,
   );
   logger.log(`  ${size} KB`);
-  logger.log(`✓ ${path.relative(cwd, jsPath)}`);
-  logger.log(`✓ ${path.relative(cwd, dtsPath)}`);
+  logger.log(`[ok] ${path.relative(cwd, jsPath)}`);
+  logger.log(`[ok] ${path.relative(cwd, dtsPath)}`);
   if (variantDtsPath && variantDecl) {
     const augCount = (variantDecl.match(/': true;/g) || []).length;
     logger.log(
-      `✓ ${path.relative(cwd, variantDtsPath)} (${augCount} type augmentations)`,
+      `[ok] ${path.relative(cwd, variantDtsPath)} (${augCount} type augmentations)`,
     );
   }
 
@@ -2579,7 +2660,7 @@ async function themeBuildInternal(
   const cssImport = importSpecifier(relOutDir, cssBase) + '.css';
   const exportName = `${toIdentifier(baseName)}Theme`;
   logger.log(`
-Install in your app (paths are relative to a file in src/ — adjust if yours lives elsewhere):
+Install in your app (paths are relative to a file in src/; adjust if yours lives elsewhere):
 
   import { ${exportName} } from '${jsImport}';
   import '${cssImport}';
@@ -2611,7 +2692,7 @@ Or with a <link> tag:
   // Adaptation rules are resolved theme writes in their own right, so a family
   // named only inside one needs the same notice as one named at the root.
   for (const family of unloadedFonts) {
-    const msg = `Font "${family}" is named by this theme but not loaded — add a <link> or @font-face in your app (recipe: astryx docs typography)`;
+    const msg = `Font "${family}" is named by this theme but not loaded; add a <link> or @font-face in your app (recipe: astryx docs typography)`;
     noticeMessages.push(msg);
     logger.log(`  note: ${msg}`);
   }
@@ -2905,11 +2986,11 @@ export async function themeBuildFamily(
     const upToDate = stale.length === 0;
     if (upToDate) {
       logger.log(
-        `\n✓ Theme family outputs are up to date with ${sourceRelative}.`,
+        `\n[ok] Theme family outputs are up to date with ${sourceRelative}.`,
       );
     } else {
       logger.error(
-        `\n✗ ${stale.length} theme family output(s) are out of date:`,
+        `\n[fail] ${stale.length} theme family output(s) are out of date:`,
       );
       for (const entry of stale) {
         logger.error(
@@ -2929,7 +3010,7 @@ export async function themeBuildFamily(
     };
   }
   writeBuildOutputs(writes);
-  for (const output of Object.values(outputs)) logger.log(`✓ ${output}`);
+  for (const output of Object.values(outputs)) logger.log(`[ok] ${output}`);
   const themeBindings = members.map(member => bindings.get(member.theme.name));
   const relOutDir = path.relative(cwd, outDir) || '.';
   const jsImport = importSpecifier(relOutDir, baseName);
@@ -2947,7 +3028,7 @@ Or load the same stylesheet natively:
   ];
   const notices = unloadedFonts.map(
     family =>
-      `Font "${family}" is named by this theme family but not loaded — add a <link> or @font-face in your app (recipe: astryx docs typography)`,
+      `Font "${family}" is named by this theme family but not loaded; add a <link> or @font-face in your app (recipe: astryx docs typography)`,
   );
   for (const notice of notices) logger.log(`  note: ${notice}`);
   return {

package/api/theme/build/build.public-component-vars.test.mjs

@@ -19,7 +19,7 @@
  * next one is covered without touching this file.
  *
  * Asserted on the receipt's `warnings` rather than on a rejection: a private
- * var is reported (logged `✗`, collected into the receipt) and the build then
+ * var is reported (logged `[error]`, collected into the receipt) and the build then
  * emits its CSS and resolves anyway. Asserting a throw would pass for the
  * wrong reason — it never throws, which is why a throwaway build read as a
  * pass on the first version of #5214.

package/api/theme/build/build.receipt-doc.test.mjs

@@ -0,0 +1,111 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * Every field `themeBuild()` returns is named in its FunctionDoc and in the
+ * response-types doc.
+ *
+ * The receipt is a stable machine-readable response, so each field needs
+ * consumer documentation, not only a typedef. The fields are read off a real
+ * build, so a field added to the receipt without documentation fails here.
+ */
+
+import {describe, it, expect, beforeAll, afterEach} from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import {themeBuild} from './build.mjs';
+import {doc} from '../themeBuild.doc.mjs';
+import {doc as responseTypes} from '../../../foundation/response/response-types.doc.mjs';
+import {ensureCoreBuilt} from '../../../clients/cli/commands/ensure-core-built.mjs';
+
+/** @type {string[]} */
+const dirs = [];
+
+beforeAll(() => {
+  ensureCoreBuilt();
+}, 200_000);
+
+afterEach(() => {
+  for (const dir of dirs.splice(0)) {
+    fs.rmSync(dir, {recursive: true, force: true});
+  }
+});
+
+/** @returns {string} a temp dir holding a theme that exercises every field */
+function themeDir() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'astryx-receipt-doc-'));
+  dirs.push(dir);
+  fs.writeFileSync(
+    path.join(dir, 'ocean.mjs'),
+    `export default {
+  name: 'ocean',
+  tokens: {'--color-background-body': '#ffffff', '--font-family-body': '"Inter", sans-serif'},
+  components: {progressbar: {base: {color: 'red'}}},
+};
+`,
+  );
+  return dir;
+}
+
+/** @param {string} type */
+function returnsDescription(type) {
+  const entry = doc.returns?.find(r => r.type === type);
+  expect(entry, `themeBuild doc has no ${type} return`).toBeDefined();
+  return /** @type {{description: string}} */ (entry).description;
+}
+
+/** @param {string} description @param {string[]} fields */
+function undocumented(description, fields) {
+  return fields.filter(
+    field => !new RegExp(String.raw`\b${field}\b`).test(description),
+  );
+}
+
+describe('themeBuild() consumer docs name every receipt field', () => {
+  it('theme.build', async () => {
+    const dir = themeDir();
+    const result = await themeBuild('ocean.mjs', {}, {cwd: dir});
+
+    expect(result?.type).toBe('theme.build');
+    const data = /** @type {Record<string, any>} */ (result?.data);
+    // The theme is chosen so the optional arrays are non-empty.
+    expect(data.warnings.length).toBeGreaterThan(0);
+    expect(data.notices.length).toBeGreaterThan(0);
+
+    const fields = [
+      ...Object.keys(data),
+      ...Object.keys(data.outputs),
+      'variantsDts',
+    ];
+    expect(undocumented(returnsDescription('theme.build'), fields)).toEqual([]);
+  });
+
+  it('theme.build in the response-types doc', async () => {
+    const dir = themeDir();
+    const result = await themeBuild('ocean.mjs', {}, {cwd: dir});
+    const data = /** @type {Record<string, any>} */ (result?.data);
+    const member = responseTypes.members.find(m => m.value === 'theme.build');
+    expect(member, 'response-types has no theme.build member').toBeDefined();
+
+    const fields = [
+      ...Object.keys(data),
+      ...Object.keys(data.outputs),
+      'variantsDts',
+    ];
+    expect(
+      undocumented(/** @type {{description: string}} */ (member).description, fields),
+    ).toEqual([]);
+  });
+
+  it('theme.build.check', async () => {
+    const dir = themeDir();
+    const result = await themeBuild('ocean.mjs', {check: true}, {cwd: dir});
+
+    expect(result?.type).toBe('theme.build.check');
+    const data = /** @type {Record<string, any>} */ (result?.data);
+    const fields = [...Object.keys(data), ...Object.keys(data.stale[0])];
+    expect(
+      undocumented(returnsDescription('theme.build.check'), fields),
+    ).toEqual([]);
+  });
+});

package/api/theme/build/build.rollback.test.mjs

@@ -0,0 +1,148 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * `theme build` writes its CSS, JS, and declarations as one transaction: when
+ * a later output fails to publish, every output it already replaced gets its
+ * previous bytes back and every output it created is removed. Publishing is
+ * forced to fail by wrapping the two calls that publish a staged file:
+ * `linkSync` for a new file and `renameSync` for a replacement.
+ *
+ * Separate file because vi.mock is hoisted and affects the whole module.
+ * `themeBuild` needs a built core; the `node` project's globalSetup builds it.
+ */
+
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+const failures = vi.hoisted(() => ({
+  /** Fail the Nth staged-file publish (1-based); 0 disables. */
+  publish: 0,
+  count: 0,
+}));
+
+vi.mock('node:fs', async importOriginal => {
+  const actual = /** @type {typeof import('node:fs')} */ (
+    await importOriginal()
+  );
+  /** @param {string} source @param {string} op */
+  const maybeFail = (source, op) => {
+    if (!path.basename(String(source)).includes('.tmp')) return;
+    if (failures.publish === 0) return;
+    failures.count++;
+    if (failures.count === failures.publish) {
+      throw Object.assign(new Error(`EIO: forced ${op} failure`), {
+        code: 'EIO',
+      });
+    }
+  };
+  return {
+    ...actual,
+    linkSync: vi.fn((source, destination) => {
+      maybeFail(source, 'link');
+      return actual.linkSync(source, destination);
+    }),
+    renameSync: vi.fn((source, destination) => {
+      maybeFail(source, 'rename');
+      return actual.renameSync(source, destination);
+    }),
+  };
+});
+
+const fs = await import('node:fs');
+const {themeBuild} = await import('./build.mjs');
+
+vi.setConfig({testTimeout: 30000});
+
+let tmpDir;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(
+    path.join(os.tmpdir(), 'astryx-theme-build-rollback-'),
+  );
+  failures.publish = 0;
+  failures.count = 0;
+});
+
+afterEach(() => {
+  failures.publish = 0;
+  fs.rmSync(tmpDir, {recursive: true, force: true});
+});
+
+/**
+ * Write a source for the theme named `rollbacktheme`. Each call uses a new
+ * file so the loader cannot serve an earlier version from its cache.
+ * @param {string} file @param {string} background
+ */
+function writeTheme(file, background) {
+  fs.writeFileSync(
+    path.join(tmpDir, file),
+    `export default { name: 'rollbacktheme', tokens: { '--color-bg': '${background}' } };\n`,
+  );
+  return file;
+}
+
+const OUTPUTS = ['rollbacktheme.css', 'rollbacktheme.js', 'rollbacktheme.d.ts'];
+
+/** @returns {Map<string, Buffer | null>} */
+function readOutputs() {
+  return new Map(
+    OUTPUTS.map(name => {
+      const file = path.join(tmpDir, name);
+      return [name, fs.existsSync(file) ? fs.readFileSync(file) : null];
+    }),
+  );
+}
+
+function strays() {
+  return fs
+    .readdirSync(tmpDir)
+    .filter(name => name.includes('.tmp') || name.includes('.restore-'));
+}
+
+describe('themeBuild rolls back a partial write', () => {
+  it('removes every created output when the second publish fails', async () => {
+    const source = writeTheme('first.mjs', '#0a0a0a');
+    failures.publish = 2;
+
+    await expect(themeBuild(source, {}, {cwd: tmpDir})).rejects.toMatchObject({
+      code: 'ERR_WRITE_FAILED',
+    });
+
+    for (const bytes of readOutputs().values()) expect(bytes).toBeNull();
+    expect(strays()).toEqual([]);
+  });
+
+  it('restores every replaced output when the second publish fails', async () => {
+    const first = await themeBuild(
+      writeTheme('first.mjs', '#0a0a0a'),
+      {},
+      {cwd: tmpDir},
+    );
+    expect(first?.type).toBe('theme.build');
+    const before = readOutputs();
+    for (const bytes of before.values()) expect(bytes).not.toBeNull();
+
+    const next = writeTheme('next.mjs', '#fafafa');
+    failures.publish = 2;
+    await expect(themeBuild(next, {}, {cwd: tmpDir})).rejects.toMatchObject({
+      code: 'ERR_WRITE_FAILED',
+    });
+
+    const after = readOutputs();
+    for (const name of OUTPUTS) {
+      expect(
+        after.get(name)?.equals(/** @type {Buffer} */ (before.get(name))),
+      ).toBe(true);
+    }
+
+    // The failed build really had different bytes to write.
+    failures.publish = 0;
+    await themeBuild(next, {}, {cwd: tmpDir});
+    const css = readOutputs().get('rollbacktheme.css');
+    expect(
+      css?.equals(/** @type {Buffer} */ (before.get('rollbacktheme.css'))),
+    ).toBe(false);
+    expect(strays()).toEqual([]);
+  });
+});