@xingwangzhe/stalux 1.35.11 → 1.35.12

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@xingwangzhe/stalux",
-    "version": "1.35.11",
+    "version": "1.35.12",
     "description": "A powerful, modern Astro blog theme — use as template or install as plugin",
     "keywords": [
         "astro",
@@ -94,7 +94,9 @@
         "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 && node scripts/build-style-names.ts",
-        "styles:watch": "node scripts/build-styles.ts --watch"
+        "styles:watch": "node scripts/build-styles.ts --watch",
+        "benchmark:performance": "node scripts/benchmark-performance.ts",
+        "benchmark:builds": "python3 scripts/benchmark-builds.py"
     },
     "dependencies": {
         "@astrojs/compiler": "^4.0.0",

package/src/index.ts

@@ -1,3 +1,4 @@
+import { forEachBounded } from "./internal/bounded-tasks.ts";
 import { compactStylesPlugin } from "./internal/compact-styles.ts";
 import { modernCssTargets } from "./internal/modern-css.ts";
 import { styleNames } from "./internal/style-names.generated.ts";
@@ -521,9 +522,7 @@ export function stalux(options: StaluxOptions = {}): AstroIntegration[] {
                     );
                 };
                 // Bound I/O concurrency without retaining the entire site's HTML in memory.
-                for (let offset = 0; offset < pageEntries.length; offset += 4) {
-                    await Promise.all(pageEntries.slice(offset, offset + 4).map(processPage));
-                }
+                await forEachBounded(pageEntries, 4, processPage);
                 if (pageFontData) {
                     clearPageFontSubsets(pageFontData.outputDir, referencedPageFonts);
                 }

package/src/internal/bounded-tasks.ts

@@ -0,0 +1,28 @@
+/** Work-conserving queue: one slow task never stalls the other workers. */
+export async function forEachBounded<T>(
+    items: readonly T[],
+    concurrency: number,
+    task: (item: T) => Promise<unknown>,
+): Promise<void> {
+    if (!Number.isInteger(concurrency) || concurrency < 1)
+        throw new RangeError("Concurrency must be a positive integer");
+    let cursor = 0;
+    let failed = false;
+    const worker = async () => {
+        while (!failed && cursor < items.length) {
+            const item = items[cursor++] as T;
+            try {
+                await task(item);
+            } catch (error) {
+                failed = true;
+                throw error;
+            }
+        }
+    };
+    // Wait for active tasks to settle before returning a failure to the build.
+    const results = await Promise.allSettled(
+        Array.from({ length: Math.min(concurrency, items.length) }, worker),
+    );
+    const failure = results.find((result) => result.status === "rejected");
+    if (failure?.status === "rejected") throw failure.reason;
+}

package/src/internal/compact-styles.ts

@@ -201,19 +201,27 @@ export function compactScript(code: string, names: Names = styleNames, expressio
             }>;
             const bodyStart = node.start + 1;
             const expressions = node.expressions as Array<{ start: number; end: number }>;
-            const masked = new MagicString(source.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("<")) {
+            if (segments.some((segment) => segment.value.raw.includes("<"))) {
+                const masked = new MagicString(source.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();
                 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))
+                    let low = 0;
+                    let high = expressions.length;
+                    while (low < high) {
+                        const middle = (low + high) >>> 1;
+                        if ((expressions[middle]?.end ?? 0) + 1 <= start) low = middle + 1;
+                        else high = middle;
+                    }
+                    const expressionAtEdit = expressions[low];
+                    if (!expressionAtEdit || end <= expressionAtEdit.start - 2)
                         output.overwrite(start, end, edit.text);
                 }
             } else
@@ -233,11 +241,44 @@ export function compactScript(code: string, names: Names = styleNames, expressio
     return expression ? output.toString().slice(1, -1) : output.toString();
 }
 
+/** Map requested UTF-8 byte offsets to UTF-16 without repeatedly decoding prefixes. */
+export function mapUtf8Offsets(code: string, locations: Iterable<number>): Map<number, number> {
+    const requested = [...locations].sort((a, b) => a - b);
+    const offsets = new Map<number, number>();
+    let index = 0;
+    let bytes = 0;
+    let units = 0;
+    for (const char of code) {
+        const point = char.codePointAt(0) as number;
+        const width = point <= 0x7f ? 1 : point <= 0x7ff ? 2 : point <= 0xffff ? 3 : 4;
+        while (index < requested.length && (requested[index] as number) < bytes + width) {
+            const offset = requested[index++] as number;
+            offsets.set(offset, units + (offset > bytes ? 1 : 0));
+        }
+        bytes += width;
+        units += char.length;
+    }
+    while (index < requested.length) offsets.set(requested[index++] as number, units);
+    return offsets;
+}
+
 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;
