refactor: trim PR debloat and fix transformers build

Extract shared helpers for home notices, timetable subtitles, and theme images; dedupe global search, Select, and build scripts while preserving behaviour.

Add @huggingface/transformers as a direct dependency and resolve ORT WASM paths via require.resolve so pnpm postinstall and Vite can bundle vector search.

Co-authored-by: Cursor <cursoragent@cursor.com>

lib/inlineWorker.ts

@@ -1,71 +1,32 @@
-// vite-plugin-inline-worker-dev.ts
-// vite-plugin-inline-worker-dev.ts
 import { Plugin } from "vite";
-import fs from "fs/promises";
 import { build } from "esbuild";
 
-/**
- * Creates a Vite plugin designed for bundling and inlining web worker scripts during development.
- * This plugin specifically targets module imports that include a `?inlineWorker` query parameter.
- * When such an import is encountered, the plugin bundles the worker script using `esbuild`
- * and then generates JavaScript code that inlines this bundled worker as a Blob,
- * creating the worker instance via `URL.createObjectURL()`.
- * The name "vite:inline-worker-dev" suggests it's primarily intended for development builds.
- *
- * @returns {Plugin} A Vite plugin object with `name` and `load` properties.
- */
+/** Bundle worker entry points imported with `?inlineWorker` as Blob-backed Workers in dev. */
 export default function InlineWorkerDevPlugin(): Plugin {
   return {
-    /**
-     * The unique name of this Vite plugin.
-     * @type {string}
-     */
     name: "vite:inline-worker-dev",
-    /**
-     * The Vite hook responsible for loading and transforming modules.
-     * This function intercepts modules imported with `?inlineWorker`.
-     * For such modules, it bundles the worker script and returns JavaScript code
-     * that, when executed, will create an instance of this worker from an inlined Blob.
-     *
-     * @async
-     * @param {string} id The path or ID of the module Vite is attempting to load,
-     *                    potentially including query parameters (e.g., "/path/to/worker.ts?inlineWorker").
-     * @returns {Promise<string | null>} A promise that resolves to:
-     *                                   - `null` if the module ID does not include `?inlineWorker`.
-     *                                   - A string of JavaScript code if the module is an inline worker.
-     *                                     This code will define a default export function (e.g., `InlineWorker`)
-     *                                     that, when called, creates and returns a new `Worker` instance
-     *                                     from the bundled and inlined worker script.
-     */
     async load(id) {
-      if (id.includes("?inlineWorker")) {
-        const [cleanPath] = id.split("?");
-        // Note: Original code had `await fs.readFile(cleanPath, "utf-8");` but `code` wasn't used.
-        // `esbuild` directly takes `cleanPath` as an entry point.
-        const result = await build({
-          entryPoints: [cleanPath],
-          bundle: true,
-          write: false,
-          platform: "browser",
-          format: "iife",
-          target: "esnext",
-          external: ["webextension-polyfill"],
-        });
+      if (!id.includes("?inlineWorker")) return null;
 
-        const workerCode = result.outputFiles[0].text;
+      const [cleanPath] = id.split("?");
+      const result = await build({
+        entryPoints: [cleanPath],
+        bundle: true,
+        write: false,
+        platform: "browser",
+        format: "iife",
+        target: "esnext",
+        external: ["webextension-polyfill"],
+      });
 
-        // Construct JavaScript code that will create the worker from a Blob.
-        // This code is what gets returned to Vite and replaces the original import.
-        const workerBlobCode = `
-          const code = ${JSON.stringify(workerCode)};
-          export default function InlineWorker() {
-            const blob = new Blob([code], { type: 'application/javascript' });
-            return new Worker(URL.createObjectURL(blob), { type: 'module' });
-          }
-        `;
-        return workerBlobCode;
-      }
-      return null; // Let Vite handle other modules normally
+      const workerCode = result.outputFiles[0].text;
+      return `
+        const code = ${JSON.stringify(workerCode)};
+        export default function InlineWorker() {
+          const blob = new Blob([code], { type: 'application/javascript' });
+          return new Worker(URL.createObjectURL(blob), { type: 'module' });
+        }
+      `;
     },
   };
 }