rwsdk 0.1.26 → 0.2.0-alpha.0

package/dist/lib/smokeTests/templates/SmokeTestClient.template.js

@@ -3,6 +3,7 @@ export function getSmokeTestClientTemplate() {
 
 import React, { useState } from "react";
 import { smokeTestAction } from "./__smokeTestFunctions";
+import clientStyles from "./smokeTestClientStyles.module.css";
 
 interface SmokeTestStatus {
   status: string;
@@ -80,8 +81,22 @@ export const SmokeTestClient: React.FC = () => {
         {loading ? "Checking..." : "Run Smoke Test"}
       </button>
 
+      {/* Client Stylesheet Marker */}
+      <div
+        className="smoke-test-url-styles"
+        data-testid="smoke-test-url-styles"
+      >
+        <p>A red box should appear above this text (from URL import)</p>
+      </div>
+      <div
+        className={clientStyles.smokeTestClientStyles}
+        data-testid="smoke-test-client-styles"
+      >
+        <p>A blue box should appear above this text (from CSS module)</p>
+      </div>
+
       {/* HMR Testing Marker - Do not modify this comment */}
-      <div 
+      <div
         id="client-hmr-marker"
         data-testid="client-hmr-marker"
         data-hmr-text="original"
@@ -146,7 +161,7 @@ export const SmokeTestClient: React.FC = () => {
         </div>
       )}
 
-      <div 
+      <div
         id="smoke-test-client-timestamp"
         data-client-timestamp={lastCheck?.timestamp ?? ""}
         data-status={lastCheck?.status ?? ""}

package/dist/lib/smokeTests/templates/smokeTestClientStyles.module.css.template.d.ts

@@ -0,0 +1 @@
+export declare const template = "\n.smokeTestClientStyles {\n  /* This is a comment to test HMR */\n  background-color: rgb(0, 0, 255);\n  width: 100px;\n  height: 100px;\n}\n";

package/dist/lib/smokeTests/templates/smokeTestClientStyles.module.css.template.js

@@ -0,0 +1,9 @@
+/* eslint-disable quotes */
+export const template = `
+.smokeTestClientStyles {
+  /* This is a comment to test HMR */
+  background-color: rgb(0, 0, 255);
+  width: 100px;
+  height: 100px;
+}
+`;

package/dist/lib/smokeTests/templates/smokeTestUrlStyles.css.template.d.ts

@@ -0,0 +1 @@
+export declare const template = "\n.smoke-test-url-styles {\n  /* This is a comment to test HMR */\n  background-color: rgb(255, 0, 0);\n  width: 100px;\n  height: 100px;\n}\n";

package/dist/lib/smokeTests/templates/smokeTestUrlStyles.css.template.js

@@ -0,0 +1,9 @@
+/* eslint-disable quotes */
+export const template = `
+.smoke-test-url-styles {
+  /* This is a comment to test HMR */
+  background-color: rgb(255, 0, 0);
+  width: 100px;
+  height: 100px;
+}
+`;

package/dist/lib/smokeTests/types.d.mts

@@ -23,6 +23,7 @@ export interface SmokeTestOptions {
     copyProject?: boolean;
     realtime?: boolean;
     skipHmr?: boolean;
+    skipStyleTests?: boolean;
 }
 export interface TestResources {
     tempDirCleanup?: () => Promise<void>;

package/dist/runtime/clientNavigation.d.ts

@@ -1,6 +1,9 @@
+export interface ClientNavigationOptions {
+    onNavigate?: () => void;
+    scrollToTop?: boolean;
+    scrollBehavior?: "auto" | "smooth" | "instant";
+}
 export declare function validateClickEvent(event: MouseEvent, target: HTMLElement): boolean;
-export declare function initClientNavigation(opts?: {
-    onNavigate: () => void;
-}): {
+export declare function initClientNavigation(opts?: ClientNavigationOptions): {
     handleResponse: (response: Response) => boolean;
 };

package/dist/runtime/clientNavigation.js

@@ -27,12 +27,70 @@ export function validateClickEvent(event, target) {
     }
     return true;
 }
-export function initClientNavigation(opts = {
-    onNavigate: async function onNavigate() {
-        // @ts-expect-error
-        await globalThis.__rsc_callServer();
-    },
-}) {
+export function initClientNavigation(opts = {}) {
+    // Merge user options with defaults
+    const options = {
+        onNavigate: async function onNavigate() {
+            // @ts-expect-error
+            await globalThis.__rsc_callServer();
+        },
+        scrollToTop: true,
+        scrollBehavior: 'instant',
+        ...opts,
+    };
+    // Prevent browser's automatic scroll restoration for popstate
+    if ('scrollRestoration' in history) {
+        history.scrollRestoration = 'manual';
+    }
+    // Set up scroll behavior management
+    let popStateWasCalled = false;
+    let savedScrollPosition = null;
+    const observer = new MutationObserver(() => {
+        if (popStateWasCalled && savedScrollPosition) {
+            // Restore scroll position for popstate navigation (always instant)
+            window.scrollTo({
+                top: savedScrollPosition.y,
+                left: savedScrollPosition.x,
+                behavior: 'instant',
+            });
+            savedScrollPosition = null;
+        }
+        else if (options.scrollToTop && !popStateWasCalled) {
+            // Scroll to top for anchor click navigation (configurable)
+            window.scrollTo({
+                top: 0,
+                left: 0,
+                behavior: options.scrollBehavior,
+            });
+            // Update the current history entry with the new scroll position (top)
+            // This ensures that if we navigate back and then forward again,
+            // we return to the top position, not some previous scroll position
+            window.history.replaceState({
+                ...window.history.state,
+                scrollX: 0,
+                scrollY: 0
+            }, "", window.location.href);
+        }
+        popStateWasCalled = false;
+    });
+    const handleScrollPopState = (event) => {
+        popStateWasCalled = true;
+        // Save the scroll position that the browser would have restored to
+        const state = event.state;
+        if (state && typeof state === 'object' && 'scrollX' in state && 'scrollY' in state) {
+            savedScrollPosition = { x: state.scrollX, y: state.scrollY };
+        }
+        else {
+            // Fallback: try to get scroll position from browser's session history
+            // This is a best effort since we can't directly access the browser's stored position
+            savedScrollPosition = { x: window.scrollX, y: window.scrollY };
+        }
+    };
+    const main = document.querySelector("main") || document.body;
+    if (main) {
+        window.addEventListener("popstate", handleScrollPopState);
+        observer.observe(main, { childList: true, subtree: true });
+    }
     // Intercept all anchor tag clicks
     document.addEventListener("click", async function handleClickEvent(event) {
         // Prevent default navigation
@@ -43,12 +101,18 @@ export function initClientNavigation(opts = {
         const el = event.target;
         const a = el.closest("a");
         const href = a?.getAttribute("href");
+        // Save current scroll position before navigating
+        window.history.replaceState({
+            path: window.location.pathname,
+            scrollX: window.scrollX,
+            scrollY: window.scrollY
+        }, "", window.location.href);
         window.history.pushState({ path: href }, "", window.location.origin + href);
-        await opts.onNavigate();
+        await options.onNavigate();
     }, true);
     // Handle browser back/forward buttons
     window.addEventListener("popstate", async function handlePopState() {
-        await opts.onNavigate();
+        await options.onNavigate();
     });
     // Return a handleResponse function for use with initClient
     return {

package/dist/runtime/entries/types/client.d.ts

@@ -1 +1,6 @@
 import "./shared";
+export interface ClientNavigationOptions {
+    onNavigate?: () => void;
+    scrollToTop?: boolean;
+    scrollBehavior?: "auto" | "smooth" | "instant";
+}

package/dist/runtime/lib/manifest.d.ts

@@ -0,0 +1,2 @@
+import { type RequestInfo } from "../requestInfo/types";
+export declare const getManifest: (requestInfo: RequestInfo) => Promise<Record<string, any>>;

package/dist/runtime/lib/manifest.js

@@ -0,0 +1,17 @@
+let manifest;
+export const getManifest = async (requestInfo) => {
+    if (manifest) {
+        return manifest;
+    }
+    if (import.meta.env.VITE_IS_DEV_SERVER) {
+        const url = new URL(requestInfo.request.url);
+        url.searchParams.set("scripts", JSON.stringify(Array.from(requestInfo.rw.scriptsToBeLoaded)));
+        url.pathname = "/__rwsdk_manifest";
+        manifest = await fetch(url.toString()).then((res) => res.json());
+    }
+    else {
+        const { default: prodManifest } = await import("virtual:rwsdk:manifest.js");
+        manifest = prodManifest;
+    }
+    return manifest;
+};

package/dist/runtime/lib/router.d.ts

@@ -15,6 +15,7 @@ export type RwContext = {
     ssr: boolean;
     layouts?: React.FC<LayoutProps<any>>[];
     databases: Map<string, Kysely<any>>;
+    scriptsToBeLoaded: Set<string>;
 };
 export type RouteMiddleware<T extends RequestInfo = RequestInfo> = (requestInfo: T) => Response | Promise<Response> | void | Promise<void> | Promise<Response | void>;
 type RouteFunction<T extends RequestInfo = RequestInfo> = (requestInfo: T) => Response | Promise<Response>;

package/dist/runtime/register/worker.js

@@ -1,5 +1,6 @@
 import { registerServerReference as baseRegisterServerReference, registerClientReference as baseRegisterClientReference, decodeReply, } from "react-server-dom-webpack/server.edge";
 import { getServerModuleExport } from "../imports/worker.js";
+import { requestInfo } from "../requestInfo/worker.js";
 export function registerServerReference(action, id, name) {
     if (typeof action !== "function") {
         return action;
@@ -12,11 +13,22 @@ export function registerClientReference(id, exportName, value) {
         ? value
         : () => null;
     const reference = baseRegisterClientReference({}, id, exportName);
-    return Object.defineProperties(wrappedValue, {
-        ...Object.getOwnPropertyDescriptors(reference),
-        $$async: { value: true },
-        $$isClientReference: { value: true },
-    });
+    const finalDescriptors = Object.getOwnPropertyDescriptors(reference);
+    const idDescriptor = finalDescriptors.$$id;
+    if (idDescriptor && idDescriptor.hasOwnProperty("value")) {
+        const originalValue = idDescriptor.value;
+        finalDescriptors.$$id = {
+            configurable: idDescriptor.configurable,
+            enumerable: idDescriptor.enumerable,
+            get() {
+                requestInfo.rw.scriptsToBeLoaded.add(id);
+                return originalValue;
+            },
+        };
+    }
+    finalDescriptors.$$async = { value: true };
+    finalDescriptors.$$isClientReference = { value: true };
+    return Object.defineProperties(wrappedValue, finalDescriptors);
 }
 export async function __smokeTestActionHandler(timestamp) {
     await new Promise((resolve) => setTimeout(resolve, 0));

package/dist/runtime/render/renderRscThenableToHtmlStream.d.ts

@@ -1,9 +1,9 @@
-import { type DocumentProps } from "../lib/router";
-import { type RequestInfo } from "../requestInfo/types";
+import { type DocumentProps } from "../lib/router.js";
+import { type RequestInfo } from "../requestInfo/types.js";
 export declare const renderRscThenableToHtmlStream: ({ thenable, Document, requestInfo, shouldSSR, onError, }: {
     thenable: any;
     Document: React.FC<DocumentProps>;
     requestInfo: RequestInfo;
     shouldSSR: boolean;
     onError: (error: unknown) => void;
-}) => Promise<import("react-dom/server").ReactDOMServerReadableStream>;
+}) => Promise<import("react-dom/server.js").ReactDOMServerReadableStream>;

package/dist/runtime/render/renderRscThenableToHtmlStream.js

@@ -1,9 +1,13 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { use } from "react";
 import { renderToReadableStream } from "react-dom/server.edge";
+import { Stylesheets } from "./stylesheets.js";
 export const renderRscThenableToHtmlStream = async ({ thenable, Document, requestInfo, shouldSSR, onError, }) => {
     const Component = () => {
-        const node = use(thenable).node;
+        const RscApp = () => {
+            const node = use(thenable).node;
+            return (_jsxs(_Fragment, { children: [_jsx(Stylesheets, { requestInfo: requestInfo }), _jsx("div", { id: "hydrate-root", children: node })] }));
+        };
         // todo(justinvdm, 18 Jun 2025): We can build on this later to allow users
         // surface context. e.g:
         // * we assign `user: requestInfo.clientCtx` here
@@ -17,7 +21,7 @@ export const renderRscThenableToHtmlStream = async ({ thenable, Document, reques
         };
         return (_jsxs(Document, { ...requestInfo, children: [_jsx("script", { nonce: requestInfo.rw.nonce, dangerouslySetInnerHTML: {
                         __html: `globalThis.__RWSDK_CONTEXT = ${JSON.stringify(clientContext)}`,
-                    } }), _jsx("div", { id: "hydrate-root", children: node })] }));
+                    } }), _jsx(RscApp, {})] }));
     };
     return await renderToReadableStream(_jsx(Component, {}), {
         nonce: requestInfo.rw.nonce,

package/dist/runtime/render/stylesheets.d.ts

@@ -0,0 +1,9 @@
+import { type RequestInfo } from "../requestInfo/types.js";
+export type CssEntry = {
+    url: string;
+    content: string;
+    absolutePath: string;
+};
+export declare const Stylesheets: ({ requestInfo }: {
+    requestInfo: RequestInfo;
+}) => import("react/jsx-runtime.js").JSX.Element;

package/dist/runtime/render/stylesheets.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { use } from "react";
+import { getManifest } from "../lib/manifest.js";
+const findCssForModule = (scriptId, manifest) => {
+    const css = new Set();
+    const visited = new Set();
+    const inner = (id) => {
+        if (visited.has(id)) {
+            return;
+        }
+        visited.add(id);
+        const entry = manifest[id];
+        if (!entry) {
+            return;
+        }
+        if (entry.css) {
+            for (const href of entry.css) {
+                css.add(href);
+            }
+        }
+    };
+    inner(scriptId);
+    return Array.from(css);
+};
+export const Stylesheets = ({ requestInfo }) => {
+    const manifest = use(getManifest(requestInfo));
+    const allStylesheets = new Set();
+    for (const scriptId of requestInfo.rw.scriptsToBeLoaded) {
+        const css = findCssForModule(scriptId, manifest);
+        for (const entry of css) {
+            allStylesheets.add(entry);
+        }
+    }
+    return (_jsx(_Fragment, { children: Array.from(allStylesheets).map((entry) => {
+            if (typeof entry === "string") {
+                return (_jsx("link", { rel: "stylesheet", href: entry, precedence: "first" }, entry));
+            }
+            if (import.meta.env.VITE_IS_DEV_SERVER) {
+                return (_jsx("style", { "data-vite-dev-id": entry.absolutePath, dangerouslySetInnerHTML: { __html: entry.content } }, entry.url));
+            }
+            else {
+                return (_jsx("link", { rel: "stylesheet", href: entry.url, precedence: "first" }, entry.url));
+            }
+        }) }));
+};

package/dist/runtime/worker.js

@@ -41,6 +41,7 @@ export const defineApp = (routes) => {
                     rscPayload: true,
                     ssr: true,
                     databases: new Map(),
+                    scriptsToBeLoaded: new Set(),
                 };
                 const outerRequestInfo = {
                     request,

package/dist/scripts/debug-sync.mjs

@@ -24,6 +24,93 @@ const getPackageManagerInfo = (targetDir) => {
     }
     return pnpmResult;
 };
+/**
+ * @summary Workaround for pnpm's local tarball dependency resolution.
+ *
+ * @description
+ * When installing a new version of the SDK from a local tarball (e.g., during
+ * development with `rwsync`), pnpm creates a new, uniquely-named directory in
+ * the `.pnpm` store (e.g., `rwsdk@file+...`).
+ *
+ * A challenge arises when other packages list `rwsdk` as a peer dependency.
+ * pnpm may not consistently update the symlinks for these peer dependencies
+ * to point to the newest `rwsdk` instance. This can result in a state where
+ * multiple versions of `rwsdk` coexist in `node_modules`, with some parts of
+ * the application using a stale version.
+ *
+ * This function addresses the issue by:
+ * 1. Identifying the most recently installed `rwsdk` instance in the `.pnpm`
+ *    store after a `pnpm install` run.
+ * 2. Forcefully updating the top-level `node_modules/rwsdk` symlink to point
+ *    to this new instance.
+ * 3. Traversing all other `rwsdk`-related directories in the `.pnpm` store
+ *    and updating their internal `rwsdk` symlinks to also point to the correct
+ *    new instance.
+ *
+ * I am sorry for this ugly hack, I am sure there is a better way, and that it is me
+ * doing something wrong. The aim is not to go down this rabbit hole right now
+ * -- @justinvdm
+ */
+const hackyPnpmSymlinkFix = async (targetDir) => {
+    console.log("💣 Performing pnpm symlink fix...");
+    const pnpmDir = path.join(targetDir, "node_modules", ".pnpm");
+    if (!existsSync(pnpmDir)) {
+        console.log("   🤔 No .pnpm directory found.");
+        return;
+    }
+    try {
+        const entries = await fs.readdir(pnpmDir);
+        // Find ALL rwsdk directories, not just file-based ones, to handle
+        // all kinds of stale peer dependencies.
+        const rwsdkDirs = entries.filter((e) => e.startsWith("rwsdk@"));
+        console.log("   Found rwsdk directories:", rwsdkDirs);
+        if (rwsdkDirs.length === 0) {
+            console.log("   🤔 No rwsdk directories found to hack.");
+            return;
+        }
+        let latestDir = "";
+        let latestMtime = new Date(0);
+        for (const dir of rwsdkDirs) {
+            const fullPath = path.join(pnpmDir, dir);
+            const stats = await fs.stat(fullPath);
+            if (stats.mtime > latestMtime) {
+                latestMtime = stats.mtime;
+                latestDir = dir;
+            }
+        }
+        console.log("   Latest rwsdk directory:", latestDir);
+        if (!latestDir) {
+            console.log("   🤔 Could not determine the latest rwsdk directory.");
+            return;
+        }
+        const goldenSourcePath = path.join(pnpmDir, latestDir, "node_modules", "rwsdk");
+        if (!existsSync(goldenSourcePath)) {
+            console.error(`   ❌ Golden source path does not exist: ${goldenSourcePath}`);
+            return;
+        }
+        console.log(`   🎯 Golden rwsdk path is: ${goldenSourcePath}`);
+        // 1. Fix top-level symlink
+        const topLevelSymlink = path.join(targetDir, "node_modules", "rwsdk");
+        await fs.rm(topLevelSymlink, { recursive: true, force: true });
+        await fs.symlink(goldenSourcePath, topLevelSymlink, "dir");
+        console.log(`   ✅ Symlinked ${topLevelSymlink} -> ${goldenSourcePath}`);
+        // 2. Fix peer dependency symlinks
+        const allPnpmDirs = await fs.readdir(pnpmDir);
+        for (const dir of allPnpmDirs) {
+            if (dir === latestDir || !dir.includes("rwsdk"))
+                continue;
+            const peerSymlink = path.join(pnpmDir, dir, "node_modules", "rwsdk");
+            if (existsSync(peerSymlink)) {
+                await fs.rm(peerSymlink, { recursive: true, force: true });
+                await fs.symlink(goldenSourcePath, peerSymlink, "dir");
+                console.log(`   ✅ Hijacked symlink in ${dir}`);
+            }
+        }
+    }
+    catch (error) {
+        console.error("   ❌ Failed during hacky pnpm symlink fix:", error);
+    }
+};
 const performFullSync = async (sdkDir, targetDir, cacheBust = false) => {
     const sdkPackageJsonPath = path.join(sdkDir, "package.json");
     let originalSdkPackageJson = null;
@@ -58,25 +145,47 @@ const performFullSync = async (sdkDir, targetDir, cacheBust = false) => {
             .readFile(lockfilePath, "utf-8")
             .catch(() => null);
         try {
-            const cmd = pm.name;
-            const args = [pm.command];
-            if (pm.name === "yarn") {
-                args.push(`file:${tarballPath}`);
+            if (pm.name === "pnpm") {
+                console.log("🛠️  Using pnpm overrides to install SDK...");
+                if (originalPackageJson) {
+                    const targetPackageJson = JSON.parse(originalPackageJson);
+                    targetPackageJson.pnpm = targetPackageJson.pnpm || {};
+                    targetPackageJson.pnpm.overrides =
+                        targetPackageJson.pnpm.overrides || {};
+                    targetPackageJson.pnpm.overrides.rwsdk = `file:${tarballPath}`;
+                    await fs.writeFile(packageJsonPath, JSON.stringify(targetPackageJson, null, 2));
+                }
+                // We use install here, which respects the overrides.
+                // We also don't want to fail if the lockfile is out of date.
+                await $("pnpm", ["install", "--no-frozen-lockfile"], {
+                    cwd: targetDir,
+                    stdio: "inherit",
+                });
+                if (process.env.RWSDK_PNPM_SYMLINK_FIX) {
+                    await hackyPnpmSymlinkFix(targetDir);
+                }
             }
             else {
-                args.push(tarballPath);
+                const cmd = pm.name;
+                const args = [pm.command];
+                if (pm.name === "yarn") {
+                    args.push(`file:${tarballPath}`);
+                }
+                else {
+                    args.push(tarballPath);
+                }
+                await $(cmd, args, {
+                    cwd: targetDir,
+                    stdio: "inherit",
+                });
             }
-            await $(cmd, args, {
-                cwd: targetDir,
-                stdio: "inherit",
-            });
         }
         finally {
             if (originalPackageJson) {
                 console.log("Restoring package.json...");
                 await fs.writeFile(packageJsonPath, originalPackageJson);
             }
-            if (originalLockfile) {
+            if (originalLockfile && pm.name !== "pnpm") {
                 console.log(`Restoring ${pm.lockFile}...`);
                 await fs.writeFile(lockfilePath, originalLockfile);
             }
@@ -131,7 +240,9 @@ const performSync = async (sdkDir, targetDir) => {
     }
     if (packageJsonChanged) {
         console.log("📦 package.json changed, performing full sync...");
-        await performFullSync(sdkDir, targetDir);
+        // We always cache-bust on a full sync now to ensure pnpm's overrides
+        // see a new version and the hacky symlink fix runs on a clean slate.
+        await performFullSync(sdkDir, targetDir, true);
     }
     else {
         await performFastSync(sdkDir, targetDir);
@@ -150,7 +261,8 @@ export const debugSync = async (opts) => {
         return;
     }
     // --- Watch Mode Logic ---
-    const lockfilePath = path.join(targetDir, "node_modules", ".rwsync.lock");
+    // Use global lock based on SDK directory since all instances sync from the same source
+    const lockfilePath = path.join(sdkDir, ".rwsync.lock");
     let release;
     // Ensure the directory for the lockfile exists
     await fs.mkdir(path.dirname(lockfilePath), { recursive: true });
@@ -161,7 +273,7 @@ export const debugSync = async (opts) => {
     }
     catch (e) {
         if (e.code === "ELOCKED") {
-            console.error(`❌ Another rwsync process is already watching ${targetDir}.`);
+            console.error(`❌ Another rwsync process is already running for this SDK.`);
             console.error(`   If this is not correct, please remove the lockfile at ${lockfilePath}`);
             process.exit(1);
         }

package/dist/scripts/ensure-deploy-env.mjs

@@ -15,9 +15,9 @@ const promptForDeployment = async () => {
     });
     return new Promise((resolve) => {
         // Handle Ctrl+C (SIGINT)
-        rl.on('SIGINT', () => {
+        rl.on("SIGINT", () => {
             rl.close();
-            console.log('\nDeployment cancelled.');
+            console.log("\nDeployment cancelled.");
             process.exit(1);
         });
         rl.question("Do you want to proceed with deployment? (y/N): ", (answer) => {

package/dist/scripts/smoke-test.mjs

@@ -30,6 +30,8 @@ if (fileURLToPath(import.meta.url) === process.argv[1]) {
         copyProject: false, // Default to false - don't copy project to artifacts
         realtime: false, // Default to false - don't just test realtime
         skipHmr: false, // Default to false - run HMR tests
+        // todo(justinvdm, 2025-07-31): Remove this once style tests working with headless
+        skipStyleTests: true, // Default to true - skip style tests
         // sync: will be set below
     };
     // Log if we're in CI
@@ -53,6 +55,9 @@ if (fileURLToPath(import.meta.url) === process.argv[1]) {
         else if (arg === "--skip-hmr") {
             options.skipHmr = true;
         }
+        else if (arg === "--run-style-tests") {
+            options.skipStyleTests = false;
+        }
         else if (arg === "--keep") {
             options.keep = true;
         }
@@ -89,6 +94,7 @@ Options:
   --skip-release          Skip testing the release/production deployment
   --skip-client           Skip client-side tests, only run server-side checks
   --skip-hmr              Skip hot module replacement (HMR) tests
+  --run-style-tests       Enable stylesheet-related tests (disabled by default)
   --path=PATH             Project directory to test
   --artifact-dir=DIR      Directory to store test artifacts (default: .artifacts)
   --keep                  Keep temporary test directory after tests complete

package/dist/vite/manifestPlugin.d.mts

@@ -0,0 +1,4 @@
+import { type Plugin } from "vite";
+export declare const manifestPlugin: ({ manifestPath, }: {
+    manifestPath: string;
+}) => Plugin;