@xingwangzhe/stalux 1.34.0 → 1.35.1

package/README.md

@@ -93,6 +93,7 @@ bun run dev
 - 🗺️ **Sitemap** (bundled; `.md` source endpoints auto-filtered)
 - 🖼️ **PhotoSwipe** image lightbox
 - 📊 **Mermaid** diagrams and flowcharts
+  Uses Merman through `@xingwangzhe/satteri-mermaid@0.8.1`, with the `dark` theme and a transparent canvas by default. The plugin supports 11 theme presets; see the [configuration reference](https://github.com/xingwangzhe/satteri-mermaid/blob/v0.8.1/docs/configuration.md). Rendering failures throw by default.
 - 📐 **Math formula rendering** (Temml → MathML)
 - 💬 **Waline** comment system
 - 🤖 **LLM discovery files** (llms.txt / llms-full.txt)
@@ -301,3 +302,11 @@ Article bodies and summary cards are up to 840px wide. Summaries use the existin
 Visitor weather is optional: set `weather: { enabled: true }` in `stalux/config/site.yml` to show it as plain text in the footer (with visitor IP and approximate location) and below the desktop article clock. Omitted or `false` disables it. It automatically requests an approximate city from IP.SB (with IPinfo as fallback) and weather from Open-Meteo, only while visible; no browser GPS permission is requested. These external services receive the visitor IP, and Open-Meteo receives rounded coordinates. A 20-minute session cache stores the city, visitor IP and weather, without coordinates. Visitors behind VPNs may see the exit city. Hidden tabs, offscreen cards and Astro navigation stop work; unavailable services show a retry action and retain previous weather. Open-Meteo's free endpoint is for non-commercial use subject to its limits; the card links to its attribution licence. No server endpoint or extra package is needed.
 
 Archives keep a transparent, single-column year/month timeline with all articles expanded. Each month gently fades and moves into place once when it enters the viewport (280ms), using native browser APIs without extra dependencies. Reduced motion, printing, missing browser APIs and disabled JavaScript retain the complete static list. Mobile dates sit above wrapping article titles. No new configuration is required. Article titles retain a single hover underline; hovering or keyboard-focusing a title previews its existing `desc` on the right, falling below near viewport edges. Empty descriptions show no preview, and touch navigation stays direct. The preview uses the browser top layer (with a high stacking-level fallback) to avoid clipping or overlap.
+
+### Production style compaction (1.35.0)
+
+Development keeps readable source names. Production builds compact private Stalux classes, custom properties and keyframes before Astro compilation and asset hashing, using a version-local mapping shipped with the package. Templates, client selectors, inline styles and dynamic server-generated animations share the mapping; its contents and transformer source participate in incremental cache invalidation.
+
+Stable `data-*` hooks, article anchors, public font properties (`--font-body`, `--font-code`, plus the legacy override hooks `--accent` and `--foreground-60p`), third-party interfaces and user content keep their meaning. Use your own classes and public component interfaces for extensions; the generated `s*`, `--s*` and `k*` names are reserved for the theme. Existing CSS import paths remain available and consumers need no additional configuration or UnoCSS installation.
+
+Theme CSS uses native nesting, modern RGB syntax, `overflow-wrap: anywhere` and clipped one-pixel accessible content with `clip-path`. Lightning CSS targets modern browser engines instead of generating obsolete compatibility expansions. Necessary multiline-clamping and third-party MathML browser adaptations remain. Production source maps are disabled to avoid exposing the original names. Build assertions check semantic CSS/HTML/JS surfaces and resource integrity without modifying article text or code examples; detector results always identify the rule or scanner version used.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@xingwangzhe/stalux",
-    "version": "1.34.0",
+    "version": "1.35.1",
     "description": "A powerful, modern Astro blog theme — use as template or install as plugin",
     "keywords": [
         "astro",
@@ -91,26 +91,30 @@
         "prepare": "git config core.hooksPath scripts/git-hooks",
         "dev:debug": "STALUX_DEBUG=1 astro dev --verbose",
         "build:debug": "STALUX_DEBUG=1 astro build --verbose && node scripts/verify-build.ts",
-        "styles:build": "node scripts/build-styles.ts",
+        "styles:build": "node scripts/build-styles.ts && node scripts/build-style-names.ts",
         "styles:watch": "node scripts/build-styles.ts --watch"
     },
     "dependencies": {
+        "@astrojs/compiler": "2.13.1",
         "@astrojs/markdown-satteri": "0.4.2",
         "@astrojs/partytown": "2.1.8",
         "@astrojs/rss": "^4.0.19",
         "@astrojs/sitemap": "^3.7.4",
+        "@babel/parser": "7.29.9",
         "@expressive-code/plugin-line-numbers": "^0.44.2",
         "@lucide/astro": "^1.47.0",
         "@mcp-b/webmcp-polyfill": "^5.1.0",
         "@pagefind/component-ui": "^1.5.2",
         "@waline/client": "3.16.0",
         "@xingwangzhe/cjk-font-split-native": "0.2.0",
-        "@xingwangzhe/satteri-mermaid": "0.7.8",
+        "@xingwangzhe/satteri-mermaid": "0.8.1",
         "@xingwangzhe/satteri-photoswipe": "^0.2.5",
         "@xingwangzhe/tags-cloud": "^1.2.8",
         "astro-expressive-code": "^0.44.2",
         "astro-seo": "^1.2.0",
         "badge-maker": "^6.0.0",
+        "css-tree": "3.2.1",
+        "magic-string": "0.30.21",
         "pagefind": "^1.5.2",
         "parse5": "8.0.1",
         "photoswipe": "^5.4.4",
@@ -122,6 +126,7 @@
     "devDependencies": {
         "@astrojs/check": "0.9.10",
         "@biomejs/biome": "2.5.14",
+        "@types/css-tree": "^3.2.0",
         "@types/node": "^26.6.2",
         "@unocss/astro": "^66.10.5",
         "@vitest/coverage-v8": "5.0.1",

package/src/components/stalux/common/Typewriter.astro

@@ -33,7 +33,7 @@ registerPageLifecycle("typewriter", mountTypewriters);
     padding: 0;
     margin: -1px;
     overflow: hidden;
-    clip: rect(0, 0, 0, 0);
+    clip-path: inset(50%);
     white-space: nowrap;
     border: 0;
 }
@@ -80,7 +80,7 @@ registerPageLifecycle("typewriter", mountTypewriters);
         height: auto;
         margin: 0;
         overflow: visible;
-        clip: auto;
+        clip-path: none;
         white-space: normal;
     }
 }

