@xingwangzhe/stalux 1.51.1 → 1.52.2

package/src/internal/font-slices.ts

@@ -17,9 +17,7 @@ import { styleNames } from "./style-names.generated.ts";
  *     shared-header/footer-*.woff2 — persistent shell glyph subsets
  */
 
-import { existsSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
 import { dirname, join, resolve, sep } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
 import { FontSubsetter } from "@xingwangzhe/cjk-font-split-native";
 import type { AstroIntegrationLogger } from "astro";
 import {
@@ -75,13 +73,14 @@ export interface FontInputs {
 // ---------------------------------------------------------------------------
 
 /** Locate a font file: project root → stalux package → this package. */
-function findFont(projectRoot: string, rel: string): string | undefined {
+async function findFont(projectRoot: string, rel: string): Promise<string | undefined> {
     const candidates = [
         resolve(projectRoot, rel),
         resolve(projectRoot, "node_modules", "@xingwangzhe", "stalux", rel),
-        resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", rel),
+        resolve(dirname(Bun.fileURLToPath(import.meta.url)), "..", "..", rel),
     ];
-    return candidates.find((p) => existsSync(p));
+    for (const candidate of candidates) if (await Bun.file(candidate).exists()) return candidate;
+    return undefined;
 }
 
 // ---------------------------------------------------------------------------
@@ -102,19 +101,19 @@ export async function resolveFontInputs(
     const started = performance.now();
     logger.debug("locating font inputs");
     // 1. Locate fonts (check project root first, then stalux package dir)
-    const fontPath = findFont(projectRoot, FONT_INPUT);
+    const fontPath = await findFont(projectRoot, FONT_INPUT);
     if (!fontPath) {
         logger.warn(`Body font not found at ${FONT_INPUT}, skipping font injection`);
         return null;
     }
-    const codeNormal = findFont(projectRoot, CODE_FONT_INPUT);
+    const codeNormal = await findFont(projectRoot, CODE_FONT_INPUT);
     if (!codeNormal) {
         logger.warn(`Code font not found at ${CODE_FONT_INPUT}, skipping font injection`);
         return null;
     }
-    const codeItalic = findFont(projectRoot, CODE_FONT_ITALIC_INPUT);
+    const codeItalic = await findFont(projectRoot, CODE_FONT_ITALIC_INPUT);
 
-    const fontBuffer = readFileSync(fontPath);
+    const fontBuffer = Buffer.from(await Bun.file(fontPath).bytes());
     logger.debug(`font inputs located in ${(performance.now() - started).toFixed(1)}ms`);
     logger.info(
         `Native page-font source ready (LXGW ${(fontBuffer.length / 1024 / 1024).toFixed(1)} MB)`,
@@ -168,9 +167,9 @@ const VISUALLY_HIDDEN_CLASSES = new Set([
 ]);
 
 function cssGeneratedText(css: string): string {
-    return [...css.matchAll(/\bcontent\s*:\s*(["'])(.*?)\1\s*(?:!important\s*)?(?:;|})/gis)]
+    return [...css.matchAll(/\bcontent\s*:\s*(["'])(.*?)\1\s*(?:!important\s*)?(?:;|\})/gisu)]
         .map(([, , value]) =>
-            (value ?? "").replace(/\\([\da-f]{1,6})\s?|\\(.)/gi, (_, hex, char) =>
+            (value ?? "").replace(/\\([\da-f]{1,6})\s?|\\(.)/giu, (_, hex, char) =>
                 hex ? String.fromCodePoint(Number.parseInt(hex, 16)) : char,
             ),
         )
@@ -191,14 +190,14 @@ function collectStylesheetLinks(node: HtmlNode, output: string[]): void {
 }
 
 /** Read local CSS files linked from an emitted page and return generated text strings. */
-export function readLinkedStylesheetText(
+export async function readLinkedStylesheetText(
     html: string,
     pagePath: string,
     outputDir: string,
     cache = new Map<string, string>(),
     document = parse(html),
     dependencies?: Set<string>,
-): string {
+): Promise<string> {
     const root = resolve(outputDir);
     const links: string[] = [];
     collectStylesheetLinks(document, links);
@@ -209,7 +208,7 @@ export function readLinkedStylesheetText(
         try {
             cssPath = href.startsWith("/")
                 ? resolve(root, `.${new URL(href, "https://stalux.local").pathname}`)
-                : fileURLToPath(new URL(href, pathToFileURL(pagePath)));
+                : Bun.fileURLToPath(new URL(href, Bun.pathToFileURL(pagePath)));
         } catch {
             continue;
         }
@@ -217,7 +216,7 @@ export function readLinkedStylesheetText(
         dependencies?.add(cssPath);
         if (!cache.has(cssPath)) {
             try {
-                cache.set(cssPath, cssGeneratedText(readFileSync(cssPath, "utf8")));
+                cache.set(cssPath, cssGeneratedText(await Bun.file(cssPath).text()));
             } catch {
                 cache.set(cssPath, "");
             }
@@ -476,11 +475,11 @@ function renderPageFont(
         for (const node of style.childNodes) {
             if (node.nodeName !== "#text" || !("value" in node)) continue;
             node.value = node.value.replace(
-                /@font-face\{[^}]*font-family:"LXGW WenKai-[^"]+"[^}]*\}/g,
+                /@font-face\{[^}]*font-family:"LXGW WenKai-[^"]+"[^}]*\}/gu,
                 (face) => {
-                    const unicodeRange = face.match(/unicode-range:([^;}]+)/i)?.[1] ?? "";
+                    const unicodeRange = face.match(/unicode-range:([^;}]+)/iu)?.[1] ?? "";
                     const hasCjkRange = unicodeRange.split(",").some((range) => {
-                        const start = range.match(/U\+([\da-f]+)/i)?.[1];
+                        const start = range.match(/U\+([\da-f]+)/iu)?.[1];
                         if (!start) return false;
                         const point = Number.parseInt(start, 16);
                         return point >= 0x4e00 && point <= 0x9fff;
@@ -595,18 +594,26 @@ export async function writePageFontSubsetIntoDocumentAsync(
 }
 
 /** Remove stale page subsets so deploy artifacts only contain the current build's referenced files. */
-export function clearPageFontSubsets(
+export async function clearPageFontSubsets(
     outputDir: string,
     referencedFiles: Set<string> = new Set(),
-): void {
-    if (!existsSync(outputDir)) return;
-    for (const name of readdirSync(outputDir)) {
-        const isSubset =
-            name.startsWith("page-") ||
-            name.startsWith("shared-header-") ||
-            name.startsWith("shared-footer-");
-        if (isSubset && name.endsWith(".woff2") && !referencedFiles.has(name)) {
-            unlinkSync(join(outputDir, name));
-        }
+): Promise<void> {
+    let names: string[];
+    try {
+        names = [...new Bun.Glob("**/*.woff2").scanSync({ cwd: outputDir, onlyFiles: true })];
+    } catch {
+        return;
     }
+    await Promise.all(
+        names
+            .filter(
+                (name) =>
+                    (name.startsWith("page-") ||
+                        name.startsWith("shared-header-") ||
+                        name.startsWith("shared-footer-")) &&
+                    name.endsWith(".woff2") &&
+                    !referencedFiles.has(name),
+            )
+            .map((name) => Bun.file(join(outputDir, name)).delete()),
+    );
 }

package/src/internal/html-images.ts

@@ -81,7 +81,7 @@ export function updateImageTag(image: HtmlImage, updates: Record<string, string>
         tag = tag.slice(0, edit.start) + edit.value + tag.slice(edit.end);
     if (additions.length)
         tag = tag.replace(
-            /\s*\/?\s*>$/,
+            /\s*\/?\s*>$/u,
             (ending) => ` ${additions.join(" ")}${ending.trimStart()}`,
         );
     return tag;

package/src/internal/html-styles.ts

@@ -11,7 +11,7 @@ export function promoteCodeStyles(document: DefaultTreeAdapterMap["document"]):
             if (node.tagName === "template" || node.tagName === "noscript") return;
             if (node.tagName === "head") head = node;
             inCode ||= (
-                node.attrs.find((a) => a.name === "class")?.value.split(/\s+/) ?? []
+                node.attrs.find((a) => a.name === "class")?.value.split(/\s+/u) ?? []
             ).includes("expressive-code");
             if (
                 inCode &&

package/src/internal/image-dimensions.ts

@@ -1,4 +1,3 @@
-import { open } from "node:fs/promises";
 import path from "node:path";
 import { imageSize } from "image-size";
 import { imageSizeFromFile } from "image-size/fromFile";
@@ -56,17 +55,13 @@ async function readLocalImageDimensions(filename: string): Promise<ImageDimensio
     } catch {
         // Preserve previously supported JPEGs whose SOF is first or beyond the header window.
         // Only this compatibility path reads a whole image, never an unknown or remote format.
-        const file = await open(filename, "r").catch(() => undefined);
-        if (!file) return undefined;
         try {
-            const signature = Buffer.alloc(2);
-            await file.read(signature, 0, 2, 0);
+            const file = Bun.file(filename);
+            const signature = new Uint8Array(await file.slice(0, 2).arrayBuffer());
             if (signature[0] !== 0xff || signature[1] !== 0xd8) return undefined;
-            return readImageDimensions(await file.readFile());
+            return readImageDimensions(Buffer.from(await file.bytes()));
         } catch {
             return undefined;
-        } finally {
-            await file.close();
         }
     }
 }

package/src/internal/injected-routes.ts

@@ -1,5 +1,3 @@
-import { fileURLToPath } from "node:url";
-
 import { ROUTE_DEFINITIONS } from "../utils/route-catalog";
 
 export interface InjectedRoute {
@@ -10,6 +8,6 @@ export interface InjectedRoute {
 export function createInjectedRoutes(baseDir: URL): InjectedRoute[] {
     return ROUTE_DEFINITIONS.map(({ pattern, source }) => ({
         pattern,
-        entrypoint: fileURLToPath(new URL(source, baseDir)),
+        entrypoint: Bun.fileURLToPath(new URL(source, baseDir)),
     }));
 }

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

@@ -1,5 +1,3 @@
-import { createHash } from "node:crypto";
-import { createReadStream, promises as fs } from "node:fs";
 import path from "node:path";
 
 export interface CachedPageOutput {
@@ -7,7 +5,8 @@ export interface CachedPageOutput {
     font?: { filename: string; sourcePath: string };
 }
 
-const digest = (value: string | Buffer) => createHash("sha256").update(value).digest("hex");
+const digest = (value: string | Uint8Array) =>
+    new Bun.CryptoHasher("sha256").update(value).digest("hex");
 
 /** Content hashes include dependencies even when their public URL has not changed. */
 export async function createPageOutputCache(
@@ -17,15 +16,14 @@ export async function createPageOutputCache(
     assets: readonly string[] = [],
     contentKey = "",
 ) {
-    const hash = createHash("sha256").update("stalux-page-output-v2\0");
+    const hash = new Bun.CryptoHasher("sha256").update("stalux-page-output-v2\0");
     if (font) hash.update(font);
     if (contentKey) hash.update("\0content-key\0").update(contentKey);
     for (const dependency of [...dependencies].sort()) {
         hash.update(dependency).update("\0");
-        hash.update(await fs.readFile(dependency)).update("\0");
+        hash.update(await Bun.file(dependency).bytes()).update("\0");
     }
     const namespace = path.join(directory, hash.digest("hex"));
-    await fs.mkdir(namespace, { recursive: true });
     const knownAssets = new Set(assets);
     const assetDigests = new Map<string, Promise<string | null>>();
     const assetDigest = (asset: string): Promise<string | null> => {
@@ -34,8 +32,8 @@ export async function createPageOutputCache(
         if (!pending) {
             pending = (async () => {
                 try {
-                    const hash = createHash("sha256");
-                    for await (const chunk of createReadStream(asset)) hash.update(chunk);
+                    const hash = new Bun.CryptoHasher("sha256");
+                    for await (const chunk of Bun.file(asset).stream()) hash.update(chunk);
                     return hash.digest("hex");
                 } catch {
                     return null;
@@ -46,12 +44,12 @@ export async function createPageOutputCache(
         return pending;
     };
     const key = (entry: string, html: string) =>
-        createHash("sha256").update(entry).update("\0").update(html).digest("hex");
+        new Bun.CryptoHasher("sha256").update(entry).update("\0").update(html).digest("hex");
     return {
         async get(entry: string, html: string): Promise<CachedPageOutput | undefined> {
             try {
                 const record = JSON.parse(
-                    await fs.readFile(path.join(namespace, `${key(entry, html)}.json`), "utf8"),
+                    await Bun.file(path.join(namespace, `${key(entry, html)}.json`)).text(),
                 );
                 if (typeof record.html !== "string" || digest(record.html) !== record.digest)
                     return undefined;
@@ -63,7 +61,7 @@ export async function createPageOutputCache(
                     record.font &&
                     (!/^page-[a-f\d]+\.woff2$/u.test(record.font.filename) ||
                         typeof record.font.sourcePath !== "string" ||
-                        !(await fs.stat(record.font.sourcePath)).isFile())
+                        !(await Bun.file(record.font.sourcePath).exists()))
                 )
                     return undefined;
                 return { html: record.html, font: record.font };
@@ -79,9 +77,8 @@ export async function createPageOutputCache(
             referencedAssets: readonly string[] = [],
         ): Promise<void> {
             const target = path.join(namespace, `${key(entry, html)}.json`);
-            const temporary = `${target}.${process.pid}.tmp`;
-            await fs.writeFile(
-                temporary,
+            await Bun.write(
+                target,
                 JSON.stringify({
                     ...output,
                     digest: digest(output.html),
@@ -90,7 +87,6 @@ export async function createPageOutputCache(
                     ),
                 }),
             );
-            await fs.rename(temporary, target);
         },
     };
 }

package/src/internal/post-cover.ts

@@ -1,12 +1,3 @@
-import { createHash } from "node:crypto";
-import {
-    copyFileSync,
-    existsSync,
-    mkdirSync,
-    readdirSync,
-    readFileSync,
-    writeFileSync,
-} from "node:fs";
 import path from "node:path";
 import type { HtmlImage } from "./html-images";
 
@@ -60,8 +51,8 @@ export interface CoverContext {
     logger?: { warn: (message: string) => void };
 }
 
-const digest = (parts: readonly (string | Buffer)[]): string => {
-    const hash = createHash("sha256");
+const digest = (parts: readonly (string | Buffer | Uint8Array)[]): string => {
+    const hash = new Bun.CryptoHasher("sha256");
     for (const part of parts) hash.update(part).update("\0");
     return hash.digest("hex");
 };
@@ -96,27 +87,26 @@ export async function upgradeCoverImages(
         if (!CONVERTIBLE.test(pathname)) continue;
         const source = path.resolve(root, `.${pathname}`);
         if (!source.startsWith(`${root}${path.sep}`)) continue;
-        if (!existsSync(source)) continue;
+        if (!(await Bun.file(source).exists())) continue;
         context.dependencies?.add(source);
 
         let bytes: Buffer;
         try {
-            bytes = readFileSync(source);
+            bytes = Buffer.from(await Bun.file(source).bytes());
         } catch {
             continue;
         }
         const hash = digest([RECIPE, "webp", String(MAX_WIDTH), String(QUALITY), bytes]);
         const filename = `${hash.slice(0, 16)}.webp`;
         const cached = path.join(cacheDir, filename);
-        if (!existsSync(cached)) {
+        if (!(await Bun.file(cached).exists())) {
             try {
                 const encoded = await context
                     .sharp(bytes)
                     .resize({ width: MAX_WIDTH, withoutEnlargement: true })
                     .webp({ quality: QUALITY, effort: 5 })
                     .toBuffer();
-                mkdirSync(cacheDir, { recursive: true });
-                writeFileSync(cached, encoded);
+                await Bun.write(cached, encoded);
             } catch (error) {
                 // One malformed source must not fail the page it appears on.
                 context.logger?.warn(`封面转 WebP 失败（${pathname}）：${String(error)}`);
@@ -132,16 +122,22 @@ export async function upgradeCoverImages(
 }
 
 /** Copy every cached cover into the build output so cached pages still resolve. */
-export function restoreCoverFiles(context: { outDir: string; cacheDir: string }): number {
+export async function restoreCoverFiles(context: {
+    outDir: string;
+    cacheDir: string;
+}): Promise<number> {
     const cacheDir = path.join(context.cacheDir, RECIPE);
-    if (!existsSync(cacheDir)) return 0;
-    const target = path.join(context.outDir, COVER_DIR);
-    mkdirSync(target, { recursive: true });
-    let copied = 0;
-    for (const name of readdirSync(cacheDir)) {
-        if (!name.endsWith(".webp")) continue;
-        copyFileSync(path.join(cacheDir, name), path.join(target, name));
-        copied++;
+    let names: string[];
+    try {
+        names = [...new Bun.Glob("*.webp").scanSync({ cwd: cacheDir, onlyFiles: true })];
+    } catch {
+        return 0;
     }
-    return copied;
+    const target = path.join(context.outDir, COVER_DIR);
+    await Promise.all(
+        names.map((name) =>
+            Bun.write(path.join(target, name), Bun.file(path.join(cacheDir, name))),
+        ),
+    );
+    return names.length;
 }

package/src/internal/project-mode.ts

@@ -1,7 +1,8 @@
 import { realpathSync } from "node:fs";
-import { fileURLToPath } from "node:url";
 
 /** Linked consumers still need injected routes; only the theme's own root has file routes. */
 export function isPluginProject(projectRoot: URL, themeRoot: URL): boolean {
-    return realpathSync(fileURLToPath(projectRoot)) !== realpathSync(fileURLToPath(themeRoot));
+    return (
+        realpathSync(Bun.fileURLToPath(projectRoot)) !== realpathSync(Bun.fileURLToPath(themeRoot))
+    );
 }

package/src/internal/public-assets.ts

@@ -1,6 +1,33 @@
-import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
 import path from "node:path";
 
+/** Bun.Glob reports a missing directory as an empty scan instead of throwing here. */
+function listFiles(directory: string, patterns: readonly string[]): string[] {
+    const names = new Set<string>();
+    for (const pattern of patterns) {
+        try {
+            for (const name of new Bun.Glob(pattern).scanSync({
+                cwd: directory,
+                onlyFiles: true,
+            }))
+                names.add(name);
+        } catch {
+            // Missing source directory: nothing to sync.
+        }
+    }
+    return [...names].sort();
+}
+
+async function sameContents(left: string, right: string): Promise<boolean> {
+    const [leftBytes, rightBytes] = await Promise.all([
+        Bun.file(left).bytes(),
+        Bun.file(right).bytes(),
+    ]);
+    if (leftBytes.length !== rightBytes.length) return false;
+    for (let index = 0; index < leftBytes.length; index++)
+        if (leftBytes[index] !== rightBytes[index]) return false;
+    return true;
+}
+
 // ---------------------------------------------------------------------------
 // 背景资源判别式同步
 // ---------------------------------------------------------------------------
@@ -13,47 +40,39 @@ import path from "node:path";
  * - 用户新增的文件：保留，不删除（避免误删用户自定义背景）
  * - 不做整目录 force 复制
  */
-export function syncBackgroundSvgs(
+export async function syncBackgroundSvgs(
     srcDir: string,
     publicDir: string,
-): { copied: number; skipped: number } {
+): Promise<{ copied: number; skipped: number }> {
     const srcBg = path.join(srcDir, "../public/background");
-    if (!existsSync(srcBg)) return { copied: 0, skipped: 0 };
+    const names = listFiles(srcBg, ["*.svg", "*.webp"]);
+    if (names.length === 0) return { copied: 0, skipped: 0 };
 
     const destBg = path.join(publicDir, "background");
-    mkdirSync(destBg, { recursive: true });
-
     let copied = 0;
     let skipped = 0;
-    for (const name of readdirSync(srcBg)) {
-        if (!/\.(?:svg|webp)$/u.test(name)) continue;
+    for (const name of names) {
         const srcFile = path.join(srcBg, name);
         const destFile = path.join(destBg, name);
-        if (existsSync(destFile)) {
-            const srcBuf = readFileSync(srcFile);
-            const destBuf = readFileSync(destFile);
-            if (srcBuf.equals(destBuf)) {
-                skipped++; // 内容一致，跳过
-                continue;
-            }
+        if ((await Bun.file(destFile).exists()) && (await sameContents(srcFile, destFile))) {
+            skipped++; // 内容一致，跳过
+            continue;
         }
-        copyFileSync(srcFile, destFile);
+        await Bun.write(destFile, Bun.file(srcFile));
         copied++;
     }
     return { copied, skipped };
 }
 
 /** Sync packaged math fonts and licensing notices; Astro does not merge integration public directories. */
-export function syncFontAssets(srcDir: string, publicDir: string): void {
+export async function syncFontAssets(srcDir: string, publicDir: string): Promise<void> {
     const source = path.join(srcDir, "../public/fonts");
-    if (!existsSync(source)) return;
+    const names = listFiles(source, ["*.woff2", "*.txt"]);
     const destination = path.join(publicDir, "fonts");
-    mkdirSync(destination, { recursive: true });
-    for (const name of readdirSync(source)) {
-        if (!/\.(?:woff2|txt)$/u.test(name)) continue;
+    for (const name of names) {
         const from = path.join(source, name);
         const to = path.join(destination, name);
-        if (existsSync(to) && readFileSync(from).equals(readFileSync(to))) continue;
-        copyFileSync(from, to);
+        if ((await Bun.file(to).exists()) && (await sameContents(from, to))) continue;
+        await Bun.write(to, Bun.file(from));
     }
 }

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

@@ -1,11 +1,9 @@
-import { createHash } from "node:crypto";
-import { existsSync, readdirSync, readFileSync } from "node:fs";
 import path from "node:path";
 
 declare const __STALUX_RUNTIME_CACHE_KEY__: string;
 
 export function hashRuntimeSources(sources: ReadonlyArray<readonly [string, string]>): string {
-    const hash = createHash("sha256");
+    const hash = new Bun.CryptoHasher("sha256");
     for (const [name, contents] of [...sources].sort(([left], [right]) =>
         left.localeCompare(right),
     )) {
@@ -17,43 +15,60 @@ export function hashRuntimeSources(sources: ReadonlyArray<readonly [string, stri
     return hash.digest("hex").slice(0, 16);
 }
 
-function collectFiles(
+/** Bun.Glob keeps directory walks in the runtime instead of node:fs. */
+async 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, include);
-        if (!include(entry.name)) return [];
-        return [[path.relative(root, target), readFileSync(target, "utf8")] as const];
-    });
+): Promise<Array<readonly [string, string]>> {
+    let names: string[];
+    try {
+        names = [...new Bun.Glob("**/*").scanSync({ cwd: directory, onlyFiles: true })];
+    } catch {
+        return [];
+    }
+    return Promise.all(
+        names
+            .filter((name) => include(path.basename(name)))
+            .map(async (name): Promise<readonly [string, string]> => {
+                const target = path.join(directory, name);
+                return [
+                    path.relative(root, target).replaceAll(path.sep, "/"),
+                    await Bun.file(target).text(),
+                ];
+            }),
+    );
 }
 
-export function createRuntimeCacheKey(
+export async function createRuntimeCacheKey(
     scriptsDirectory: string,
     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))
-                  .map((name): readonly [string, string] => [
+): Promise<string> {
+    const styleNames = stylesDirectory
+        ? [...new Bun.Glob("generated*.css").scanSync({ cwd: stylesDirectory })]
+              .filter((name) => /^generated(?:-[a-z]+)?\.css$/u.test(name))
+              .map(
+                  async (name): Promise<readonly [string, string]> => [
                       `styles/${name}`,
-                      readFileSync(path.join(stylesDirectory, name), "utf8"),
-                  ])
+                      await Bun.file(path.join(stylesDirectory, name)).text(),
+                  ],
+              )
+        : [];
+    return hashRuntimeSources([
+        ...(await collectFiles(scriptsDirectory)),
+        ...(configDirectory
+            ? (
+                  await collectFiles(configDirectory, configDirectory, (name) =>
+                      /\.ya?ml$/iu.test(name),
+                  )
+              ).map(([name, contents]) => [`config/${name}`, contents] as const)
             : []),
+        ...(await Promise.all(styleNames)),
         ...(styleMapping ? [["style-names", styleMapping] as const] : []),
-        ["package.json", readFileSync(packageJson, "utf8")],
+        ["package.json", await Bun.file(packageJson).text()],
     ]);
 }
 

package/src/internal/satteri-config.ts

@@ -23,13 +23,13 @@ function pluginName(plugin: unknown): string | undefined {
     return undefined;
 }
 
-export function appendUniquePlugin<T>(list: T[], plugin: T, seen: Set<string>): void {
+export function appendUniquePlugin<T>(list: T[], plugin: unknown, seen: Set<string>): void {
     const name = pluginName(plugin);
     if (name) {
         if (seen.has(name)) return;
         seen.add(name);
     }
-    list.push(plugin);
+    list.push(plugin as T);
 }
 
 export function prepareSatteriProcessor(processor: unknown): SatteriProcessorOptions | undefined {

package/src/internal/search-style.ts

@@ -1,5 +1,3 @@
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
 import type { Plugin } from "vite";
 
 const publicId = "virtual:stalux-search-style";
@@ -7,9 +5,10 @@ const virtualId = `\0${publicId}`;
 
 /** Astro dev treats a direct CSS ?url import as a module script; keep it a URL-only leaf. */
 export function searchStylePlugin(development: boolean, base: string): Plugin {
-    const stylesheet = createRequire(import.meta.url)
-        .resolve("@pagefind/component-ui/css")
-        .replaceAll("\\", "/");
+    const stylesheet = Bun.resolveSync(
+        "@pagefind/component-ui/css",
+        Bun.fileURLToPath(new URL(".", import.meta.url)),
+    ).replaceAll("\\", "/");
     let building = false;
     return {
         name: "stalux:search-style",
@@ -20,7 +19,7 @@ export function searchStylePlugin(development: boolean, base: string): Plugin {
             if (building && this.environment.name === "client")
                 this.emitFile({
                     type: "chunk",
-                    id: fileURLToPath(
+                    id: Bun.fileURLToPath(
                         new URL("../scripts/search-engine-entry.ts", import.meta.url),
                     ),
                     fileName: "pagefind-enhanced/pagefind.js",
@@ -39,7 +38,7 @@ export function searchStylePlugin(development: boolean, base: string): Plugin {
         },
         load(id) {
             if (id !== virtualId) return;
-            return `export default ${JSON.stringify(`${base.replace(/\/$/, "")}/@fs${stylesheet}`)};`;
+            return `export default ${JSON.stringify(`${base.replace(/\/$/u, "")}/@fs${stylesheet}`)};`;
         },
     };
 }