@xingwangzhe/stalux 1.46.1 → 1.46.5

package/src/scripts/runtime-counter.ts

@@ -4,7 +4,7 @@ import { observeVisibleClock } from "./visible-clock";
 registerPageLifecycle("runtime-counter", () => {
     const container = document.querySelector<HTMLElement>("[data-stalux-buildtime]");
     const counter = document.getElementById("runtime-counter");
-    if (!container || !counter) return;
+    if (!(container && counter)) return;
     const start = new Date(container.dataset.staluxBuildtime ?? "");
     const format =
         container.dataset.staluxRuntimeFormat ?? "{days}d {hours}h {minutes}m {seconds}s";

package/src/scripts/shell-hydration.ts

@@ -0,0 +1,60 @@
+/**
+ * Keep a shell's frame, refresh only the parts that describe the page.
+ *
+ * A `data-swup-persist` node is kept whole by Swup: that is what makes the
+ * sidebars, the header and the footer survive a visit. For a container whose
+ * *frame* is stable but whose *contents* belong to the page (the article's TOC,
+ * tag list and category list), keeping the node whole would show the previous
+ * article's headings. Marking it `data-stalux-shell-slot` says: keep this node,
+ * take the children from the page we are navigating to.
+ *
+ * Doing it here, synchronously after the swap and before `astro:after-swap`, means
+ * every page module that mounts later sees the refreshed lists and nothing has to
+ * be measured or re-rendered a second time.
+ */
+const SLOT = "[data-stalux-shell-slot]";
+
+/** Persist nodes that existed before this swap; only their slots need refilling. */
+const retained = new WeakSet<Element>();
+
+/** Call before the content is replaced, while the old document is still live. */
+export function markRetainedShells(): void {
+    for (const element of document.querySelectorAll("[data-swup-persist]")) retained.add(element);
+}
+
+export function hydrateShells(next: Document | undefined): number {
+    if (!next || typeof next.querySelector !== "function") return 0;
+    let hydrated = 0;
+    for (const live of document.querySelectorAll<HTMLElement>(SLOT)) {
+        const slot = live.getAttribute?.("data-stalux-shell-slot");
+        if (!slot) continue;
+        // A slot that arrived with the incoming document already holds the right
+        // children; replacing them again would dirty layout for nothing.
+        const shell = live.closest("[data-swup-persist]");
+        if (!(shell && retained.has(shell))) continue;
+        const incoming = next.querySelector<HTMLElement>(`[data-stalux-shell-slot="${slot}"]`);
+        if (!incoming) continue;
+        // Two articles often share the same tags or the same category. Writing
+        // identical children back would dirty layout for a subtree that is
+        // already correct.
+        if (live.innerHTML === incoming.innerHTML) continue;
+        // The incoming nodes belong to another document; importNode adopts them.
+        const fresh = document.importNode(incoming, true);
+        live.replaceChildren(...fresh.childNodes);
+        // These lists are new content even though their frame is old, so the
+        // unroll cue still applies to them.
+        for (const group of live.querySelectorAll<HTMLElement>("[data-stalux-reveal]"))
+            group.setAttribute("data-stalux-shell-fresh", "");
+        hydrated++;
+    }
+    // A shell that is itself new (first visit to an article, or any move between
+    // page types) brings fresh lists with it: they are content, not a kept frame.
+    for (const group of document.querySelectorAll<HTMLElement>(
+        "[data-swup-persist] [data-stalux-reveal]",
+    )) {
+        const shell = group.closest("[data-swup-persist]");
+        if (shell && !retained.has(shell) && !group.hasAttribute("data-stalux-shell-fresh"))
+            group.setAttribute("data-stalux-shell-fresh", "");
+    }
+    return hydrated;
+}

package/src/scripts/smooth-scroll.ts

@@ -12,9 +12,9 @@ export interface PageGlide {
 }
 
 /** Bound the pre-swap return-to-top so a 6000px article does not add a second. */
-const GLIDE_MIN_MS = 160;
-const GLIDE_MAX_MS = 360;
-const GLIDE_SAFETY_MS = 760;
+const GLIDE_MIN_MS = 80;
+const GLIDE_MAX_MS = 180;
+const GLIDE_SAFETY_MS = 380;
 
 /**
  * Walk the current document back to the top before the container is replaced.
@@ -42,7 +42,7 @@ export function glideToTop(): PageGlide {
 
     // Longer documents take proportionally longer, but the ceiling keeps the
     // whole cue inside the same budget as the content fade.
-    const duration = Math.min(GLIDE_MAX_MS, GLIDE_MIN_MS + startTop / 10);
+    const duration = Math.min(GLIDE_MAX_MS, GLIDE_MIN_MS + startTop / 20);
     let frame: number | undefined;
     let settled = false;
     const release = () => {

package/src/scripts/swup-internals.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Type restoration for swup members we depend on but the package omits.
+ *
+ * `Visit.abort()` exists in swup 4.10.0's source (`src/modules/Visit.ts`) and is
+ * marked `/** @internal *\/`, so it is stripped from the published
+ * `dist/types/modules/Visit.d.ts`. The router genuinely needs it: superseding a
+ * visit mid-navigation means marking the old one aborted, and no public API does
+ * that.
+ *
+ * Declaring it here is the honest alternative to casting at the call site: the
+ * compiler now checks the name and the signature everywhere, and there is exactly
+ * one place to revisit when swup changes. Callers still guard with
+ * `typeof visit.abort === "function"` so a future removal degrades to a no-op
+ * instead of throwing in the middle of a navigation.
+ *
+ * Recheck on every swup upgrade:
+ *   grep -n "@internal" node_modules/swup/src/modules/Visit.ts
+ *   grep -n "abort" node_modules/swup/dist/types/modules/Visit.d.ts
+ */
+
+export {};
+
+declare module "swup" {
+    interface Visit {
+        /**
+         * Mark this visit aborted. Internal in 4.10.0; see the note above.
+         * Not a public API: do not call it outside the router adapter.
+         */
+        abort(): void;
+    }
+}

package/src/scripts/swup-router.ts

@@ -12,6 +12,7 @@ import "./navigation-client";
 import { prepareNavigationScripts } from "./navigation-scripts";
 import { prepareRouteMotion, type RouteMotion } from "./route-motion";
 import { animateRouteOut } from "./route-out";
+import { hydrateShells, markRetainedShells } from "./shell-hydration";
 import { cancelPageScroll, glideToTop, type PageGlide, scrollPage } from "./smooth-scroll";
 
 interface NavigationContext {
@@ -35,9 +36,11 @@ type Position = { top: number; left: number; focus?: string };
 const MAIN = "main[data-stalux-route]";
 
 function abortObsoleteVisit(visit: Visit): void {
-    // Swup 4.10 ships abort() but strips @internal members from its .d.ts.
-    // Pin core to that audited version; recheck this adapter when upgrading it.
-    (visit as Visit & { abort: () => void }).abort();
+    // `abort()` is @internal in swup 4.10.0 and stripped from the published
+    // types; swup-internals.d.ts restores the declaration, so this is checked
+    // like any other member. The guard keeps a future removal from throwing in
+    // the middle of a navigation: every caller returns right after this anyway.
+    if (typeof visit.abort === "function") visit.abort();
 }
 
 function dispatchNavigation(name: string, context: NavigationContext, nextDocument?: Document) {
@@ -88,9 +91,9 @@ export function installSwupRouter(): Swup {
     window.addEventListener(
         "popstate",
         (event) => {
-            browserMotion =
-                (event as PopStateEvent & { hasUAVisualTransition?: boolean })
-                    .hasUAVisualTransition === true;
+            // hasUAVisualTransition is part of the DOM lib's PopStateEvent, so
+            // this reads the event directly; the listener is typed for popstate.
+            browserMotion = event.hasUAVisualTransition === true;
         },
         { capture: true },
     );
@@ -181,8 +184,10 @@ export function installSwupRouter(): Swup {
             left: window.scrollX,
             focus,
         });
-        if (historyPositions.size > 64)
-            historyPositions.delete(historyPositions.keys().next().value as number);
+        if (historyPositions.size > 64) {
+            const oldest = historyPositions.keys().next();
+            if (!oldest.done) historyPositions.delete(oldest.value);
+        }
         const from = new URL(visit.from.url + (visit.from.hash ?? ""), window.location.origin);
         const to = new URL(visit.to.url + (visit.to.hash ?? ""), window.location.origin);
         const navigationType = visit.history.popstate ? "traverse" : visit.history.action;
@@ -261,7 +266,7 @@ export function installSwupRouter(): Swup {
         // missing document on an aborted visit is not a failed navigation.
         if (context?.controller.signal.aborted || visit.done || visit !== swup.visit) return;
         const next = visit.to.document;
-        if (!context || !next || !replace) throw new Error("Missing Swup document");
+        if (!(context && next && replace)) throw new Error("Missing Swup document");
         if (context.controller.signal.aborted) return;
         // Two cues overlap on the outgoing document: the content stage leaving,
         // and the page walking back to the top. Persisted sidebars, the header
@@ -283,6 +288,9 @@ export function installSwupRouter(): Swup {
         html.dataset.staluxVtPreset = context.preset;
         context.motion = prepareRouteMotion(dispatchNavigation("astro:before-swap", context, next));
         if (context.controller.signal.aborted) return;
+        // Remember which shells exist now: after the swap only those slots need
+        // refilling, because only those nodes came from the previous document.
+        markRetainedShells();
         await replace(visit, args);
         // The stage node survives the swap, so the filled exit effect still holds
         // the incoming document at zero opacity. It is released inside
@@ -306,7 +314,38 @@ export function installSwupRouter(): Swup {
         }
         html.dataset.staluxRoute = getRouteKind(context.to.pathname);
         visibleHistoryIndex = Number(window.history.state?.index ?? visibleHistoryIndex);
+        // Kept shells whose contents belong to the page (the article sidebars'
+        // lists) take their children from the incoming document now, before any
+        // page module mounts, so nothing needs to re-render or re-measure later.
+        hydrateShells(next);
         dispatchNavigation("astro:after-swap", context, next);
+        // The entry cue has to own the first painted frame of the new document.
+        // content:scroll is an await and a rAF away, and running the incoming
+        // scripts can block the main thread for hundreds of milliseconds: the
+        // reader would see the finished page for one or more frames and only
+        // then watch it jump to the entry offset and slide back, which reads as
+        // the page shaking. Put the scroll at its final position and start the
+        // cue in this same synchronous block, before the scripts run, so the
+        // compositor already owns the cue while the main thread is busy. A visit
+        // with a hash or a history traversal keeps the deferred path, because its
+        // scroll is not decided yet.
+        if (
+            // A history traversal restores a position that is only known later,
+            // and a hash target is decided by the anchor.
+            !visit.history.popstate &&
+            context.navigationType !== "traverse" &&
+            !context.to.hash &&
+            context.preset !== "none" &&
+            // ScrollPlugin owns visit.scroll; a bare visit has no reset flag.
+            visit.scroll?.reset !== false
+        ) {
+            const position = scroll.getCachedScrollPositions?.(visit.to.url)?.window;
+            const top = position?.top ?? 0;
+            const left = position?.left ?? 0;
+            if (window.scrollY !== top || window.scrollX !== left)
+                window.scrollTo({ top, left, behavior: "instant" });
+            startMotion(visit);
+        }
         context.scriptsReady = context.executeScripts?.(context.controller.signal);
     });
 
@@ -392,8 +431,11 @@ export function installSwupRouter(): Swup {
         }
     });
     swup.hooks.on("cache:set", () => {
-        while (swup.cache.size > 32)
-            swup.cache.delete(swup.cache.all.keys().next().value as string);
+        while (swup.cache.size > 32) {
+            const oldest = swup.cache.all.keys().next();
+            if (oldest.done) break;
+            swup.cache.delete(oldest.value);
+        }
     });
     // Parsed DOM, not window.load: slow third-party resources cannot hold the
     // first page's interactions hostage. Page-runtime dedupes the early mount.

package/src/scripts/waline.ts

@@ -10,7 +10,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 registerPageLifecycle("waline", () => {
     const container = document.querySelector<HTMLElement>("#waline-container");
     const commentElement = document.querySelector<HTMLElement>("#waline-comment");
-    if (!container || !commentElement) return;
+    if (!(container && commentElement)) return;
 
     let decoded: unknown;
     try {

package/src/scripts/weather.ts

@@ -8,22 +8,140 @@ export interface WeatherData {
     code: number;
     updated: number;
 }
-export type WeatherState = { status: "loading" | "ready" | "error"; data?: WeatherData };
+export interface WeatherState {
+    status: "loading" | "ready" | "error";
+    data?: WeatherData;
+}
 type Listener = (state: WeatherState) => void;
+/** One provider request; the only shape callers may assume is `unknown`. */
+type GeoRequest = (url: string) => Promise<unknown>;
+
+interface ApproximateLocation {
+    city: string;
+    lat: number;
+    lon: number;
+    ip?: string;
+}
+
+interface WeatherReading {
+    temperature: number;
+    apparent: number;
+    code: number;
+}
+
+const invalidLocation = () => new Error("Invalid approximate location");
+
+/**
+ * Read one provider's answer into a location, or reject it.
+ *
+ * The two providers use different field names, so this is the only place that
+ * knows either wire format; everything downstream sees ApproximateLocation.
+ * Narrowing happens through `in` checks, so no value is ever asserted.
+ */
+function parseLocation(value: unknown): ApproximateLocation {
+    if (typeof value !== "object" || value === null) throw invalidLocation();
+    if ("error" in value && value.error) throw invalidLocation();
+    if (!("city" in value) || typeof value.city !== "string" || !value.city.trim())
+        throw invalidLocation();
+    if (!("latitude" in value) || typeof value.latitude !== "number") throw invalidLocation();
+    if (!("longitude" in value) || typeof value.longitude !== "number") throw invalidLocation();
+    const lat = value.latitude;
+    const lon = value.longitude;
+    if (
+        !(Number.isFinite(lat) && Number.isFinite(lon)) ||
+        Math.abs(lat) > 90 ||
+        Math.abs(lon) > 180
+    )
+        throw invalidLocation();
+    const usableIp =
+        "ip" in value &&
+        typeof value.ip === "string" &&
+        value.ip.length <= 45 &&
+        /^[0-9a-f:.]+$/i.test(value.ip);
+    return { city: value.city.trim(), lat, lon, ...(usableIp ? { ip: value.ip as string } : {}) };
+}
+
+/** Prefer the primary provider, fall back to the second one on any failure. */
+async function resolveLocation(get: GeoRequest): Promise<ApproximateLocation> {
+    try {
+        return parseLocation(await get("https://api.ip.sb/geoip"));
+    } catch {
+        const fallback = await get("https://ipinfo.io/json");
+        if (typeof fallback !== "object" || fallback === null) throw invalidLocation();
+        const coordinates =
+            "loc" in fallback && typeof fallback.loc === "string" ? fallback.loc.split(",") : [];
+        const pair = coordinates.length === 2 ? coordinates : undefined;
+        return parseLocation({
+            city: "city" in fallback ? fallback.city : undefined,
+            ip: "ip" in fallback ? fallback.ip : undefined,
+            latitude: pair?.[0]?.trim() ? Number(pair[0]) : undefined,
+            longitude: pair?.[1]?.trim() ? Number(pair[1]) : undefined,
+            error: "error" in fallback ? fallback.error : undefined,
+        });
+    }
+}
+
+/**
+ * Parse an untrusted value into weather data, or reject it.
+ *
+ * `in` narrowing keeps this assertion-free: the value stays `unknown` until each
+ * field is proven, and the caller receives a domain type instead of a flag.
+ */
+function parseWeatherData(value: unknown): WeatherData | undefined {
+    if (typeof value !== "object" || value === null) return undefined;
+    if (!("city" in value) || typeof value.city !== "string") return undefined;
+    const city = value.city;
+    if (city.length === 0 || city.length >= 160) return undefined;
+    let ip: string | undefined;
+    if ("ip" in value && value.ip !== undefined) {
+        if (
+            typeof value.ip !== "string" ||
+            value.ip.length > 45 ||
+            !/^[0-9a-f:.]+$/i.test(value.ip)
+        )
+            return undefined;
+        ip = value.ip;
+    }
+    if (!("temperature" in value)) return undefined;
+    if (!("apparent" in value)) return undefined;
+    if (!("code" in value)) return undefined;
+    if (!("updated" in value)) return undefined;
+    const temperature = finite(value.temperature);
+    const apparent = finite(value.apparent);
+    const code = finite(value.code);
+    const updated = finite(value.updated);
+    if (
+        temperature === undefined ||
+        apparent === undefined ||
+        code === undefined ||
+        updated === undefined
+    )
+        return undefined;
+    return { city, ...(ip === undefined ? {} : { ip }), temperature, apparent, code, updated };
+}
 
-function validData(value: unknown): value is WeatherData {
-    if (!value || typeof value !== "object") return false;
-    const data = value as WeatherData;
-    return (
-        typeof data.city === "string" &&
-        data.city.length > 0 &&
-        data.city.length < 160 &&
-        (data.ip === undefined ||
-            (typeof data.ip === "string" &&
-                data.ip.length <= 45 &&
-                /^[0-9a-f:.]+$/i.test(data.ip))) &&
-        [data.temperature, data.apparent, data.code, data.updated].every(Number.isFinite)
-    );
+const finite = (value: unknown): number | undefined =>
+    typeof value === "number" && Number.isFinite(value) ? value : undefined;
+
+/** Read the three numbers the card shows, or reject the response. */
+function parseReading(value: unknown): WeatherReading | undefined {
+    if (typeof value !== "object" || value === null) return undefined;
+    if (!("current" in value)) return undefined;
+    const current = value.current;
+    if (typeof current !== "object" || current === null) return undefined;
+    const number = (key: "temperature_2m" | "apparent_temperature" | "weather_code") => {
+        if (key === "temperature_2m" && "temperature_2m" in current)
+            return finite(current.temperature_2m);
+        if (key === "apparent_temperature" && "apparent_temperature" in current)
+            return finite(current.apparent_temperature);
+        if (key === "weather_code" && "weather_code" in current)
+            return finite(current.weather_code);
+    };
+    const temperature = number("temperature_2m");
+    const apparent = number("apparent_temperature");
+    const code = number("weather_code");
+    if (temperature === undefined || apparent === undefined || code === undefined) return undefined;
+    return { temperature, apparent, code };
 }
 
 export function createWeatherClient({
@@ -41,8 +159,8 @@ export function createWeatherClient({
     let timer: ReturnType<typeof setTimeout> | undefined;
     let generation = 0;
     try {
-        const cached: unknown = JSON.parse(storage?.getItem(CACHE_KEY) ?? "null");
-        if (validData(cached) && cached.updated <= now()) data = cached;
+        const cached = parseWeatherData(JSON.parse(storage?.getItem(CACHE_KEY) ?? "null"));
+        if (cached && cached.updated <= now()) data = cached;
     } catch {
         /* Storage is optional. */
     }
@@ -57,7 +175,7 @@ export function createWeatherClient({
         timer = undefined;
     };
     const refresh = async (force = false) => {
-        if (!listeners.size || controller) return;
+        if (listeners.size === 0 || controller) return;
         clearTimeout(timer);
         if (!force && data && now() - data.updated < WEATHER_TTL) {
             emit("ready");
@@ -71,9 +189,9 @@ export function createWeatherClient({
         timer = timeout;
         emit("loading");
         try {
-            const get = async (url: string) => {
+            const get = async (endpoint: string): Promise<unknown> => {
                 if (request.signal.aborted) throw new Error("Request cancelled");
-                const response = await fetcher(url, {
+                const response = await fetcher(endpoint, {
                     signal: request.signal,
                     credentials: "omit",
                     referrerPolicy: "no-referrer",
@@ -82,55 +200,7 @@ export function createWeatherClient({
                     throw new Error("Weather service unavailable");
                 return response.json();
             };
-            const validateLocation = (location: {
-                city?: unknown;
-                latitude?: unknown;
-                longitude?: unknown;
-                ip?: unknown;
-                error?: unknown;
-            }) => {
-                const lat = location.latitude;
-                const lon = location.longitude;
-                if (
-                    location.error ||
-                    typeof location.city !== "string" ||
-                    !location.city.trim() ||
-                    typeof lat !== "number" ||
-                    typeof lon !== "number" ||
-                    !Number.isFinite(lat) ||
-                    !Number.isFinite(lon) ||
-                    Math.abs(lat) > 90 ||
-                    Math.abs(lon) > 180
-                )
-                    throw new Error("Invalid approximate location");
-                const ip =
-                    typeof location.ip === "string" &&
-                    location.ip.length <= 45 &&
-                    /^[0-9a-f:.]+$/i.test(location.ip)
-                        ? location.ip
-                        : undefined;
-                return { city: location.city.trim(), lat, lon, ip };
-            };
-            let location: ReturnType<typeof validateLocation>;
-            try {
-                location = validateLocation(await get("https://api.ip.sb/geoip"));
-            } catch {
-                const info = await get("https://ipinfo.io/json");
-                const coordinates = typeof info.loc === "string" ? info.loc.split(",") : [];
-                location = validateLocation({
-                    city: info.city,
-                    ip: info.ip,
-                    latitude:
-                        coordinates.length === 2 && coordinates[0]?.trim()
-                            ? Number(coordinates[0])
-                            : undefined,
-                    longitude:
-                        coordinates.length === 2 && coordinates[1]?.trim()
-                            ? Number(coordinates[1])
-                            : undefined,
-                    error: info.error,
-                });
-            }
+            const location = await resolveLocation(get);
             const { lat, lon } = location;
             const url = new URL("https://api.open-meteo.com/v1/forecast");
             url.search = new URLSearchParams({
@@ -140,19 +210,15 @@ export function createWeatherClient({
                 timezone: "auto",
                 forecast_days: "1",
             }).toString();
-            const weather = await get(url.href);
-            const current = weather.current;
-            const next: WeatherData = {
-                city: location.city.trim(),
-                ip: location.ip,
-                temperature: current?.temperature_2m,
-                apparent: current?.apparent_temperature,
-                code: current?.weather_code,
+            const reading = parseReading(await get(url.href));
+            if (!reading) throw new Error("Invalid weather response");
+            if (token !== generation || request.signal.aborted) return;
+            data = {
+                city: location.city,
+                ...(location.ip === undefined ? {} : { ip: location.ip }),
+                ...reading,
                 updated: now(),
             };
-            if (!validData(next)) throw new Error("Invalid weather response");
-            if (token !== generation || request.signal.aborted) return;
-            data = next;
             try {
                 storage?.setItem(CACHE_KEY, JSON.stringify(data));
             } catch {
@@ -173,7 +239,7 @@ export function createWeatherClient({
             void refresh();
             return () => {
                 listeners.delete(listener);
-                if (!listeners.size) stop();
+                if (listeners.size === 0) stop();
             };
         },
         refresh: () => void refresh(true),
@@ -222,7 +288,7 @@ export function weatherDescription(code: number, lang: string): string {
 let client: ReturnType<typeof createWeatherClient> | undefined;
 export function mountWeather() {
     const elements = [...document.querySelectorAll<HTMLElement>("[data-stalux-weather]")];
-    if (!elements.length) return;
+    if (elements.length === 0) return;
     if (!client) {
         let storage: Storage | undefined;
         try {
@@ -238,7 +304,7 @@ export function mountWeather() {
         const locationOutput = element.querySelector<HTMLElement>("[data-weather-location]");
         const status = element.querySelector<HTMLElement>("[data-weather-status]");
         const retry = element.querySelector<HTMLButtonElement>("[data-weather-retry]");
-        if (!output || !status || !retry) return () => {};
+        if (!(output && status && retry)) return () => undefined;
         const zh = (element.dataset.lang ?? "zh-CN").startsWith("zh");
         let visible = !globalThis.IntersectionObserver;
         let unsubscribe: (() => void) | undefined;

package/src/scripts/webmcp.ts

@@ -65,9 +65,9 @@ type DocumentWithModelContext = { modelContext?: ModelContext };
 // ---------------------------------------------------------------------------
 
 const SITE_LANG =
-    (typeof document !== "undefined"
-        ? document.body?.dataset.staluxSiteLang
-        : "zh-CN"
+    (typeof document === "undefined"
+        ? "zh-CN"
+        : document.body?.dataset.staluxSiteLang
     )?.toLowerCase() ?? "zh-cn";
 
 /** 站点为英文站时为 true */
@@ -141,22 +141,26 @@ function loadPostsMeta(): Promise<PostMeta[] | null> {
         const attempt = fetchJSON(sitePath("api/posts.json"))
             .then((data) => {
                 if (
-                    !Array.isArray(data) ||
-                    !data.every(
-                        (post) =>
-                            post &&
-                            typeof post.title === "string" &&
-                            typeof post.abbrlink === "string" &&
-                            typeof post.url === "string" &&
-                            (post.desc === undefined || typeof post.desc === "string") &&
-                            (!post.categories ||
-                                (Array.isArray(post.categories) &&
-                                    post.categories.every(
-                                        (category: unknown) => typeof category === "string",
-                                    ))) &&
-                            (!post.tags ||
-                                (Array.isArray(post.tags) &&
-                                    post.tags.every((tag: unknown) => typeof tag === "string"))),
+                    !(
+                        Array.isArray(data) &&
+                        data.every(
+                            (post) =>
+                                post &&
+                                typeof post.title === "string" &&
+                                typeof post.abbrlink === "string" &&
+                                typeof post.url === "string" &&
+                                (post.desc === undefined || typeof post.desc === "string") &&
+                                (!post.categories ||
+                                    (Array.isArray(post.categories) &&
+                                        post.categories.every(
+                                            (category: unknown) => typeof category === "string",
+                                        ))) &&
+                                (!post.tags ||
+                                    (Array.isArray(post.tags) &&
+                                        post.tags.every(
+                                            (tag: unknown) => typeof tag === "string",
+                                        ))),
+                        )
                     )
                 )
                     return null;
@@ -494,7 +498,7 @@ function searchPostsTool(): WebMCPTool {
             if (!pagefind) return fallback("INDEX_UNAVAILABLE");
             try {
                 const result = await pagefind.search(keyword);
-                if (!result || !Array.isArray(result.results)) return fallback("SEARCH_FAILED");
+                if (!(result && Array.isArray(result.results))) return fallback("SEARCH_FAILED");
                 const posts: Record<string, unknown>[] = [...metadataMatches];
                 const seen = new Set(metadataMatches.map((post) => post.abbrlink));
                 for (

package/src/utils/ai-discovery.ts

@@ -413,7 +413,7 @@ export async function renderLlmsTxt(
     for (const { name, url } of mediaLinks) {
         lines.push(`- ${t("ai.socialMedia")} (${escapeMd(name)}): ${url}`);
     }
-    if (!authorName && !email && mediaLinks.length === 0) {
+    if (!(authorName || email) && mediaLinks.length === 0) {
         lines.push(`- ${t("ai.noContact")}`);
     }
     lines.push("");

package/src/utils/cc.ts

@@ -18,7 +18,7 @@ export function buildCCLink(licenseCode: string): string {
 
     const pathPart = match[1];
     const version = match[2];
-    if (!pathPart || !version) {
+    if (!(pathPart && version)) {
         return "https://creativecommons.org/licenses/by-nc-sa/4.0/";
     }
     return `https://creativecommons.org/licenses/${pathPart.toLowerCase()}/${version}/`;
@@ -45,7 +45,7 @@ export function buildCCName(licenseCode: string, t: Translator["t"]): string {
 
     const pathPart = match[1];
     const version = match[2];
-    if (!pathPart || !version) {
+    if (!(pathPart && version)) {
         const elements = ["BY", "NC", "SA"].map((code) => t(`cc.${code}`)).join("-");
         return t("cc.format", { elements, version: "4.0" });
     }