package/src/components/stalux/tags/tagsCloud.astro

@@ -30,6 +30,7 @@ const tagLinks = tagList.map((t) => ({
                 <a
                     href={`/tags/${name}/`}
                     class="stalux-cloud-tag-card"
+                    data-stalux-card
                     data-stalux-tag-card
                     data-count={count}
                     data-astro-prefetch

package/src/index.ts

@@ -1,3 +1,6 @@
+import { compactStylesPlugin } from "./internal/compact-styles.ts";
+import { modernCssTargets } from "./internal/modern-css.ts";
+import { styleNames } from "./internal/style-names.generated.ts";
 /**
  * Stalux — Astro 博客主题集成入口
  *
@@ -162,6 +165,7 @@ export function stalux(options: StaluxOptions = {}): AstroIntegration[] {
                 updateConfig,
                 addDevToolbarApp,
                 config,
+                command,
                 logger,
             }) => {
                 const started = performance.now();
@@ -176,6 +180,8 @@ export function stalux(options: StaluxOptions = {}): AstroIntegration[] {
                     path.join(srcDir, "scripts"),
                     path.resolve(srcDir, "../package.json"),
                     path.join(srcDir, "styles"),
+                    JSON.stringify([styleNames, modernCssTargets]) +
+                        readFileSync(path.join(srcDir, "internal/compact-styles.ts"), "utf8"),
                 );
 
                 // 1. 注入 Vite 别名 + 组件覆盖插件 + Vue 特性标记（Waline 依赖）
@@ -187,14 +193,21 @@ export function stalux(options: StaluxOptions = {}): AstroIntegration[] {
                             config.build.inlineStylesheets === "always" ? "always" : "never",
                     },
                     vite: {
-                        build: { target: config.vite.build?.target ?? "esnext" },
+                        css: { lightningcss: { targets: modernCssTargets } },
+                        build: {
+                            target: config.vite.build?.target ?? "esnext",
+                            cssMinify: "lightningcss",
+                            sourcemap: false,
+                        },
                         resolve: {
                             alias: createViteAliases(srcDir),
                         },
                         plugins: [
+                            ...(command === "build" ? [compactStylesPlugin(srcDir)] : []),
                             staluxComponentsAlias(opt.components, logger.fork("stalux/components")),
                         ],
                         define: {
+                            __STALUX_COMPACT_STYLES__: JSON.stringify(command === "build"),
                             __STALUX_DEBUG__: JSON.stringify(
                                 process.env.STALUX_DEBUG === "1" ||
                                     process.argv.includes("--verbose"),
@@ -278,6 +291,7 @@ export function stalux(options: StaluxOptions = {}): AstroIntegration[] {
                             mermaidHast({
                                 responsive: true,
                                 theme: "dark",
+                                themeVariables: { background: "transparent" },
                                 themeOverrides: { clusterBorder: "#cccccc" },
                             }),
                             seen,

package/src/internal/compact-styles.ts

@@ -0,0 +1,322 @@
+import path from "node:path";
+import { parse as parseAstro } from "@astrojs/compiler";
+import { parseExpression, parse as parseScript } from "@babel/parser";
+import { generate, ident, parse, walk } from "css-tree";
+import MagicString from "magic-string";
+import { parseFragment } from "parse5";
+import type { Plugin } from "vite";
+import { styleNameIn } from "./style-name-lookup.ts";
+import { styleNames } from "./style-names.generated.ts";
+
+type Names = typeof styleNames;
+
+/** Rename parsed CSS tokens, preserving strings, URLs and unrelated third-party names. */
+export function compactCss(css: string, names: Names = styleNames, inline = false): string {
+    const ast = parse(css, {
+        context: inline ? "declarationList" : "stylesheet",
+        parseCustomProperty: true,
+    });
+    walk(ast, function (node) {
+        if (node.type === "ClassSelector")
+            node.name = styleNameIn(names.classes, ident.decode(node.name)) ?? node.name;
+        if (node.type === "Declaration")
+            node.property = styleNameIn(names.variables, node.property) ?? node.property;
+        if (node.type === "Identifier") {
+            node.name =
+                styleNameIn(names.variables, node.name) ??
+                (this.atrule?.name === "keyframes" ||
+                this.declaration?.property === "animation" ||
+                this.declaration?.property === "animation-name"
+                    ? styleNameIn(names.animations, node.name)
+                    : undefined) ??
+                node.name;
+        }
+        if (node.type === "AttributeSelector" && node.name.name === "class" && node.value) {
+            if (node.matcher !== "=" && node.matcher !== "~=")
+                throw new Error(
+                    "Theme class substring selectors must use explicit classes before compaction",
+                );
+            if (node.value.type === "String")
+                node.value.value = compactTokens(node.value.value, names);
+            if (node.value.type === "Identifier")
+                node.value.name = styleNameIn(names.classes, node.value.name) ?? node.value.name;
+        }
+    });
+    return generate(ast);
+}
+
+function compactTokens(value: string, names: Names): string {
+    // Selectors have two namespaces: class names are private, data attribute values are stable.
+    if (value.includes("[data-")) {
+        try {
+            const selector = parse(value, { context: "selectorList" });
+            walk(selector, (node) => {
+                if (node.type === "ClassSelector")
+                    node.name = styleNameIn(names.classes, ident.decode(node.name)) ?? node.name;
+            });
+            return generate(selector);
+        } catch {
+            // A template quasi may end inside an attribute selector. Its data values stay literal.
+            return value;
+        }
+    }
+    return value.replace(
+        /--[\w-]+|[a-zA-Z_][\w-]*/gu,
+        (name) =>
+            styleNameIn(names.classes, name) ??
+            styleNameIn(names.variables, name) ??
+            styleNameIn(names.animations, name) ??
+            name,
+    );
+}
+
+type Edit = { start: number; end: number; text: string };
+
+/** Parse real markup attributes; leave text and code examples untouched. */
+function markupEdits(value: string, names: Names): Edit[] {
+    const edits: Edit[] = [];
+    const ast = parseFragment(value, { sourceCodeLocationInfo: true });
+    function visit(node: typeof ast | (typeof ast.childNodes)[number]) {
+        if ("tagName" in node) {
+            if (["pre", "code", "script", "style"].includes(node.tagName)) return;
+            for (const attr of node.attrs) {
+                const loc = node.sourceCodeLocation?.attrs?.[attr.name];
+                if (!loc || !["class", "style", "data-toc-active-class"].includes(attr.name))
+                    continue;
+                const raw = value.slice(loc.startOffset, loc.endOffset);
+                const offset = loc.startOffset + raw.indexOf("=") + 1;
+                const body = value.slice(offset, loc.endOffset);
+                if (attr.name === "style") {
+                    const leading = body.match(/^\s*(["'])?/u)?.[0] ?? "";
+                    const quote = leading.at(-1);
+                    const css = body.slice(
+                        leading.length,
+                        quote === '"' || quote === "'" ? -1 : undefined,
+                    );
+                    const cssAst = parse(css, {
+                        context: "declarationList",
+                        positions: true,
+                        parseCustomProperty: true,
+                    });
+                    walk(cssAst, function (token) {
+                        if (!token.loc) return;
+                        let next: string | undefined;
+                        let end = token.loc.end.offset;
+                        if (token.type === "Declaration") {
+                            next = styleNameIn(names.variables, token.property);
+                            end = token.loc.start.offset + token.property.length;
+                        }
+                        if (token.type === "Identifier")
+                            next =
+                                styleNameIn(names.variables, token.name) ??
+                                (["animation", "animation-name"].includes(
+                                    this.declaration?.property ?? "",
+                                )
+                                    ? styleNameIn(names.animations, token.name)
+                                    : undefined);
+                        if (next)
+                            edits.push({
+                                start: offset + leading.length + token.loc.start.offset,
+                                end: offset + leading.length + end,
+                                text: next,
+                            });
+                    });
+                } else
+                    for (const match of body.matchAll(/[a-zA-Z_][\w-]*/gu)) {
+                        const next = styleNameIn(names.classes, match[0]);
+                        if (next)
+                            edits.push({
+                                start: offset + match.index,
+                                end: offset + match.index + match[0].length,
+                                text: next,
+                            });
+                    }
+            }
+        }
+        if ("childNodes" in node) for (const child of node.childNodes) visit(child);
+    }
+    visit(ast);
+    return edits;
+}
+
+function compactMarkup(value: string, names: Names): string {
+    const output = new MagicString(value);
+    for (const edit of markupEdits(value, names)) output.overwrite(edit.start, edit.end, edit.text);
+    return output.toString();
+}
+
+function visitSyntax(
+    value: unknown,
+    callback: (node: Record<string, unknown>) => boolean | undefined,
+): void {
+    if (!value || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+        for (const entry of value) visitSyntax(entry, callback);
+        return;
+    }
+    const node = value as Record<string, unknown>;
+    if (typeof node.type === "string" && callback(node) === false) return;
+    for (const [key, child] of Object.entries(node))
+        if (key !== "loc" && key !== "extra" && key !== "comments") visitSyntax(child, callback);
+}
+
+/** Parse source literals; never rewrite generated bundles or consumer modules. */
+export function compactScript(code: string, names: Names = styleNames, expression = false): string {
+    const ast = expression
+        ? parseExpression(code, { plugins: ["typescript"] })
+        : parseScript(code, { sourceType: "module", plugins: ["typescript"] });
+    const output = new MagicString(code);
+    visitSyntax(ast, (node) => {
+        if (
+            node.type === "ImportDeclaration" ||
+            node.type === "ImportExpression" ||
+            node.type === "ExportAllDeclaration"
+        )
+            return false;
+        if (
+            node.type === "StringLiteral" &&
+            typeof node.value === "string" &&
+            typeof node.start === "number" &&
+            typeof node.end === "number"
+        ) {
+            const next = node.value.includes("<")
+                ? compactMarkup(node.value, names)
+                : compactTokens(node.value, names);
+            if (next !== node.value) output.overwrite(node.start, node.end, JSON.stringify(next));
+        }
+        if (
+            node.type === "TemplateLiteral" &&
+            typeof node.start === "number" &&
+            typeof node.end === "number"
+        ) {
+            const segments = node.quasis as Array<{
+                start: number;
+                end: number;
+                value: { raw: string };
+            }>;
+            const bodyStart = node.start + 1;
+            const expressions = node.expressions as Array<{ start: number; end: number }>;
+            const masked = new MagicString(code.slice(bodyStart, node.end - 1));
+            for (const expr of expressions)
+                masked.overwrite(
+                    expr.start - 2 - bodyStart,
+                    expr.end + 1 - bodyStart,
+                    "x".repeat(expr.end - expr.start + 3),
+                );
+            const html = masked.toString();
+            if (html.includes("<")) {
+                for (const edit of markupEdits(html, names)) {
+                    const start = bodyStart + edit.start;
+                    const end = bodyStart + edit.end;
+                    if (!expressions.some((expr) => start < expr.end + 1 && end > expr.start - 2))
+                        output.overwrite(start, end, edit.text);
+                }
+            } else
+                for (const segment of segments) {
+                    const next = compactTokens(segment.value.raw, names);
+                    if (next !== segment.value.raw)
+                        output.overwrite(segment.start, segment.end, next);
+                }
+        }
+    });
+    return output.toString();
+}
+
+export async function compactAstro(code: string, names: Names = styleNames): Promise<string> {
+    const { ast } = await parseAstro(code);
+    const output = new MagicString(code);
+    const sourceBytes = Buffer.from(code);
+    const offsetOf = (offset: number) => sourceBytes.subarray(0, offset).toString("utf8").length;
+    function visit(node: typeof ast | (typeof ast.children)[number]) {
+        if (node.type === "frontmatter") {
+            const start = offsetOf(node.position?.start.offset ?? 0) + 3;
+            output.overwrite(start, start + node.value.length, compactScript(node.value, names));
+        }
+        if ("attributes" in node)
+            for (const attr of node.attributes) {
+                const byteOffset = attr.position?.start.offset;
+                const offset = byteOffset === undefined ? undefined : offsetOf(byteOffset);
+                if (offset === undefined || attr.kind === "empty" || attr.kind === "spread")
+                    continue;
+                const equals = code.indexOf("=", offset + attr.name.length);
+                const start = equals + 1 + (code.slice(equals + 1).match(/^\s*/u)?.[0].length ?? 0);
+                if (
+                    attr.kind === "expression" &&
+                    (attr.name === "class" ||
+                        attr.name === "class:list" ||
+                        attr.name === "style" ||
+                        attr.name === "data-toc-active-class")
+                ) {
+                    const next = compactScript(attr.value, names, true);
+                    if (next !== attr.value)
+                        output.overwrite(start + 1, start + 1 + attr.value.length, next);
+                } else if (
+                    attr.kind === "quoted" &&
+                    ["class", "style", "data-toc-active-class"].includes(attr.name)
+                ) {
+                    const next =
+                        attr.name === "style"
+                            ? compactCss(attr.value, names, true)
+                            : compactTokens(attr.value, names);
+                    if (next !== attr.value)
+                        output.overwrite(
+                            start,
+                            start + (attr.raw?.length ?? attr.value.length + 2),
+                            JSON.stringify(next),
+                        );
+                }
+            }
+        if (
+            "name" in node &&
+            (node.name === "style" || node.name === "script") &&
+            "children" in node
+        ) {
+            for (const child of node.children)
+                if (child.type === "text" && child.position?.end) {
+                    const next =
+                        node.name === "style"
+                            ? compactCss(child.value, names)
+                            : compactScript(child.value, names);
+                    if (next !== child.value)
+                        output.overwrite(
+                            offsetOf(child.position.start.offset),
+                            offsetOf(child.position.end.offset),
+                            next,
+                        );
+                }
+            return;
+        }
+        if ("children" in node) for (const child of node.children) visit(child);
+    }
+    visit(ast);
+    return output.toString();
+}
+
+export function compactStylesPlugin(srcDir: string): Plugin {
+    const root = path.resolve(srcDir) + path.sep;
+    return {
+        name: "stalux:compact-styles",
+        enforce: "pre",
+        transform: {
+            order: "pre",
+            async handler(code, id) {
+                const filename = id.split("?")[0] ?? "";
+                if (!filename.startsWith(root)) return;
+                const relative = filename.slice(root.length).replaceAll(path.sep, "/");
+                if (
+                    !/^(?:components|layouts|pages|scripts|utils|styles)\//u.test(relative) ||
+                    relative === "utils/style-name.ts" ||
+                    relative.endsWith(".md.ts")
+                )
+                    return;
+                let next: string;
+                if (id.includes("astro&type=")) return;
+                if (filename.endsWith(".astro")) next = await compactAstro(code);
+                else if (filename.endsWith(".css")) next = compactCss(code);
+                else if (filename.endsWith(".ts")) next = compactScript(code);
+                else return;
+                return next === code ? undefined : { code: next, map: null };
+            },
+        },
+    };
+}

package/src/internal/font-slices.ts

@@ -1,3 +1,4 @@
+import { styleNames } from "./style-names.generated.ts";
 /**
  * Build-time CJK font subsetting engine.
  *
@@ -128,6 +129,7 @@ type HtmlNode = DefaultTreeAdapterMap["node"];
 const NON_RENDERED_ELEMENTS = new Set(["script", "style", "template", "title"]);
 const VISUALLY_HIDDEN_CLASSES = new Set([
     "agent-home-summary",
+    styleNames.classes["agent-home-summary"] ?? "agent-home-summary",
     "screen-reader-only",
     "sr-only",
     "visually-hidden",

package/src/internal/modern-css.ts

@@ -0,0 +1,7 @@
+// Modern CSS output floor for the 1.35 release. Older fallback expansions are unnecessary.
+// Acceptance uses current stable browser engines; targets intentionally retain native nesting.
+export const modernCssTargets = {
+    chrome: 154 << 16,
+    firefox: 157 << 16,
+    safari: (26 << 16) | (6 << 8),
+};

package/src/internal/runtime-cache-key.ts

@@ -29,6 +29,7 @@ export function createRuntimeCacheKey(
     scriptsDirectory: string,
     packageJson: string,
     stylesDirectory?: string,
+    styleMapping?: string,
 ): string {
     return hashRuntimeSources([
         ...collectFiles(scriptsDirectory),
@@ -40,6 +41,7 @@ export function createRuntimeCacheKey(
                       readFileSync(path.join(stylesDirectory, name), "utf8"),
                   ])
             : []),
+        ...(styleMapping ? [["style-names", styleMapping] as const] : []),
         ["package.json", readFileSync(packageJson, "utf8")],
     ]);
 }

package/src/internal/style-artifacts.ts

@@ -0,0 +1,94 @@
+import { parse, walk } from "css-tree";
+import { parse as parseHtml } from "parse5";
+import { styleNameIn } from "./style-name-lookup.ts";
+import { styleNames } from "./style-names.generated.ts";
+
+// Public enthec/webappanalyzer Tailwind CSS rule snapshot, retrieved 2026-10-04.
+// t.json SHA-256: aa96b868b7ad19eccd6c1337a59e14f4ff692a5bcb531a7a1021a3cfef7ab1e4
+const tailwindMarkers =
+    /--tw-[\w-]+|@(?:apply|tailwind)\b|\/\*!\s*tailwindcss\b|(?:cdn\.)?tailwindcss\.(?:com|js)|\/npm\/@tailwindcss\/browser/iu;
+
+/** Check semantic style surfaces, leaving article prose and code examples intact. */
+export function styleArtifactProblems(filename: string, source: string): string[] {
+    const problems: string[] = [];
+    if (filename.endsWith(".css")) {
+        if (tailwindMarkers.test(source))
+            problems.push("Tailwind CSS fingerprint or uncompiled directive");
+        walk(parse(source, { parseCustomProperty: true }), (node) => {
+            if (node.type === "ClassSelector" && styleNameIn(styleNames.classes, node.name))
+                problems.push(`uncompacted class ${node.name}`);
+            if (node.type === "Declaration" && styleNameIn(styleNames.variables, node.property))
+                problems.push(`uncompacted variable ${node.property}`);
+            if (
+                node.type === "Identifier" &&
+                (styleNameIn(styleNames.variables, node.name) ||
+                    styleNameIn(styleNames.animations, node.name))
+            )
+                problems.push(`uncompacted CSS reference ${node.name}`);
+        });
+    } else if (filename.endsWith(".html")) {
+        const ast = parseHtml(source);
+        function visit(node: typeof ast | (typeof ast.childNodes)[number]) {
+            if ("tagName" in node) {
+                if (node.tagName === "pre" || node.tagName === "code") return;
+                for (const attr of node.attrs) {
+                    if (attr.name === "class")
+                        for (const name of attr.value.split(/\s+/u)) {
+                            if (styleNameIn(styleNames.classes, name))
+                                problems.push(`uncompacted HTML class ${name}`);
+                        }
+                    if (attr.name === "style")
+                        for (const match of attr.value.matchAll(/--[\w-]+/gu)) {
+                            if (styleNameIn(styleNames.variables, match[0]))
+                                problems.push(`uncompacted inline variable ${match[0]}`);
+                        }
+                    if (
+                        (attr.name === "src" || attr.name === "href") &&
+                        tailwindMarkers.test(attr.value)
+                    )
+                        problems.push("Tailwind CDN reference");
+                }
+                if (
+                    node.tagName === "script" &&
+                    "childNodes" in node &&
+                    !node.attrs.some(
+                        (attr) =>
+                            attr.name === "type" &&
+                            !["module", "text/javascript"].includes(attr.value),
+                    )
+                ) {
+                    for (const child of node.childNodes)
+                        if ("value" in child)
+                            problems.push(...styleArtifactProblems("inline.js", child.value));
+                }
+                if (node.tagName === "style" && "childNodes" in node)
+                    for (const child of node.childNodes) {
+                        if ("value" in child)
+                            problems.push(...styleArtifactProblems("inline.css", child.value));
+                    }
+            }
+            if ("childNodes" in node) for (const child of node.childNodes) visit(child);
+        }
+        visit(ast);
+    } else if (filename.endsWith(".js")) {
+        if (tailwindMarkers.test(source)) problems.push("Tailwind script fingerprint");
+        const styleReferences = source.replace(/\[data-[^\]]+\]/gu, "");
+        for (const match of styleReferences.matchAll(/--[\w-]+|[a-zA-Z_][\w-]*/gu)) {
+            if (
+                styleNameIn(styleNames.classes, match[0]) ||
+                styleNameIn(styleNames.variables, match[0]) ||
+                styleNameIn(styleNames.animations, match[0])
+            )
+                problems.push(`uncompacted script name ${match[0]}`);
+        }
+    } else if (filename.endsWith(".map")) {
+        const map = JSON.parse(source) as { sourcesContent?: string[] };
+        if (
+            map.sourcesContent?.some((content) =>
+                /style-names\.generated|stalux-main|--un-/u.test(content),
+            )
+        )
+            problems.push("public sourcemap exposes theme names");
+    }
+    return [...new Set(problems)];
+}

package/src/internal/style-name-lookup.ts

@@ -0,0 +1,4 @@
+/** Dictionary access must not resolve inherited names such as constructor or toString. */
+export function styleNameIn(table: Record<string, string>, name: string): string | undefined {
+    return Object.hasOwn(table, name) ? table[name] : undefined;
+}