@xingwangzhe/stalux 1.35.12 → 1.35.13

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

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { readdirSync, readFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 import path from "node:path";
 
 declare const __STALUX_RUNTIME_CACHE_KEY__: string;
@@ -17,10 +17,15 @@ export function hashRuntimeSources(sources: ReadonlyArray<readonly [string, stri
     return hash.digest("hex").slice(0, 16);
 }
 
-function collectFiles(directory: string, root = directory): Array<readonly [string, string]> {
+function collectFiles(
+    directory: string,
+    root = directory,
+    include = (_name: string) => true,
+): Array<readonly [string, string]> {
     return readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
         const target = path.join(directory, entry.name);
-        if (entry.isDirectory()) return collectFiles(target, root);
+        if (entry.isDirectory()) return collectFiles(target, root, include);
+        if (!include(entry.name)) return [];
         return [[path.relative(root, target), readFileSync(target, "utf8")] as const];
     });
 }
@@ -30,9 +35,15 @@ export function createRuntimeCacheKey(
     packageJson: string,
     stylesDirectory?: string,
     styleMapping?: string,
+    configDirectory?: string,
 ): string {
     return hashRuntimeSources([
         ...collectFiles(scriptsDirectory),
+        ...(configDirectory && existsSync(configDirectory)
+            ? collectFiles(configDirectory, configDirectory, (name) => /\.ya?ml$/iu.test(name)).map(
+                  ([name, contents]) => [`config/${name}`, contents] as const,
+              )
+            : []),
         ...(stylesDirectory
             ? readdirSync(stylesDirectory)
                   .filter((name) => /^generated(?:-[a-z]+)?\.css$/u.test(name))

package/src/internal/style-names.generated.ts

@@ -193,32 +193,33 @@ export const styleNames: { classes: Record<string, string>; variables: Record<st
         "stalux-toc-title": "s59",
         "stalux-typewriter": "s5a",
         "stalux-typewriter-accessible": "s5b",
-        "stalux-typewriter-text": "s5c",
-        "stalux-u-flex": "s5d",
-        "stalux-u-flex-col": "s5e",
-        "stalux-u-flex-wrap": "s5f",
-        "stalux-u-items-center": "s5g",
-        "stalux-u-justify-center": "s5h",
-        "stalux-u-min-w-0": "s5i",
-        "stalux-u-text-center": "s5j",
-        "stalux-u-w-full": "s5k",
-        "stalux-weather": "s5l",
-        "stalux-weather-footer": "s5m",
-        "stalux-weather-heading": "s5n",
-        "stalux-weather-location": "s5o",
-        "stalux-weather-main": "s5p",
-        "stalux-weather-source": "s5q",
-        "stalux-weather-status": "s5r",
-        "stalux-word-body": "s5s",
-        "stalux-word-card": "s5t",
-        "stalux-word-date": "s5u",
-        "stalux-word-footer": "s5v",
-        "stalux-word-list-item": "s5w",
-        "stalux-word-list-list": "s5x",
-        "stalux-word-source-date": "s5y",
-        "stalux-word-source-link": "s5z",
-        "stalux-word-source-meta": "s60",
-        "stalux-word-source-text": "s61"
+        "stalux-typewriter-reserve": "s5c",
+        "stalux-typewriter-text": "s5d",
+        "stalux-u-flex": "s5e",
+        "stalux-u-flex-col": "s5f",
+        "stalux-u-flex-wrap": "s5g",
+        "stalux-u-items-center": "s5h",
+        "stalux-u-justify-center": "s5i",
+        "stalux-u-min-w-0": "s5j",
+        "stalux-u-text-center": "s5k",
+        "stalux-u-w-full": "s5l",
+        "stalux-weather": "s5m",
+        "stalux-weather-footer": "s5n",
+        "stalux-weather-heading": "s5o",
+        "stalux-weather-location": "s5p",
+        "stalux-weather-main": "s5q",
+        "stalux-weather-source": "s5r",
+        "stalux-weather-status": "s5s",
+        "stalux-word-body": "s5t",
+        "stalux-word-card": "s5u",
+        "stalux-word-date": "s5v",
+        "stalux-word-footer": "s5w",
+        "stalux-word-list-item": "s5x",
+        "stalux-word-list-list": "s5y",
+        "stalux-word-source-date": "s5z",
+        "stalux-word-source-link": "s60",
+        "stalux-word-source-meta": "s61",
+        "stalux-word-source-text": "s62"
     },
     "variables": {
         "--accent-20p": "--s0",

package/src/layouts/PostLayout.astro

@@ -58,6 +58,7 @@ const walineConfig = walineSection?.serverURL
 
         <!-- Main Content -->
         <PostContent
+            postId={props.postId}
             title={props.title}
             description={props.description}
             titleTransitionName={props.postId === undefined

package/src/layouts/Stalux.astro

@@ -36,7 +36,7 @@ const aiConfig = getAiDiscoveryData(configEntries);
 const htmlLang = siteConfig.lang || "zh-CN";
 
 // 背景 SVG 以静态 URL 硬编码在 background.ts（纯客户端），
-// 集成在 config:setup 时把 SVG 复制到用户项目 public/background/。
+// 集成在 config:done 时把 SVG 复制到用户项目最终的 publicDir/background/。
 // SSR 不渲染背景图，默认露出 .bg-layer 的灰墙底色（--stalux-bg-color），
 // 客户端运行时随机选图；不经过 import.meta.glob 资源管线，
 // 保证增量构建依赖图 hash 稳定。
@@ -77,6 +77,8 @@ const routeAnimation = getRouteAnimation(routeKind);
         data-stalux-site-url={siteConfig.url}
         data-stalux-site-description={siteConfig.description}
         data-stalux-site-lang={siteConfig.lang}
+        data-stalux-markdown-export={String(promoteConfig?.export_md === true)}
+        data-stalux-webmcp-enabled={String(aiConfig?.conformance !== "disabled")}
         data-stalux-ga-id={headConfig?.googleAnalyticsId}
         data-stalux-clarity-id={headConfig?.bingClarityId}
         data-stalux-umami-id={headConfig?.umami?.id}

package/src/pages/api/post.abbrlink.json.ts

@@ -16,9 +16,6 @@ export const GET: APIRoute = async () => {
         headers: {
             "Content-Type": "application/json; charset=utf-8",
             "Cache-Control": "public, max-age=0, must-revalidate",
-            "RateLimit-Limit": "60",
-            "RateLimit-Remaining": "59",
-            "RateLimit-Reset": "60",
         },
     });
 };

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

@@ -1,4 +1,5 @@
-import { getCollection } from "astro:content";
+import { getPostContentIndex } from "@utils/content-index";
+import { sitePath } from "@utils/site-path";
 import { getPostDescriptions } from "@utils/word-count-utils";
 import type { APIRoute } from "astro";
 
@@ -11,7 +12,7 @@ export const prerender = true;
  * 是 stalux_get_post / stalux_random_post 等 WebMCP 工具的廉价数据源。
  */
 export const GET: APIRoute = async ({ logger }) => {
-    const posts = await getCollection("posts", ({ data }) => !data.draft);
+    const { posts } = await getPostContentIndex();
 
     const descriptions = await getPostDescriptions(logger);
     const payload = posts.map((post) => ({
@@ -23,7 +24,7 @@ export const GET: APIRoute = async ({ logger }) => {
         categories: post.data.categories ?? [],
         desc: post.data.desc ?? "",
         wordCount: descriptions.get(String(post.data.abbrlink))?.wordCount ?? 0,
-        url: `/posts/${post.data.abbrlink}/`,
+        url: sitePath(`posts/${encodeURIComponent(String(post.data.abbrlink))}/`),
     }));
 
     return new Response(JSON.stringify(payload), {
@@ -31,9 +32,6 @@ export const GET: APIRoute = async ({ logger }) => {
         headers: {
             "Content-Type": "application/json; charset=utf-8",
             "Cache-Control": "public, max-age=0, must-revalidate",
-            "RateLimit-Limit": "60",
-            "RateLimit-Remaining": "59",
-            "RateLimit-Reset": "60",
         },
     });
 };

package/src/pages/openapi.json.ts

@@ -7,40 +7,6 @@ const responseSchema = {
     items: { type: "object", additionalProperties: true },
 };
 
-const problemSchema = {
-    type: "object",
-    required: ["type", "title", "status", "code", "detail"],
-    properties: {
-        type: { type: "string", format: "uri", description: "Stable problem type URI." },
-        title: { type: "string" },
-        status: { type: "integer", minimum: 400, maximum: 599 },
-        code: { type: "string", description: "Machine-readable error code." },
-        detail: { type: "string" },
-        resolution: { type: "string" },
-    },
-};
-
-const rateLimitHeaders = {
-    "RateLimit-Limit": {
-        description: "Maximum requests in the advertised window.",
-        schema: { type: "integer" },
-    },
-    "RateLimit-Remaining": {
-        description: "Remaining requests in the advertised window.",
-        schema: { type: "integer" },
-    },
-    "RateLimit-Reset": {
-        description: "Seconds until the advertised window resets.",
-        schema: { type: "integer" },
-    },
-};
-
-const problemResponse = (description: string, status: number) => ({
-    description,
-    content: { "application/problem+json": { schema: problemSchema } },
-    headers: status === 429 ? { "Retry-After": { schema: { type: "integer" } } } : undefined,
-});
-
 export const GET: APIRoute = async ({ site }) => {
     const server = site?.toString().replace(/\/$/, "") || "";
     const document = {
@@ -68,10 +34,7 @@ export const GET: APIRoute = async ({ site }) => {
                         "200": {
                             description: "Published post metadata",
                             content: { "application/json": { schema: responseSchema } },
-                            headers: rateLimitHeaders,
                         },
-                        "400": problemResponse("Invalid request.", 400),
-                        "429": problemResponse("Rate limit exceeded.", 429),
                     },
                 },
             },
@@ -85,10 +48,7 @@ export const GET: APIRoute = async ({ site }) => {
                         "200": {
                             description: "Published post identifiers",
                             content: { "application/json": { schema: responseSchema } },
-                            headers: rateLimitHeaders,
                         },
-                        "400": problemResponse("Invalid request.", 400),
-                        "429": problemResponse("Rate limit exceeded.", 429),
                     },
                 },
             },
@@ -97,7 +57,8 @@ export const GET: APIRoute = async ({ site }) => {
                     tags: ["Posts"],
                     operationId: "readPostMarkdown",
                     summary: "Read one post as Markdown",
-                    description: "Returns the normalized Markdown source for a published post.",
+                    description:
+                        "Returns normalized Markdown when promote.export_md is enabled. Otherwise this file is absent; HTTP errors and their body format are controlled by the static host.",
                     parameters: [
                         {
                             name: "abbrlink",
@@ -112,8 +73,6 @@ export const GET: APIRoute = async ({ site }) => {
                             description: "Markdown post content",
                             content: { "text/markdown": { schema: { type: "string" } } },
                         },
-                        "404": problemResponse("Post not found.", 404),
-                        "429": problemResponse("Rate limit exceeded.", 429),
                     },
                 },
             },
@@ -124,7 +83,7 @@ export const GET: APIRoute = async ({ site }) => {
             deprecation:
                 "Breaking changes are announced in the documentation and a Deprecation/Sunset response header may be added before removal.",
             rateLimits:
-                "Static exports publish RateLimit-* documentation headers but cannot enforce a dynamic quota or emit Retry-After without a server runtime.",
+                "These files are static. Stalux does not enforce per-client quotas or generate dynamic rate-limit/error responses; any hosting limits belong to the deployment provider.",
         },
     };
 

package/src/pages/posts/[post].md.ts

@@ -1,49 +1,13 @@
 import { type CollectionEntry, getCollection } from "astro:content";
+import { getRuntimeCacheKey } from "@internal/runtime-cache-key";
 import { type ConfigMap, isMarkdownExportEnabled, loadConfig } from "@utils/ai-discovery";
 import { buildCCLink, buildCCName } from "@utils/cc";
 import { createTranslator } from "@utils/i18n";
+import { reconstructMarkdown } from "@utils/post-markdown";
 import type { APIRoute, GetStaticPaths } from "astro";
 
 export const prerender = true;
 
-function reconstructMarkdown(post: CollectionEntry<"posts">): string {
-    const d = post.data;
-    const lines: string[] = ["---"];
-
-    lines.push(`title: ${yamlScalar(d.title)}`);
-    if (d.tags?.length)
-        lines.push(`tags:\n${d.tags.map((t) => `    - ${yamlScalar(t)}`).join("\n")}`);
-    if (d.categories?.length)
-        lines.push(`categories:\n${d.categories.map((c) => `    - ${yamlScalar(c)}`).join("\n")}`);
-    lines.push(`date: ${yamlScalar(d.date)}`);
-    if (d.updated) lines.push(`updated: ${yamlScalar(d.updated)}`);
-    lines.push(`desc: ${yamlScalar(d.desc)}`);
-    lines.push(`abbrlink: ${yamlScalar(String(d.abbrlink))}`);
-    if (d.draft) lines.push(`draft: true`);
-    if (d.cc && d.cc !== "CC-BY-NC-SA-4.0") lines.push(`cc: ${yamlScalar(d.cc)}`);
-    if (d.cover) lines.push(`cover: ${yamlScalar(d.cover)}`);
-
-    lines.push("---", "");
-    const body = typeof post.body === "string" ? post.body : "";
-    return lines.join("\n") + body + (body.endsWith("\n") ? "" : "\n");
-}
-
-function yamlScalar(value: string): string {
-    if (
-        value === "" ||
-        /[:#{}[\],&*?|>!%@`]/.test(value) ||
-        value.includes("\n") ||
-        value.startsWith(" ") ||
-        value.endsWith(" ") ||
-        value === "true" ||
-        value === "false" ||
-        value === "null"
-    ) {
-        return JSON.stringify(value);
-    }
-    return value;
-}
-
 /** 生成 Markdown 格式的版权脚注 */
 function generateCCFooter(post: CollectionEntry<"posts">, config: ConfigMap): string {
     const siteConfig = config.get("site") ?? {};
@@ -75,7 +39,7 @@ export const getStaticPaths = (async () => {
     const posts = await getCollection("posts", ({ data }) => !data.draft);
     return posts.map((post) => ({
         params: { post: String(post.data.abbrlink) },
-        cacheKey: post.data.updated ?? post.data.date,
+        cacheKey: `${post.data.updated ?? post.data.date}|${getRuntimeCacheKey()}`,
         props: { post },
     }));
 }) satisfies GetStaticPaths;
@@ -88,7 +52,7 @@ export const GET: APIRoute = async ({ props }) => {
 
     // 内容集合已经提供解析后的 frontmatter 和正文，导出一份内容等价的 Markdown。
     // 不读取 post.filePath，避免把页面端点绑定到 Node 文件系统。
-    let markdown = reconstructMarkdown(post);
+    let markdown = reconstructMarkdown(post.data, post.body);
 
     // 追加版权脚注（不修改内容源文件）
     const footer = generateCCFooter(post, config);

package/src/scripts/navigation-font.ts

@@ -0,0 +1,28 @@
+/** Warm the destination font while the old page is still visible. Never delay navigation indefinitely. */
+export async function prepareNavigationFont(
+    nextDocument: Document,
+    signal: AbortSignal,
+    timeoutMs = 1000,
+): Promise<void> {
+    const href = nextDocument
+        .querySelector<HTMLLinkElement>("link[data-stalux-page-font-preload]")
+        ?.getAttribute("href");
+    if (!href || signal.aborted || typeof FontFace === "undefined") return;
+    const url = new URL(href, window.location.href);
+    if (url.origin !== window.location.origin) return;
+    // Loading a detached face fills the font cache without replacing the old page's font.
+    const face = new FontFace("LXGW WenKai-Page Subset", `url(${JSON.stringify(url.href)})`, {
+        style: "normal",
+        weight: "100 900",
+    });
+    await new Promise<void>((resolve) => {
+        const finish = () => {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", finish);
+            resolve();
+        };
+        const timer = setTimeout(finish, timeoutMs);
+        signal.addEventListener("abort", finish, { once: true });
+        void face.load().then(finish, finish);
+    });
+}

package/src/scripts/page-runtime.ts

@@ -55,6 +55,7 @@ export function registerPageLifecycle(
     logger.debug("lifecycle registered");
 
     let active = true;
+    let pageGeneration = 0;
     const registration: RuntimeRegistration = {
         unregister: () => undefined,
     };
@@ -72,6 +73,7 @@ export function registerPageLifecycle(
     };
     const mountPage = () => {
         if (!active) return;
+        pageGeneration++;
         disposePage();
         const started = performance.now();
         logger.debug("mount started");
@@ -86,7 +88,10 @@ export function registerPageLifecycle(
         }
     };
     const handlePageLoad = () => mountPage();
-    const handleBeforeSwap = () => disposePage();
+    const handleBeforeSwap = () => {
+        pageGeneration++;
+        disposePage();
+    };
 
     target.addEventListener("astro:page-load", handlePageLoad);
     target.addEventListener("astro:before-swap", handleBeforeSwap);
@@ -94,15 +99,24 @@ export function registerPageLifecycle(
     registration.unregister = () => {
         if (!active) return;
         active = false;
-        disposePage();
-        target.removeEventListener("astro:page-load", handlePageLoad);
-        target.removeEventListener("astro:before-swap", handleBeforeSwap);
-        registry.delete(key);
+        try {
+            disposePage();
+        } finally {
+            target.removeEventListener("astro:page-load", handlePageLoad);
+            target.removeEventListener("astro:before-swap", handleBeforeSwap);
+            registry.delete(key);
+        }
     };
     registry.set(key, registration);
 
     // Late-loaded modules can miss Astro's initial page-load event.
-    if (target.readyState === "complete") queueTask(mountPage);
+    if (target.readyState === "complete") {
+        const scheduledGeneration = pageGeneration;
+        queueTask(() => {
+            // A real page-load or swap supersedes this late-module fallback.
+            if (pageGeneration === scheduledGeneration) mountPage();
+        });
+    }
 
     return registration.unregister;
 }

package/src/scripts/pagefind-api.ts

@@ -0,0 +1,63 @@
+import { sitePath } from "../utils/site-path";
+import { createClientLogger } from "./logger";
+
+export interface PagefindData {
+    url: string;
+    meta?: { title?: string };
+    plain_excerpt?: string;
+    content?: string;
+}
+
+export interface PagefindApi {
+    search: (
+        query: string | null,
+        options?: { filters?: Record<string, string> },
+    ) => Promise<{
+        results: Array<{ data: () => Promise<PagefindData> }>;
+    }>;
+}
+
+/** Share successful imports and in-flight work; a failed attempt remains retryable. */
+export function createPagefindLoader(
+    importModule: (url: string) => Promise<unknown> = (url) => import(/* @vite-ignore */ url),
+    origin: () => string = () => location.origin,
+    base = import.meta.env.BASE_URL,
+): () => Promise<PagefindApi | null> {
+    let pending: Promise<PagefindApi | null> | undefined;
+    let failedAttempts = 0;
+    const logger = createClientLogger("webmcp/pagefind");
+    return () => {
+        if (!pending) {
+            pending = (async () => {
+                try {
+                    const url = new URL(sitePath("pagefind/pagefind.js", base), origin());
+                    // Browsers can retain a failed ESM fetch; retry with a fresh module URL.
+                    if (failedAttempts)
+                        url.searchParams.set("stalux_retry", String(failedAttempts));
+                    const loaded = await importModule(url.href);
+                    const namespace = loaded as {
+                        default?: PagefindApi;
+                        search?: PagefindApi["search"];
+                    };
+                    const api = namespace.default ?? namespace;
+                    if (typeof api.search !== "function")
+                        throw new Error("Invalid Pagefind module");
+                    return api as PagefindApi;
+                } catch {
+                    failedAttempts++;
+                    logger.warn(
+                        "Pagefind index unavailable; build the static search index and retry",
+                    );
+                    return null;
+                }
+            })();
+            const attempt = pending;
+            void attempt.then((result) => {
+                if (!result && pending === attempt) pending = undefined;
+            });
+        }
+        return pending;
+    };
+}
+
+export const loadPagefind = createPagefindLoader();

package/src/scripts/view-transitions.ts

@@ -1,5 +1,6 @@
 import { getRouteKind } from "@utils/public-routes";
 import { createClientLogger } from "./logger";
+import { prepareNavigationFont } from "./navigation-font";
 
 const logger = createClientLogger("view-transitions");
 
@@ -19,6 +20,9 @@ interface NavigationEvent {
     from: URL;
     to: URL;
     direction: string;
+    loader: () => Promise<void>;
+    newDocument: Document;
+    signal: AbortSignal;
 }
 
 function setNavigationState(event: NavigationEvent): void {
@@ -35,7 +39,14 @@ if (!transitionWindow.__STALUX_VT_LISTENER__) {
     transitionWindow.__STALUX_VT_LISTENER__ = true;
 
     document.addEventListener("astro:before-preparation", (event) => {
-        setNavigationState(event as NavigationEvent);
+        const navigation = event as unknown as NavigationEvent;
+        setNavigationState(navigation);
+        const loader = navigation.loader;
+        navigation.loader = async () => {
+            await loader();
+            if (!event.defaultPrevented)
+                await prepareNavigationFont(navigation.newDocument, navigation.signal);
+        };
     });
 
     document.addEventListener("astro:after-swap", () => {