+    // Collect only requested locations: O(source + locations log locations),
+    // O(locations) storage instead of decoding every source prefix again.
+    const locations = new Set<number>([0]);
+    function collectLocations(node: typeof ast | (typeof ast.children)[number]) {
+        if (node.position?.start) locations.add(node.position.start.offset);
+        if (node.position?.end) locations.add(node.position.end.offset);
+        if ("attributes" in node)
+            for (const attr of node.attributes)
+                if (attr.position?.start) locations.add(attr.position.start.offset);
+        if ("children" in node) for (const child of node.children) collectLocations(child);
+    }
+    collectLocations(ast);
+    const offsets = mapUtf8Offsets(code, locations);
+    const offsetOf = (offset: number) => offsets.get(offset) ?? 0;
     function visit(node: typeof ast | (typeof ast.children)[number]) {
         if (node.type === "frontmatter") {
             const start = offsetOf(node.position?.start.offset ?? 0) + 3;
@@ -250,7 +291,8 @@ export async function compactAstro(code: string, names: Names = styleNames): Pro
                 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);
+                let start = equals + 1;
+                while (start < code.length && /\s/u.test(code[start] as string)) start++;
                 if (
                     attr.kind === "expression" &&
                     (attr.name === "class" ||

package/src/internal/font-slices.ts

@@ -209,22 +209,31 @@ function findBody(node: HtmlNode): HtmlNode | undefined {
 }
 
 function isHiddenElement(attrs: Array<{ name: string; value: string }>): boolean {
-    const attributes = new Map(attrs.map(({ name, value }) => [name, value]));
-    if (attributes.has("hidden") || attributes.has("inert")) return true;
-
-    const classes = (attributes.get("class") ?? "").split(/\s+/u);
+    let className = "";
+    let style = "";
+    for (const attr of attrs) {
+        if (attr.name === "hidden" || attr.name === "inert") return true;
+        if (attr.name === "class") className = attr.value;
+        if (attr.name === "style") style = attr.value;
+    }
+    const classes = className.split(/\s+/u);
     if (classes.some((name) => VISUALLY_HIDDEN_CLASSES.has(name))) return true;
 
-    const style = attributes.get("style") ?? "";
     return /(?:^|;)\s*(?:display\s*:\s*none|visibility\s*:\s*hidden|content-visibility\s*:\s*hidden)\s*(?:;|$)/iu.test(
         style,
     );
 }
 
 /** Collect renderable body text nodes, including content inside collapsed controls. */
-function collectBodyText(node: HtmlNode, output: string[]): void {
+const CONTROL_CHARACTER = /\p{C}/u;
+function addGlyphs(text: string, output: Set<string>): void {
+    for (const char of text)
+        if (!output.has(char) && !CONTROL_CHARACTER.test(char)) output.add(char);
+}
+
+function collectBodyText(node: HtmlNode, output: Set<string>): void {
     if (node.nodeName === "#text" && "value" in node) {
-        output.push(node.value);
+        addGlyphs(node.value, output);
         return;
     }
 
@@ -240,9 +249,10 @@ function collectBodyText(node: HtmlNode, output: string[]): void {
 }
 
 function formatUnicodeRange(chars: string[]): string {
-    const points = chars.map((char) => char.codePointAt(0) as number).sort((a, b) => a - b);
     const ranges: Array<[number, number]> = [];
-    for (const point of points) {
+    // preparePageFont already sorts the unique glyphs by code point.
+    for (const char of chars) {
+        const point = char.codePointAt(0) as number;
         const last = ranges.at(-1);
         if (last && point === last[1] + 1) last[1] = point;
         else ranges.push([point, point]);
@@ -298,15 +308,14 @@ function preparePageFont(
     const body = findBody(document);
     if (!body) return undefined;
 
-    const bodyText: string[] = [
-        ...[...html.matchAll(/<style\b[^>]*>([\s\S]*?)<\/style\s*>/gi)].map(([, css]) =>
-            cssGeneratedText(css ?? ""),
-        ),
-        linkedStylesheetText,
-    ];
-    collectBodyText(body, bodyText);
-    const glyphSource = `${RESERVED_GLYPHS}${extraChars}${bodyText.join("")}`;
-    const chars = [...new Set([...glyphSource].filter((char) => !/\p{C}/u.test(char)))].sort(
+    const glyphs = new Set<string>();
+    addGlyphs(RESERVED_GLYPHS, glyphs);
+    addGlyphs(extraChars, glyphs);
+    addGlyphs(linkedStylesheetText, glyphs);
+    for (const [, css] of html.matchAll(/<style\b[^>]*>([\s\S]*?)<\/style\s*>/gi))
+        addGlyphs(cssGeneratedText(css ?? ""), glyphs);
+    collectBodyText(body, glyphs);
+    const chars = [...glyphs].sort(
         (a, b) => (a.codePointAt(0) as number) - (b.codePointAt(0) as number),
     );
     if (chars.length === 0) return undefined;

package/src/internal/page-output-cache.ts

@@ -24,9 +24,19 @@ export async function createPageOutputCache(
     }
     const namespace = path.join(directory, hash.digest("hex"));
     await fs.mkdir(namespace, { recursive: true });
-    const assetDigests = new Map<string, string>();
-    for (const asset of assets) assetDigests.set(asset, digest(await fs.readFile(asset)));
-    const key = (entry: string, html: string) => digest(`${entry}\0${html}`);
+    const knownAssets = new Set(assets);
+    const assetDigests = new Map<string, Promise<string | null>>();
+    const assetDigest = (asset: string): Promise<string | null> => {
+        if (!knownAssets.has(asset)) return Promise.resolve(null);
+        let pending = assetDigests.get(asset);
+        if (!pending) {
+            pending = fs.readFile(asset).then(digest, () => null);
+            assetDigests.set(asset, pending);
+        }
+        return pending;
+    };
+    const key = (entry: string, html: string) =>
+        createHash("sha256").update(entry).update("\0").update(html).digest("hex");
     return {
         async get(entry: string, html: string): Promise<CachedPageOutput | undefined> {
             try {
@@ -37,7 +47,7 @@ export async function createPageOutputCache(
                     return undefined;
                 if (!Array.isArray(record.assets)) return undefined;
                 for (const [asset, expected] of record.assets) {
-                    if ((assetDigests.get(asset) ?? null) !== expected) return undefined;
+                    if ((await assetDigest(asset)) !== expected) return undefined;
                 }
                 if (record.font) {
                     if (
@@ -66,10 +76,9 @@ export async function createPageOutputCache(
                 JSON.stringify({
                     ...output,
                     digest: digest(output.html),
-                    assets: referencedAssets.map((asset) => [
-                        asset,
-                        assetDigests.get(asset) ?? null,
-                    ]),
+                    assets: await Promise.all(
+                        referencedAssets.map(async (asset) => [asset, await assetDigest(asset)]),
+                    ),
                 }),
             );
             await fs.rename(temporary, target);

package/src/pages/api/posts.json.ts

@@ -1,5 +1,5 @@
 import { getCollection } from "astro:content";
-import { analyzeFeatureFlags } from "@plugins/feature-flags";
+import { getPostDescriptions } from "@utils/word-count-utils";
 import type { APIRoute } from "astro";
 
 export const prerender = true;
@@ -13,19 +13,18 @@ export const prerender = true;
 export const GET: APIRoute = async ({ logger }) => {
     const posts = await getCollection("posts", ({ data }) => !data.draft);
 
-    const payload = await Promise.all(
-        posts.map(async (post) => ({
-            title: post.data.title,
-            abbrlink: String(post.data.abbrlink),
-            date: post.data.date ?? undefined,
-            updated: post.data.updated ?? undefined,
-            tags: post.data.tags ?? [],
-            categories: post.data.categories ?? [],
-            desc: post.data.desc ?? "",
-            wordCount: (await analyzeFeatureFlags(post.body, logger)).wordCount,
-            url: `/posts/${post.data.abbrlink}/`,
-        })),
-    );
+    const descriptions = await getPostDescriptions(logger);
+    const payload = posts.map((post) => ({
+        title: post.data.title,
+        abbrlink: String(post.data.abbrlink),
+        date: post.data.date ?? undefined,
+        updated: post.data.updated ?? undefined,
+        tags: post.data.tags ?? [],
+        categories: post.data.categories ?? [],
+        desc: post.data.desc ?? "",
+        wordCount: descriptions.get(String(post.data.abbrlink))?.wordCount ?? 0,
+        url: `/posts/${post.data.abbrlink}/`,
+    }));
 
     return new Response(JSON.stringify(payload), {
         status: 200,

package/src/plugins/feature-flags.ts

@@ -290,7 +290,14 @@ export function analyzeFeatureFlags(
     }
     logDetail(logger, "markdown-analysis", "cache miss; analyzing feature flags");
 
-    const resultPromise = analyzeFeatureFlagsUncached(content);
+    if (import.meta.env.DEV && analysisCache.size >= 128) {
+        const oldest = analysisCache.keys().next().value;
+        if (oldest !== undefined) analysisCache.delete(oldest);
+    }
+    const resultPromise = analyzeFeatureFlagsUncached(content).catch((error: unknown) => {
+        if (analysisCache.get(content) === resultPromise) analysisCache.delete(content);
+        throw error;
+    });
     analysisCache.set(content, resultPromise);
     return resultPromise;
 }

package/src/scripts/navigation.ts

@@ -10,7 +10,7 @@ interface SearchDialog extends HTMLElement {
     close?: () => void;
 }
 
-async function openSearchDialog(): Promise<void> {
+async function openSearchDialog(signal: AbortSignal): Promise<void> {
     logger.debug("loading search UI");
     await Promise.all([
         import("@pagefind/component-ui"),
@@ -18,6 +18,7 @@ async function openSearchDialog(): Promise<void> {
             document.querySelector<HTMLLinkElement>("link[data-stalux-search-style]"),
         ),
     ]);
+    if (signal.aborted) return;
     const dialog = document.querySelector<SearchDialog>("pagefind-modal#search");
     await upgradeAndOpenSearchDialog(
         {
@@ -25,6 +26,7 @@ async function openSearchDialog(): Promise<void> {
             upgrade: (element) => customElements.upgrade(element),
         },
         dialog,
+        signal,
     );
 }
 
@@ -105,7 +107,7 @@ registerPageLifecycle("navigation", () => {
             event.preventDefault();
             closeNav();
             try {
-                await openSearchDialog();
+                await openSearchDialog(controller.signal);
                 logger.debug("search dialog opened");
             } catch (error) {
                 logger.error("search dialog failed to open; next click can retry", error);

package/src/scripts/photoswipe.ts

@@ -7,9 +7,10 @@ const logger = createClientLogger("photoswipe");
 
 const GALLERY_SELECTOR = "a.pswp-gallery-item";
 
-async function enrichPhotoSwipeData(container: Element): Promise<void> {
+async function enrichPhotoSwipeData(container: Element, signal: AbortSignal): Promise<void> {
     const links = container.querySelectorAll<HTMLAnchorElement>(GALLERY_SELECTOR);
     for (const link of links) {
+        if (signal.aborted) return;
         const image = link.querySelector<HTMLImageElement>("img");
         if (!image) continue;
 
@@ -21,12 +22,18 @@ async function enrichPhotoSwipeData(container: Element): Promise<void> {
 
         const temporaryImage = new Image();
         temporaryImage.src = image.currentSrc || image.src;
+        const cancel = () => temporaryImage.removeAttribute("src");
+        signal.addEventListener("abort", cancel, { once: true });
         try {
             await temporaryImage.decode();
         } catch {
+            if (signal.aborted) return;
             logger.debug("image dimensions unavailable; skipping enrichment");
             continue;
+        } finally {
+            signal.removeEventListener("abort", cancel);
         }
+        if (signal.aborted) return;
         link.dataset.pswpWidth = String(temporaryImage.naturalWidth);
         link.dataset.pswpHeight = String(temporaryImage.naturalHeight);
     }
@@ -41,6 +48,7 @@ registerPageLifecycle("photoswipe", () => {
     const controller = new AbortController();
     let lightbox: import("photoswipe/lightbox").default | undefined;
     let initialized = false;
+    let disposed = false;
 
     const initialize = async () => {
         logger.debug("loading lightbox modules");
@@ -48,8 +56,8 @@ registerPageLifecycle("photoswipe", () => {
             import("photoswipe/lightbox"),
             import("photoswipe"),
         ]);
-
-        void enrichPhotoSwipeData(container);
+        if (disposed) return;
+        void enrichPhotoSwipeData(container, controller.signal);
         lightbox = new PhotoSwipeLightbox({
             gallery: container,
             children: GALLERY_SELECTOR,
@@ -77,6 +85,7 @@ registerPageLifecycle("photoswipe", () => {
 
         void ensureInitialized()
             .then(() => {
+                if (disposed) return;
                 initialized = true;
                 logger.debug(`opening image index=${clickedIndex}`);
                 lightbox?.loadAndOpen(clickedIndex, undefined, initialPoint);
@@ -92,6 +101,7 @@ registerPageLifecycle("photoswipe", () => {
     });
 
     return () => {
+        disposed = true;
         controller.abort();
         lightbox?.destroy();
         lightbox = undefined;

package/src/scripts/random-posts.ts

@@ -5,21 +5,23 @@ const logger = createClientLogger("random-posts");
 
 const sleep = (ms: number, signal: AbortSignal) =>
     new Promise<void>((resolve) => {
-        const timer = window.setTimeout(resolve, ms);
-        signal.addEventListener(
-            "abort",
-            () => {
-                window.clearTimeout(timer);
-                resolve();
-            },
-            { once: true },
-        );
+        const finish = () => {
+            signal.removeEventListener("abort", aborted);
+            resolve();
+        };
+        const timer = window.setTimeout(finish, ms);
+        const aborted = () => {
+            window.clearTimeout(timer);
+            finish();
+        };
+        if (signal.aborted) aborted();
+        else signal.addEventListener("abort", aborted, { once: true });
     });
 
 function shuffle<T extends object>(items: T[]): T[] {
     const result = [...items];
+    const bytes = new Uint32Array(1);
     for (let i = result.length - 1; i > 0; i -= 1) {
-        const bytes = new Uint32Array(1);
         const j = (crypto.getRandomValues(bytes)[0] ?? 0) % (i + 1);
         const current = result[i];
         const target = result[j];

package/src/scripts/search-dialog.ts

@@ -34,9 +34,10 @@ export async function ensureSearchStyles(link: HTMLLinkElement | null): Promise<
 export async function upgradeAndOpenSearchDialog<ElementType extends SearchDialogLike>(
     registry: CustomElementRegistryLike<ElementType>,
     dialog: ElementType | null,
+    signal?: AbortSignal,
 ): Promise<void> {
     await registry.whenDefined("pagefind-modal");
-    if (!dialog) return;
+    if (!dialog || signal?.aborted) return;
     registry.upgrade(dialog);
     dialog.open?.();
 }

package/src/scripts/webmcp.ts

@@ -1,3 +1,4 @@
+import { createPostLookup } from "../utils/post-lookup";
 import { createClientLogger } from "./logger";
 
 /**
@@ -136,6 +137,16 @@ interface PostMeta {
 }
 
 let postsMetaPromise: Promise<PostMeta[] | null> | null = null;
+const postLookups = new WeakMap<PostMeta[], ReturnType<typeof createPostLookup<PostMeta>>>();
+
+function lookupFor(list: PostMeta[]) {
+    let lookup = postLookups.get(list);
+    if (!lookup) {
+        lookup = createPostLookup(list);
+        postLookups.set(list, lookup);
+    }
+    return lookup;
+}
 
 /** 加载文章元信息索引（惰性 + 缓存） */
 function loadPostsMeta(): Promise<PostMeta[] | null> {
@@ -149,16 +160,12 @@ function loadPostsMeta(): Promise<PostMeta[] | null> {
 
 /** 按 abbrlink 精确查找 */
 function findById(list: PostMeta[], id: string): PostMeta | undefined {
-    return list.find((p) => p.abbrlink === id);
+    return lookupFor(list).findById(id);
 }
 
 /** 按标题/标签关键词模糊查找（取第一条） */
 function findByKeyword(list: PostMeta[], keyword: string): PostMeta | undefined {
-    const kw = keyword.toLowerCase();
-    return (
-        list.find((p) => p.title.toLowerCase().includes(kw)) ??
-        list.find((p) => (p.tags ?? []).some((t) => t.toLowerCase().includes(kw)))
-    );
+    return lookupFor(list).findByKeyword(keyword);
 }
 
 /** 简化为输出用的元信息视图 */

package/src/scripts/word-list.ts

@@ -14,10 +14,16 @@ function scrollToWord(hash: string): void {
 registerPageLifecycle("word-list", () => {
     if (!document.querySelector("[data-word-hash]")) return;
     const controller = new AbortController();
+    let firstFrame = 0;
+    let secondFrame = 0;
 
     if (location.hash.startsWith("#word-")) {
-        requestAnimationFrame(() => {
-            requestAnimationFrame(() => scrollToWord(location.hash));
+        firstFrame = requestAnimationFrame(() => {
+            firstFrame = 0;
+            secondFrame = requestAnimationFrame(() => {
+                secondFrame = 0;
+                scrollToWord(location.hash);
+            });
         });
     }
 
@@ -35,5 +41,9 @@ registerPageLifecycle("word-list", () => {
         { signal: controller.signal },
     );
 
-    return () => controller.abort();
+    return () => {
+        controller.abort();
+        if (firstFrame) cancelAnimationFrame(firstFrame);
+        if (secondFrame) cancelAnimationFrame(secondFrame);
+    };
 });

package/src/utils/collections-stats.ts

@@ -1,26 +1,15 @@
 import type { AstroRuntimeLogger } from "astro";
 import { getPostContentIndex, type PostEntry } from "./content-index";
 
-/**
- * 统计 posts 中每个分类键出现的次数。
- * @param posts 文章集合
- * @param keyFn 从单篇文章取出若干分类键（如标签、分类）
- * @param defaultValue 文章没有任何分类键时的兜底分类名（可选）
- */
-function countBy(
-    posts: PostEntry[],
-    keyFn: (post: PostEntry) => string[] | undefined,
-    defaultValue?: string,
-): Array<{ name: string; count: number }> {
-    const counts = new Map<string, number>();
+/** Count the existing uncategorized fallback without building a second taxonomy map. */
+function countUncategorized(posts: PostEntry[]): number {
+    let count = 0;
     for (const post of posts) {
-        const keys = keyFn(post) ?? [];
-        const names = keys.length > 0 ? keys : defaultValue ? [defaultValue] : [];
-        for (const name of names) {
-            counts.set(name, (counts.get(name) ?? 0) + 1);
-        }
+        const names = post.data.categories ?? [];
+        if (!names.length) count++;
+        else for (const name of names) if (name === "uncategorized") count++;
     }
-    return [...counts].map(([name, count]) => ({ name, count }));
+    return count;
 }
 
 /**
@@ -42,9 +31,7 @@ export async function getCategoryCountList(logger?: AstroRuntimeLogger) {
         name,
         count: categoryPosts.length,
     }));
-    const uncategorized = countBy(posts, (post) => post.data.categories, "uncategorized").find(
-        ({ name }) => name === "uncategorized",
-    );
-    if (uncategorized) counts.push(uncategorized);
+    const uncategorized = countUncategorized(posts);
+    if (uncategorized) counts.push({ name: "uncategorized", count: uncategorized });
     return counts;
 }

package/src/utils/content-index.ts

@@ -47,8 +47,8 @@ function addToTaxonomy<T extends IndexablePost>(
     map: Map<string, MutableTaxonomyBucket<T>>,
     post: T,
     names: string[] | undefined,
+    timestamp: number,
 ): void {
-    const timestamp = toTimestamp(post.data.updated ?? post.data.date);
     for (const name of new Set(names ?? [])) {
         const existing = map.get(name);
         if (existing) {
@@ -94,8 +94,16 @@ function finalizeTaxonomy<T extends IndexablePost>(
 export function buildPostContentIndex<T extends IndexablePost>(
     sourcePosts: readonly T[],
 ): PostContentIndex<T> {
+    const times = new Map<T, { date: number; updated: number }>();
+    for (const post of sourcePosts) {
+        const date = toTimestamp(post.data.date);
+        times.set(post, {
+            date,
+            updated: post.data.updated == null ? date : toTimestamp(post.data.updated),
+        });
+    }
     const posts = sourcePosts.toSorted(
-        (left, right) => toTimestamp(right.data.date) - toTimestamp(left.data.date),
+        (left, right) => (times.get(right)?.date ?? 0) - (times.get(left)?.date ?? 0),
     );
     const byAbbrlink = new Map<string, T>();
     const tags = new Map<string, MutableTaxonomyBucket<T>>();
@@ -108,8 +116,9 @@ export function buildPostContentIndex<T extends IndexablePost>(
             throw new Error(`Duplicate post abbrlink: ${abbrlink}`);
         }
         byAbbrlink.set(abbrlink, post);
-        addToTaxonomy(tags, post, post.data.tags);
-        addToTaxonomy(categories, post, post.data.categories);
+        const timestamp = times.get(post)?.updated ?? 0;
+        addToTaxonomy(tags, post, post.data.tags, timestamp);
+        addToTaxonomy(categories, post, post.data.categories, timestamp);
         neighbors.set(abbrlink, {
             previous: posts[index + 1],
             next: index > 0 ? posts[index - 1] : undefined,

package/src/utils/dayjs.ts

@@ -18,6 +18,31 @@ export const toTimestamp = (v: unknown): number => parseDate(v).getTime();
 
 const pad2 = (n: number): string => String(n).padStart(2, "0");
 
+// Bounded across user-supplied zones; invalid zones still throw before caching.
+const timezoneFormatters = new Map<string, Intl.DateTimeFormat>();
+function getTimezoneFormatter(timeZone: string): Intl.DateTimeFormat {
+    let formatter = timezoneFormatters.get(timeZone);
+    if (!formatter) {
+        formatter = new Intl.DateTimeFormat("en-US", {
+            timeZone,
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            second: "2-digit",
+            hourCycle: "h23",
+            timeZoneName: "longOffset",
+        });
+        if (timezoneFormatters.size >= 16) {
+            const oldest = timezoneFormatters.keys().next().value;
+            if (oldest !== undefined) timezoneFormatters.delete(oldest);
+        }
+        timezoneFormatters.set(timeZone, formatter);
+    }
+    return formatter;
+}
+
 /**
  * 轻量 format：仅覆盖本项目实际用到的 token。
  * 支持：yyyy MM dd HH mm ss
@@ -51,17 +76,7 @@ export function formatInTimeZone(
     const d = date instanceof Date ? date : new Date(date);
     if (Number.isNaN(d.getTime())) return "";
 
-    const parts = new Intl.DateTimeFormat("en-US", {
-        timeZone,
-        year: "numeric",
-        month: "2-digit",
-        day: "2-digit",
-        hour: "2-digit",
-        minute: "2-digit",
-        second: "2-digit",
-        hourCycle: "h23",
-        timeZoneName: "longOffset",
-    }).formatToParts(d);
+    const parts = getTimezoneFormatter(timeZone).formatToParts(d);
 
     const get = (type: Intl.DateTimeFormatPartTypes): string =>
         parts.find((p) => p.type === type)?.value ?? "";

package/src/utils/feed.ts

@@ -32,43 +32,44 @@ export async function buildFeedItems(
     updatedTag: string,
     logger?: AstroRuntimeLogger,
 ): Promise<FeedItem[]> {
+    const timestamps = new Map(
+        posts.map((post) => [post, toTimestamp(post.data.updated || post.data.date)]),
+    );
     const sortedPosts = posts.toSorted((a, b) => {
         // Newest first: compare post dates, use the greater of updated/date
-        const aTime = toTimestamp(a.data.updated || a.data.date);
-        const bTime = toTimestamp(b.data.updated || b.data.date);
+        const aTime = timestamps.get(a) ?? 0;
+        const bTime = timestamps.get(b) ?? 0;
         return bTime - aTime;
     });
 
     const descriptions = await getPostDescriptions(logger);
     logDetail(logger, "feed", `rendering ${sortedPosts.length} entries; format=${updatedTag}`);
-    return Promise.all(
-        sortedPosts.map(async (post) => {
-            const cached = descriptions.get(String(post.data.abbrlink));
+    return sortedPosts.map((post) => {
+        const cached = descriptions.get(String(post.data.abbrlink));
 
-            let customData = "";
-            if (post.data.updated) {
-                const parsed = parseDate(post.data.updated);
-                if (isValid(parsed)) {
-                    const updatedIso = formatInTimeZone(
-                        parsed,
-                        stalux.timezone,
-                        "yyyy-MM-dd'T'HH:mm:ssXXX",
-                    );
-                    customData += `<${updatedTag}>${updatedIso}</${updatedTag}>`;
-                }
-            }
-            if (post.data.cc) {
-                customData += `<rights>${post.data.cc}</rights>`;
+        let customData = "";
+        if (post.data.updated) {
+            const parsed = parseDate(post.data.updated);
+            if (isValid(parsed)) {
+                const updatedIso = formatInTimeZone(
+                    parsed,
+                    stalux.timezone,
+                    "yyyy-MM-dd'T'HH:mm:ssXXX",
+                );
+                customData += `<${updatedTag}>${updatedIso}</${updatedTag}>`;
             }
+        }
+        if (post.data.cc) {
+            customData += `<rights>${post.data.cc}</rights>`;
+        }
 
-            return {
-                title: post.data.title,
-                pubDate: new Date(toMachineDateTime(post.data.date, stalux.timezone)),
-                description: cached?.desc || post.data.desc || "",
-                link: `/posts/${post.data.abbrlink}/`,
-                categories: post.data.categories || [],
-                customData,
-            };
-        }),
-    );
+        return {
+            title: post.data.title,
+            pubDate: new Date(toMachineDateTime(post.data.date, stalux.timezone)),
+            description: cached?.desc || post.data.desc || "",
+            link: `/posts/${post.data.abbrlink}/`,
+            categories: post.data.categories || [],
+            customData,
+        };
+    });
 }

package/src/utils/post-lookup.ts

@@ -0,0 +1,28 @@
+interface SearchablePost {
+    abbrlink: string;
+    title: string;
+    tags?: string[];
+}
+
+/** One immutable snapshot; duplicate IDs and fuzzy matches keep first-match order. */
+export function createPostLookup<T extends SearchablePost>(posts: readonly T[]) {
+    const byId = new Map<string, T>();
+    const searchable = posts.map((post) => {
+        if (!byId.has(post.abbrlink)) byId.set(post.abbrlink, post);
+        return {
+            post,
+            title: post.title.toLowerCase(),
+            tags: post.tags?.map((tag) => tag.toLowerCase()) ?? [],
+        };
+    });
+    return {
+        findById: (id: string): T | undefined => byId.get(id),
+        findByKeyword(keyword: string): T | undefined {
+            const query = keyword.toLowerCase();
+            return (
+                searchable.find(({ title }) => title.includes(query)) ??
+                searchable.find(({ tags }) => tags.some((tag) => tag.includes(query)))
+            )?.post;
+        },
+    };
+}

package/src/utils/toc-scrollspy.ts

@@ -25,6 +25,8 @@ export function initTocScrollSpy(activeClass: string): (() => void) | undefined
     let pending = false;
     let frameId = 0;
     let sidebarHovered = false;
+    const headingOrder = new Map(headings.map((heading, index) => [heading, index]));
+    const visibleHeadings = new Set<HTMLElement>();
     const controller = new AbortController();
 
     // 鼠标悬停在侧边栏上时跳过自动滚动，避免跟用户手动操作冲突
@@ -61,7 +63,12 @@ export function initTocScrollSpy(activeClass: string): (() => void) | undefined
     };
 
     const observer = new IntersectionObserver(
-        () => {
+        (entries) => {
+            for (const entry of entries) {
+                const heading = entry.target as HTMLElement;
+                if (entry.isIntersecting) visibleHeadings.add(heading);
+                else visibleHeadings.delete(heading);
+            }
             // 用 rAF 合并同一帧内的多次回调，避免频繁触发布局计算
             if (pending) return;
             pending = true;
@@ -70,11 +77,17 @@ export function initTocScrollSpy(activeClass: string): (() => void) | undefined
                 pending = false;
 
                 // 找到视口上方 35% 区域内最靠上的标题
-                let current =
-                    headings.find((h) => {
-                        const rect = h.getBoundingClientRect();
-                        return rect.top < window.innerHeight * 0.35 && rect.bottom > 0;
-                    }) ?? null;
+                let current: HTMLElement | null = null;
+                let currentOrder = headings.length;
+                for (const heading of visibleHeadings) {
+                    const order = headingOrder.get(heading) ?? headings.length;
+                    if (order >= currentOrder) continue;
+                    const rect = heading.getBoundingClientRect();
+                    if (rect.top < window.innerHeight * 0.35 && rect.bottom > 0) {
+                        current = heading;
+                        currentOrder = order;
+                    }
+                }
 
                 // 兜底：滚动到文章底部时，取最后一个仍在视口上方或已经越过顶部的标题
                 current ??=
@@ -111,6 +124,7 @@ export function initTocScrollSpy(activeClass: string): (() => void) | undefined
     return () => {
         controller.abort();
         observer.disconnect();
+        visibleHeadings.clear();
         if (frameId) cancelAnimationFrame(frameId);
         activeLink?.classList.remove(activeClass);
     };

package/src/utils/word-count-utils.ts

@@ -7,65 +7,69 @@
 import { getCollection } from "astro:content";
 import { analyzeFeatureFlags } from "@plugins/feature-flags";
 import type { AstroRuntimeLogger } from "astro";
+import { forEachBounded } from "../internal/bounded-tasks";
 import { logDetail, logFailure } from "./diagnostics";
 
 // ---------------------------------------------------------------------------
 // 模块级缓存（整个构建周期只计算一次）
 // ---------------------------------------------------------------------------
 
-let _cachedTotal: number | null = null;
+interface PostStatistics {
+    total: number;
+    descriptions: Map<string, { desc: string; wordCount: number }>;
+}
 
-/**
- * 获取所有已发布文章的总字数（从 body 估算）。
- * 结果会被缓存，同一构建周期内重复调用不会重新计算。
- */
-export async function getTotalWordCount(logger?: AstroRuntimeLogger): Promise<number> {
-    if (_cachedTotal !== null) {
-        logDetail(logger, "word-count", "total cache hit");
-        return _cachedTotal;
+let statisticsPromise: Promise<PostStatistics> | undefined;
+
+function loadStatistics(logger?: AstroRuntimeLogger): Promise<PostStatistics> {
+    if (!statisticsPromise) {
+        statisticsPromise = (async () => {
+            const posts = await getCollection("posts", ({ data }) => !data.draft);
+            const results = new Array<{ id: string; desc: string; wordCount: number }>(
+                posts.length,
+            );
+            await forEachBounded(
+                posts.map((post, index) => ({ post, index })),
+                4,
+                async ({ post, index }) => {
+                    results[index] = {
+                        id: String(post.data.abbrlink ?? post.id),
+                        desc: post.data.desc || "",
+                        wordCount: (await analyzeFeatureFlags(post.body, logger)).wordCount,
+                    };
+                },
+            );
+            const descriptions = new Map<string, { desc: string; wordCount: number }>();
+            let total = 0;
+            for (const result of results) {
+                total += result.wordCount;
+                descriptions.set(result.id, { desc: result.desc, wordCount: result.wordCount });
+            }
+            logDetail(logger, "word-count", `analyzed ${posts.length} posts`);
+            return { total, descriptions };
+        })().catch((error: unknown) => {
+            statisticsPromise = undefined;
+            throw error;
+        });
     }
-    logDetail(logger, "word-count", "total cache miss");
+    return statisticsPromise;
+}
+
+/** Shared in-flight statistics prevent concurrent pages from repeating collection work. */
+export async function getTotalWordCount(logger?: AstroRuntimeLogger): Promise<number> {
     try {
-        const posts = await getCollection("posts", ({ data }) => !data.draft);
-        const results = await Promise.all(
-            posts.map((post) => analyzeFeatureFlags(post.body, logger)),
-        );
-        _cachedTotal = results.reduce((sum, result) => sum + result.wordCount, 0);
-        logDetail(logger, "word-count", `analyzed ${posts.length} posts`);
-        return _cachedTotal;
+        return (await loadStatistics(logger)).total;
     } catch (error) {
         logFailure(logger, "word-count", "total calculation failed; returning zero", error);
         return 0;
     }
 }
 
-let _cachedDescriptions: Map<string, { desc: string; wordCount: number }> | null = null;
-
-/**
- * 获取所有已发布文章的描述和字数缓存，供 RSS/Atom/LLMs feed 共享。
- * - desc   ：直接从 frontmatter 读取（post.data.desc）
- * - wordCount：从 Sätteri AST 分析 post.body
- */
+/** Keep collection insertion order and frontmatter descriptions unchanged. */
 export async function getPostDescriptions(
     logger?: AstroRuntimeLogger,
 ): Promise<Map<string, { desc: string; wordCount: number }>> {
-    if (_cachedDescriptions !== null) {
-        logDetail(logger, "word-count", "description cache hit");
-        return _cachedDescriptions;
-    }
-    logDetail(logger, "word-count", "description cache miss");
-    const posts = await getCollection("posts", ({ data }) => !data.draft);
-    const results = await Promise.all(
-        posts.map(async (post) => ({
-            id: String(post.data.abbrlink ?? post.id),
-            desc: post.data.desc || "",
-            wordCount: (await analyzeFeatureFlags(post.body, logger)).wordCount,
-        })),
-    );
-    _cachedDescriptions = new Map(
-        results.map((r) => [r.id, { desc: r.desc, wordCount: r.wordCount }]),
-    );
-    return _cachedDescriptions;
+    return (await loadStatistics(logger)).descriptions;
 }
 
 export function formatWordCount(count: number, lang?: string): string {