quicklook-kit 0.6.0 → 0.7.0

package/README.markdown

@@ -4,17 +4,17 @@
 [![Version](https://img.shields.io/npm/v/quicklook-kit?style=for-the-badge)](https://www.npmjs.org/package/quicklook-kit)
 [![Build](https://img.shields.io/github/actions/workflow/status/idleberg/quicklook-kit/ci.yml?style=for-the-badge)](https://github.com/idleberg/quicklook-kit/actions)
 
-> Build macOS Quick Look previews with any Vite-based web framework, no Swift required
+> Build Quick Look previews for macOS and Windows with Vite-based web frameworks, no Swift or C# required
 
-Your preview is a web page. quicklook-kit builds it with your framework, wraps it in a small native Quick Look extension and installs the resulting app. You never touch Swift or Xcode.
+Your preview is a web page. quicklook-kit builds it with your framework and wraps it in a small native host: a Quick Look extension on macOS, a [QuickLook](https://github.com/QL-Win/QuickLook) plugin on Windows. You never touch Swift, C# or Xcode.
 
 Built-in support for SvelteKit, Astro, SolidStart, Nuxt and Analog. Any other framework that builds with Vite and writes a static `index.html` works through an integration.
 
 ## Requirements
 
-- macOS 14 or later, with [Xcode](https://apps.apple.com/app/xcode/id497799835) installed
-- [XcodeGen](https://github.com/yonaskolb/XcodeGen)
 - [Node.js](https://nodejs.org) 22.17 or later, which runs the `quicklook` CLI
+- For macOS: macOS 14 or later, with [Xcode](https://apps.apple.com/app/xcode/id497799835) and [XcodeGen](https://github.com/yonaskolb/XcodeGen) installed
+- For Windows: the [.NET SDK](https://dotnet.microsoft.com/download), on any OS. Testing the plugin needs Windows with [QuickLook](https://github.com/QL-Win/QuickLook) and the Microsoft Edge WebView2 Runtime, which ships with Windows 11
 
 ## Installation
 
@@ -31,23 +31,31 @@ To start from scratch, run `pnpm create quicklook` instead.
 Create `quicklook.config.ts` in your project root:
 
 ```ts
-import { defineConfig } from "quicklook-kit";
+import { defineConfig } from 'quicklook-kit';
 
 export default defineConfig({
-  name: "Quick Look Example",
-  bundleId: "com.example.QuickLookExample",
-  types: [
-    {
-      id: "com.example.QuickLookExample.example",
-      description: "Example File",
-      extensions: ["example"],
-      conformsTo: ["public.plain-text"],
-    },
-  ],
-  framework: "sveltekit",
+	name: 'Quick Look Example',
+	macos: {
+		bundleId: 'com.example.QuickLookExample',
+		types: [
+			{
+				id: 'com.example.QuickLookExample.example',
+				description: 'Example File',
+				extensions: ['example'],
+				conformsTo: ['public.plain-text'],
+			},
+		],
+	},
+	windows: {
+		id: 'QuickLook.Plugin.Example',
+		extensions: ['example'],
+	},
+	framework: 'sveltekit',
 });
 ```
 
+Each platform group is optional, but you need at least one: leave out `windows` to build for macOS only, or `macos` for Windows only.
+
 A new type conforms to `public.plain-text` for text formats, or `public.data` for binary ones. To preview a type macOS already knows about, use a plain string like `'public.json'` in place of an object.
 
 The config can also be `quicklook.config.js`, `.json`, `.yaml` or `.toml`, or a `.quicklookrc`. The keys are the same in every format.
@@ -55,16 +63,33 @@ The config can also be `quicklook.config.js`, `.json`, `.yaml` or `.toml`, or a
 | Key            | Default      |                                                                                    |
 | -------------- | ------------ | ---------------------------------------------------------------------------------- |
 | `name`         | required     | App name, shown in Finder and System Settings                                      |
-| `bundleId`     | required     | The extension gets `<bundleId>.Extension`                                          |
-| `types`        | required     | File types to preview                                                              |
+| `macos`        | none         | macOS options, see below                                                           |
+| `windows`      | none         | Windows options, see below                                                         |
 | `framework`    | required     | `'sveltekit'`, `'astro'`, `'solid-start'`, `'nuxt'`, `'analog'`, or an integration |
-| `icon`         | none         | Path to an `.icns` file for the app                                                |
-| `macOS`        | `'14.0'`     | Minimum macOS version                                                              |
 | `integrations` | `[]`         | See [Integrations](#integrations)                                                  |
 | `csp`          | locked down  | Directives here replace the defaults of the same name                              |
 | `maxFileSize`  | `10_000_000` | Larger files get Quick Look's generic preview                                      |
 | `public`       | `{}`         | Values the page can read at build time                                             |
 | `settings`     | `{}`         | Settings the user edits in the app, see [Settings](#settings)                      |
+| `devFile`      | none         | A file the dev server previews until you drop another, relative to the project     |
+
+Under `macos`:
+
+| Key              | Default  |                                           |
+| ---------------- | -------- | ----------------------------------------- |
+| `bundleId`       | required | The extension gets `<bundleId>.Extension` |
+| `types`          | required | File types to preview                     |
+| `icon`           | none     | Path to an `.icns` file for the app       |
+| `minimumVersion` | `'14.0'` | Minimum macOS version                     |
+
+Under `windows`:
+
+| Key          | Default  |                                                                                    |
+| ------------ | -------- | ---------------------------------------------------------------------------------- |
+| `id`         | required | Plugin name, starting with `QuickLook.Plugin.`, e.g. `QuickLook.Plugin.Example`    |
+| `extensions` | required | File extensions to preview, without the dot. They win over QuickLook's own viewers |
+
+Upgrading from a version without platform groups? The old top-level `bundleId`, `icon`, `macOS` and `types` now live under `macos`, with `macOS` renamed to `minimumVersion`.
 
 A framework can take options as a `[name, options]` pair, e.g. `['sveltekit', { outDir: 'dist' }]` when your adapter writes somewhere other than the default.
 
@@ -81,7 +106,7 @@ Each framework needs a static, client-side build:
 ### 2. Add the Vite plugin
 
 ```ts
-import { quicklook } from "quicklook-kit/vite";
+import { quicklook } from 'quicklook-kit/vite';
 
 // in the framework's Vite config
 plugins: [quicklook()];
@@ -98,9 +123,9 @@ or in `tsconfig.json` under `compilerOptions.types` as `"quicklook-kit/virtual"`
 ### 3. Read the file
 
 ```ts
-import { browserFile, config, nativeFile } from "virtual:quicklook";
+import { browserFile, config, nativeFile } from 'virtual:quicklook';
 
-const file = nativeFile(); // the previewed file inside Quick Look, undefined in the browser
+const file = nativeFile(); // the previewed file, undefined in the browser
 config.public; // values from quicklook.config.*
 ```
 
@@ -112,48 +137,57 @@ config.public; // values from quicklook.config.*
 
 Decode `bytes` however your format needs: `new TextDecoder().decode(file.bytes)` for text, or a parser for binary formats.
 
-In the dev server, `nativeFile()` returns `undefined`. Pass a dropped or picked `File` to `browserFile()` to get the same shape.
+In the dev server, `nativeFile()` returns `devFile` if you set one, and `undefined` otherwise. Pass a dropped or picked `File` to `browserFile()` to get the same shape.
 
 ### 4. Add scripts
 
 ```json
 {
-  "scripts": {
-    "dev": "quicklook dev",
-    "build": "quicklook build",
-    "register": "quicklook build && quicklook register",
-    "unregister": "quicklook unregister"
-  }
+	"scripts": {
+		"dev": "quicklook dev",
+		"build": "quicklook build",
+		"register": "quicklook build && quicklook register",
+		"unregister": "quicklook unregister"
+	}
 }
 ```
 
 ## CLI
 
-| Command                | Description                                                         |
-| ---------------------- | ------------------------------------------------------------------- |
-| `quicklook dev`        | Starts the framework's dev server                                   |
-| `quicklook build:web`  | Builds the page only, into `.quicklook/web`                         |
-| `quicklook build`      | Builds the app with its extension into `.quicklook/build`           |
-| `quicklook register`   | Copies the built app to `/Applications` and registers the extension |
-| `quicklook unregister` | Removes the app from `/Applications`                                |
+| Command                | Description                                                                   |
+| ---------------------- | ----------------------------------------------------------------------------- |
+| `quicklook dev`        | Starts the framework's dev server                                             |
+| `quicklook build:web`  | Builds the page only, into `.quicklook/web`                                   |
+| `quicklook build`      | Builds every configured platform into `.quicklook/build/<platform>`           |
+| `quicklook register`   | Installs the build on the current OS: the app on macOS, the plugin on Windows |
+| `quicklook unregister` | Removes it again                                                              |
 
-After `register`, select a file in Finder and press Space. Run `build` and `register` again after every change.
+`build` takes `--platform macos` or `--platform windows` to build just one. The Windows plugin builds on any OS; the macOS app only on a Mac, so elsewhere `build` skips it. Run `build` and `register` again after every change.
 
-If the preview doesn't show up, check `pluginkit -mAv | grep <your bundleId>`, and make sure no other app claims the same file type.
+On macOS, `register` copies the app to `/Applications` and registers its extension. Select a file in Finder and press Space. If the preview doesn't show up, check `pluginkit -mAv | grep <your macos.bundleId>`, and make sure no other app claims the same file type.
+
+On Windows, `register` copies the plugin to `%APPDATA%\pooi.moe\QuickLook\QuickLook.Plugin\<windows.id>`. Quit and restart QuickLook, then select a file in Explorer and press Space.
 
 Add `.quicklook` to your `.gitignore`.
 
 ## Things to know
 
-- **Nothing can be loaded from the network.** The extension serves your build from inside the app with a strict Content Security Policy. Import images, fonts and CSS normally and they get bundled. The dev server only reports violations in the console, without blocking them.
+- **Nothing can be loaded from the network.** The native host serves your build from disk with a strict Content Security Policy, on both platforms. Import images, fonts and CSS normally and they get bundled. The dev server only reports violations in the console, without blocking them.
 - **Inline scripts are allowed by hash.** Frameworks that bootstrap with inline `<script>` tags keep working; the hashes are added to the CSP at build time.
-- **Test in Safari.** It uses the same WebKit engine as Quick Look's WKWebView.
+- **Test in Safari and Edge.** macOS previews run in WebKit, like Safari; Windows previews in WebView2, like Edge.
 - **The light/dark theme follows the system.** Use `prefers-color-scheme` in CSS.
-- **The app is signed ad hoc.** Other people have to allow it in System Settings → Privacy & Security on first launch. Distributing it without that step requires an Apple Developer account and notarization.
+- **The macOS app is signed ad hoc.** Other people have to allow it in System Settings → Privacy & Security on first launch. Distributing it without that step requires an Apple Developer account and notarization.
+- **Windows users install the `.qlplugin`** from `.quicklook/build/windows` by previewing it in QuickLook and clicking the install button.
+
+## Releasing
+
+Projects made with `create quicklook` include a release workflow. Push a tag like `v1.0.0` and it builds every configured platform and attaches `<App>-v1.0.0-macos.zip` and `<App>-v1.0.0-windows.qlplugin` to a GitHub release.
+
+If you publish a Homebrew cask, its URL needs the `-macos` suffix once you move to a release with platform groups.
 
 ## Settings
 
-`settings` declares options the user can change in the app. Each entry's `type` picks the control the app shows:
+`settings` declares options the user can change. On macOS, the app shows a control for each entry, picked by its `type`:
 
 ```ts
 settings: {
@@ -185,37 +219,47 @@ Every entry except `object` needs a `default`. `title` defaults to the key in wo
 The page reads the values, nested like the schema, with `settings()`:
 
 ```ts
-import { settings } from "virtual:quicklook";
+import { settings } from 'virtual:quicklook';
 
 const { wrap, editor } = settings();
 ```
 
 In the dev server, `settings()` returns the defaults.
 
+Windows has no settings window. Users set values in `%APPDATA%\pooi.moe\QuickLook\<windows.id>.config`, with nested keys joined by dots, and restart QuickLook. Values that don't fit the schema fall back to the default.
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<Settings>
+  <theme>dark</theme>
+  <editor.tabSize>4</editor.tabSize>
+</Settings>
+```
+
 ## Integrations
 
 An integration is an object with a `name` and any of these hooks. They run in order: the framework first, then each entry in `integrations`.
 
 ```ts
-import type { Integration } from "quicklook-kit";
+import type { Integration } from 'quicklook-kit';
 
 export default (options: { key: string }): Integration => ({
-  name: "my-integration",
-  hooks: {
-    // Adjust the resolved config.
-    "config:resolved"(config) {},
-
-    // Post-process the framework's static output before it's bundled.
-    async "build:done"({ outDir, config }) {},
-
-    // Edit the generated XcodeGen spec: Info.plist keys, entitlements, targets.
-    "xcode:spec"(spec, config) {
-      spec.targets.QuickLookExampleExtension.info.properties.MyKey = options.key;
-    },
-
-    // Add Vite plugins wherever quicklook() is used.
-    vite: () => [],
-  },
+	name: 'my-integration',
+	hooks: {
+		// Adjust the resolved config.
+		'config:resolved'(config) {},
+
+		// Post-process the framework's static output before it's bundled.
+		async 'build:done'({ outDir, config }) {},
+
+		// Edit the generated XcodeGen spec: Info.plist keys, entitlements, targets. macOS only.
+		'xcode:spec'(spec, config) {
+			spec.targets.QuickLookExampleExtension.info.properties.MyKey = options.key;
+		},
+
+		// Add Vite plugins wherever quicklook() is used.
+		vite: () => [],
+	},
 });
 ```
 
@@ -223,7 +267,7 @@ Add it as an object, or by name so JSON and YAML configs can use it too. A name
 
 ```jsonc
 {
-  "integrations": ["quicklook-some-package", ["./my-integration.ts", { "key": "value" }]],
+	"integrations": ["quicklook-some-package", ["./my-integration.ts", { "key": "value" }]]
 }
 ```
 

package/dist/cli.mjs

@@ -1,23 +1,110 @@
 #!/usr/bin/env node
-import { a as serializeCsp, i as loadConfig, t as addSources } from "./config-BVPHnCWr.mjs";
+import { a as serializeCsp, i as loadConfig, t as addSources } from "./config-qdxXRvMf.mjs";
 import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
-import { cp, glob, readFile, rm, writeFile } from "node:fs/promises";
+import { cp, glob, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { basename, delimiter, dirname, join, resolve } from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
-//#region src/cli.ts
+import { parseArgs } from "node:util";
+// src/windows.ts
+const xmlEscapes = {
+	"&": "&",
+	"<": "&lt;",
+	">": "&gt;"
+};
+const xmlSpecial = /[&<>]/g;
+function xml(text) {
+	return text.replace(xmlSpecial, (char) => xmlEscapes[char] ?? char);
+}
+/** The settings schema as a flat list keyed like QL-Win's settings file, `editor.fontSize`. */
+function flatSettings(settings, prefix = "") {
+	return Object.entries(settings).flatMap(([name, setting]) => {
+		const key = prefix + name;
+		if (setting.type === "object") return flatSettings(setting.properties, `${key}.`);
+		const { type, default: fallback } = setting;
+		const { enum: options, minimum, maximum } = setting;
+		return [{
+			key,
+			type,
+			default: fallback,
+			...options && { enum: options.map((option) => typeof option === "object" && option ? option.value : option) },
+			...minimum !== void 0 && { minimum },
+			...maximum !== void 0 && { maximum }
+		}];
+	});
+}
+/** The plugin project's generated files, by name. The CLI adds the host source and `web/`. */
+function windowsProject(config, version) {
+	const { id, extensions } = config.windows;
+	return {
+		[`${id}.csproj`]: `<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net462</TargetFramework>
+    <AssemblyName>${id}</AssemblyName>
+    <RootNamespace>${id}</RootNamespace>
+    <Version>${xml(version)}</Version>
+    <LangVersion>latest</LangVersion>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <!-- Lets a non-Windows SDK compile against .NET Framework, WPF included, without UseWPF -->
+    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" PrivateAssets="all" />
+    <!-- QL-Win loads QuickLook.Common itself, so compile against it but don't ship it -->
+    <PackageReference Include="QuickLook.Common" Version="4.5.0" ExcludeAssets="runtime" />
+    <!-- Same version as QL-Win's built-in viewers -->
+    <PackageReference Include="Microsoft.Web.WebView2" Version="1.0.4078.44" />
+    <Reference Include="PresentationCore" />
+    <Reference Include="PresentationFramework" />
+    <Reference Include="WindowsBase" />
+    <Reference Include="System.Xaml" />
+    <Reference Include="System.Web" />
+    <Reference Include="System.Web.Extensions" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="QuickLook.Plugin.Metadata.config" CopyToOutputDirectory="PreserveNewest" />
+    <None Include="quicklook.json" CopyToOutputDirectory="PreserveNewest" />
+    <None Include="web/**" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+</Project>
+`,
+		"QuickLook.Plugin.Metadata.config": `<?xml version="1.0" encoding="utf-8"?>
+<Metadata>
+  <Namespace>${id}</Namespace>
+  <Version>${xml(version)}</Version>
+  <Description>${xml(config.name)}</Description>
+</Metadata>
+`,
+		"quicklook.json": JSON.stringify({
+			id,
+			extensions: extensions.map((extension) => extension.toLowerCase()),
+			maxFileSize: config.maxFileSize,
+			csp: serializeCsp(config.csp),
+			settings: flatSettings(config.settings)
+		})
+	};
+}
+// src/cli.ts
+const platforms = ["macos", "windows"];
+const { positionals: [subcommand], values: { platform } } = parseArgs({
+	allowPositionals: true,
+	options: { platform: { type: "string" } }
+});
+if (platform !== void 0 && !platforms.includes(platform)) throw new Error(`--platform: expected "macos" or "windows", got "${platform}"`);
 const config = await loadConfig();
-const { root, name, bundleId, macOS, types, framework, icon } = config;
+const { root, name, framework } = config;
 const target = name.replace(/[^A-Za-z0-9]/g, "");
 const work = `${root}/.quicklook`;
 const web = `${work}/web`;
-const built = `${work}/build/${name}.app`;
+const built = `${work}/build/macos/${name}.app`;
 const installed = `/Applications/${name}.app`;
+const version = process.env.VERSION?.replace(/^v/, "") ?? "1.0";
+const onWindows = process.platform === "win32";
 const native = fileURLToPath(new URL("../native", import.meta.url));
 const lsregister = "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister";
-const leadingV = /^v/;
 const inlineScript = /<script\b(?![^>]*\ssrc=)[^>]*>([\s\S]*?)<\/script>/gi;
 /**
 * The settings schema as nested arrays, each entry with its own `key`: Swift's
@@ -34,10 +121,11 @@ function settingsSchema(settings) {
 	});
 }
 /** Runs a command, exiting with its status if it fails unless `nothrow` is set. */
-function exec([file = "", ...args], { quiet = false, nothrow = false, env = process.env } = {}) {
+function exec([file = "", ...args], { quiet = false, nothrow = false, env = process.env, cwd = root, shell = false } = {}) {
 	const { status, error } = spawnSync(file, args, {
-		cwd: root,
+		cwd,
 		env,
+		shell,
 		stdio: quiet ? "ignore" : "inherit"
 	});
 	if (error) throw error;
@@ -51,12 +139,15 @@ function binPath() {
 		if (dir === dirname(dir)) return [...dirs, process.env.PATH].join(delimiter);
 	}
 }
-/** Runs a framework command with the project's own binaries. */
+/** Runs a framework command with the project's own binaries, which are `.cmd` shims on Windows. */
 function run(command) {
-	exec(command, { env: {
-		...process.env,
-		PATH: binPath()
-	} });
+	exec(onWindows ? [command.join(" ")] : command, {
+		env: {
+			...process.env,
+			PATH: binPath()
+		},
+		shell: onWindows
+	});
 }
 /** Frameworks bootstrap with inline scripts; the CSP allows exactly those, by hash. */
 async function inlineScriptHashes() {
@@ -81,17 +172,35 @@ async function buildWeb() {
 	});
 	await cp(outDir, web, { recursive: true });
 }
+function group(key) {
+	const options = config[key];
+	if (!options) throw new Error(`quicklook.config has no "${key}" group, so there is nothing to build for it.`);
+	return options;
+}
+/** Builds every configured platform, or just `--platform`. */
 async function build() {
+	const targets = platform ? [platform] : platforms.filter((p) => config[p]);
+	targets.forEach(group);
+	if (targets.includes("macos") && process.platform !== "darwin") {
+		if (platform) throw new Error("Building for macOS needs a Mac.");
+		console.log("Skipping macOS, which only builds on a Mac.");
+		targets.splice(targets.indexOf("macos"), 1);
+	}
 	await buildWeb();
 	const csp = addSources(config.csp, "script-src", ...await inlineScriptHashes());
+	if (targets.includes("macos")) await buildMacos(csp);
+	if (targets.includes("windows")) await buildWindows(csp);
+}
+async function buildMacos(csp) {
+	const { bundleId, minimumVersion, types, icon } = group("macos");
 	const hasSettings = Object.keys(config.settings).length > 0;
 	const qlSettings = hasSettings && { QLSettings: JSON.stringify(settingsSchema(config.settings)) };
 	const spec = {
 		name: target,
-		options: { deploymentTarget: { macOS } },
+		options: { deploymentTarget: { macOS: minimumVersion } },
 		settings: { base: {
 			SWIFT_VERSION: "6.0",
-			MARKETING_VERSION: process.env.VERSION?.replace(leadingV, "") ?? "1.0",
+			MARKETING_VERSION: version,
 			CURRENT_PROJECT_VERSION: "1",
 			CODE_SIGN_STYLE: "Manual",
 			CODE_SIGN_IDENTITY: "-"
@@ -122,7 +231,7 @@ async function build() {
 					properties: {
 						CFBundleName: name,
 						...icon && { CFBundleIconFile: basename(icon, ".icns") },
-						LSMinimumSystemVersion: macOS,
+						LSMinimumSystemVersion: minimumVersion,
 						...qlSettings,
 						UTExportedTypeDeclarations: types.filter((type) => typeof type !== "string").map((type) => ({
 							UTTypeIdentifier: type.id,
@@ -198,13 +307,82 @@ async function build() {
 		"Release",
 		"-destination",
 		"generic/platform=macOS",
-		`CONFIGURATION_BUILD_DIR=${work}/build`,
+		`CONFIGURATION_BUILD_DIR=${dirname(built)}`,
 		"build"
 	]);
 	exec(["touch", built]);
 	console.log(`Built ${built}`);
 }
-switch (process.argv[2]) {
+/** The plugin folder `register` copies, and the `.qlplugin` users install. */
+function windowsBuild() {
+	const { id } = group("windows");
+	return {
+		plugin: `${work}/build/windows/${id}`,
+		archive: `${work}/build/windows/${name}.qlplugin`
+	};
+}
+async function buildWindows(csp) {
+	const windows = group("windows");
+	const { plugin, archive } = windowsBuild();
+	const project = `${work}/windows`;
+	await rm(`${project}/web`, {
+		recursive: true,
+		force: true
+	});
+	await cp(web, `${project}/web`, { recursive: true });
+	await cp(`${native}/Windows/Plugin.cs`, `${project}/Plugin.cs`);
+	for (const [file, content] of Object.entries(windowsProject({
+		...config,
+		csp,
+		windows
+	}, version))) await writeFile(`${project}/${file}`, content);
+	await rm(plugin, {
+		recursive: true,
+		force: true
+	});
+	exec([
+		"dotnet",
+		"build",
+		`${project}/${windows.id}.csproj`,
+		"--configuration",
+		"Release",
+		"--output",
+		plugin,
+		"--nologo",
+		"--verbosity",
+		"quiet"
+	]);
+	const tar = onWindows ? join(process.env.SystemRoot ?? "C:\\Windows", "System32\\tar.exe") : "tar";
+	await rm(archive, { force: true });
+	exec([
+		tar,
+		"--create",
+		"--format",
+		"zip",
+		"--file",
+		archive,
+		"--exclude",
+		"*.pdb",
+		...await readdir(plugin)
+	], { cwd: plugin });
+	console.log(`Built ${archive}`);
+}
+/** QL-Win's folder for plugins installed by the user. */
+const qlWinPlugins = join(process.env.APPDATA ?? "", "pooi.moe/QuickLook/QuickLook.Plugin");
+/** Removes an installed plugin, whose DLL is locked while QuickLook runs. */
+async function removePlugin(folder) {
+	try {
+		await rm(folder, {
+			recursive: true,
+			force: true
+		});
+	} catch (error) {
+		const { code } = error;
+		if (code === "EBUSY" || code === "EPERM") throw new Error(`Quit QuickLook first, it has ${folder} in use.`, { cause: error });
+		throw error;
+	}
+}
+switch (subcommand) {
 	case "dev":
 		run(framework.build.dev);
 		break;
@@ -215,6 +393,15 @@ switch (process.argv[2]) {
 		await build();
 		break;
 	case "register":
+		if (onWindows) {
+			const { plugin } = windowsBuild();
+			if (!existsSync(plugin)) throw new Error(`No build at ${plugin}, run 'quicklook build' first.`);
+			const folder = join(qlWinPlugins, group("windows").id);
+			await removePlugin(folder);
+			await cp(plugin, folder, { recursive: true });
+			console.log(`Installed ${folder}\nQuit and restart QuickLook to load it.`);
+			break;
+		}
 		if (!existsSync(built)) throw new Error(`No build at ${built}, run 'quicklook build' first.`);
 		await rm(installed, {
 			recursive: true,
@@ -249,9 +436,15 @@ switch (process.argv[2]) {
 			"-g",
 			installed
 		]);
-		console.log(`Installed ${installed}\nVerify with: pluginkit -mAv | grep ${bundleId}`);
+		console.log(`Installed ${installed}\nVerify with: pluginkit -mAv | grep ${group("macos").bundleId}`);
 		break;
 	case "unregister":
+		if (onWindows) {
+			const folder = join(qlWinPlugins, group("windows").id);
+			await removePlugin(folder);
+			console.log(`Removed ${folder}\nQuit and restart QuickLook to unload it.`);
+			break;
+		}
 		exec([
 			lsregister,
 			"-u",
@@ -270,7 +463,6 @@ switch (process.argv[2]) {
 		});
 		console.log(`Removed ${installed}`);
 		break;
-	default: throw new Error("Usage: quicklook dev|build:web|build|register|unregister");
+	default: throw new Error("Usage: quicklook dev|build:web|build|register|unregister [--platform macos|windows]");
 }
-//#endregion
 export {};

package/dist/{config-BVPHnCWr.mjs → config-qdxXRvMf.mjs}

@@ -2,7 +2,7 @@ import { join } from "node:path";
 import process from "node:process";
 import { loadConfig } from "c12";
 import { createJiti } from "jiti";
-//#region src/settings.ts
+// src/settings.ts
 /** The fields each setting type allows, besides `type`, `title`, `description` and `order`. */
 const settingFields = {
 	boolean: ["default"],
@@ -80,6 +80,7 @@ const fieldChecks = [
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+const settingKey = /^[A-Za-z_][\w-]*$/;
 /**
 * Throws on anything in a `settings` schema the app can't show, naming the key
 * path, e.g. `settings.editor.tabSize: default 0 is below minimum 1`.
@@ -88,7 +89,7 @@ function validateSettings(settings, path = "settings") {
 	if (!isRecord(settings)) throw new Error(`${path}: expected an object of settings`);
 	for (const [key, entry] of Object.entries(settings)) {
 		const at = `${path}.${key}`;
-		if (key.includes(".")) throw new Error(`${at}: keys can't contain "."`);
+		if (!settingKey.test(key)) throw new Error(`${at}: keys need a letter or _ first, then letters, digits, _ or -`);
 		if (!isRecord(entry)) throw new Error(`${at}: expected an object with a type`);
 		const problem = settingProblem(entry);
 		if (problem) throw new Error(`${at}: ${problem}`);
@@ -135,8 +136,7 @@ function enumProblem(options, value, type) {
 	}
 	return values.includes(value) ? void 0 : `default ${JSON.stringify(value)} isn't in the enum`;
 }
-//#endregion
-//#region src/config.ts
+// src/config.ts
 /** The previewed file is untrusted input; nothing on the page needs the network. */
 const defaultCsp = {
 	"default-src": ["'none'"],
@@ -213,24 +213,47 @@ async function resolveIntegration(ref, root) {
 	const exported = await createJiti(join(root, "quicklook.config")).import(name, { default: true });
 	return typeof exported === "function" ? exported(options) : exported;
 }
+/** Top-level fields from before the platform groups, and where they went. */
+const movedFields = {
+	bundleId: "macos.bundleId",
+	icon: "macos.icon",
+	macOS: "macos.minimumVersion",
+	types: "macos.types, Windows uses windows.extensions"
+};
+const windowsId = /^QuickLook\.Plugin\.[A-Za-z0-9_.]+$/;
+function validatePlatforms(config) {
+	const moved = Object.keys(movedFields).filter((field) => field in config).map((field) => `${field}: moved to ${movedFields[field]}`);
+	if (moved.length > 0) throw new Error(moved.join("\n"));
+	if (!(config.macos || config.windows)) throw new Error("quicklook.config: add a \"macos\" or \"windows\" group for each platform to build for");
+	if (!config.windows) return;
+	const { id, extensions } = config.windows;
+	if (typeof id !== "string" || !windowsId.test(id)) throw new Error(`windows.id: expected "QuickLook.Plugin." followed by a name, got ${JSON.stringify(id)}`);
+	if (!Array.isArray(extensions) || extensions.length === 0) throw new Error("windows.extensions: expected at least one extension");
+	const dotted = extensions.find((extension) => extension.startsWith("."));
+	if (dotted) throw new Error(`windows.extensions: write "${dotted.slice(1)}" without the dot`);
+}
 async function loadConfig$1(root = process.cwd()) {
 	const { config } = await loadConfig({
 		name: "quicklook",
 		cwd: root
 	});
 	if (!config?.name) throw new Error(`No quicklook.config.* with a name found in ${root}`);
+	validatePlatforms(config);
 	validateSettings(config.settings ?? {});
-	const { framework: frameworkRef, integrations: refs = [], ...rest } = config;
+	const { framework: frameworkRef, integrations: refs = [], macos, ...rest } = config;
 	const framework = await resolveIntegration(frameworkRef, root);
 	if (!framework.build) throw new Error(`Framework "${framework.name}" doesn't say how to build the page`);
 	const integrations = [framework];
 	for (const ref of refs) integrations.push(await resolveIntegration(ref, root));
 	const resolved = {
-		macOS: "14.0",
 		maxFileSize: 1e7,
 		public: {},
 		settings: {},
 		...rest,
+		...macos && { macos: {
+			minimumVersion: "14.0",
+			...macos
+		} },
 		csp: {
 			...defaultCsp,
 			...config.csp
@@ -245,5 +268,4 @@ async function loadConfig$1(root = process.cwd()) {
 	for (const integration of integrations) await integration.hooks?.["config:resolved"]?.(resolved);
 	return resolved;
 }
-//#endregion
 export { serializeCsp as a, loadConfig$1 as i, defaultCsp as n, defineConfig as r, addSources as t };

package/dist/config.d.mts

@@ -1,5 +1,4 @@
 import { Plugin } from "vite";
-//#region src/config.d.ts
 /** An existing type id such as "public.json", or a new type the app declares. */
 export type FileType = string | DeclaredType;
 /** A file type the app declares itself, as a UTExportedTypeDeclaration. */
@@ -76,15 +75,27 @@ export interface Integration {
  * either an integration or a function that takes the options and returns one.
  */
 export type IntegrationRef = Integration | string | [name: string, options?: unknown];
-export interface QuickLookConfig {
-  /** App name, shown in Finder and System Settings. */
-  name: string;
+/** Builds a Quick Look extension for macOS. */
+export interface MacosConfig {
   bundleId: string;
   /** Path to the app's .icns icon, relative to the project root. */
   icon?: string;
-  /** Minimum macOS version. Defaults to 14.0. */
-  macOS?: string;
+  /** Defaults to 14.0. */
+  minimumVersion?: string;
   types: FileType[];
+}
+/** Builds a plugin for QuickLook on Windows. */
+export interface WindowsConfig {
+  /** The plugin's namespace and assembly name, e.g. `QuickLook.Plugin.Example`. */
+  id: string;
+  /** Extensions to preview, without the dot. */
+  extensions: string[];
+}
+export interface QuickLookConfig {
+  /** App name, shown in Finder and System Settings. */
+  name: string;
+  macos?: MacosConfig;
+  windows?: WindowsConfig;
   /** `sveltekit`, `astro`, `solid-start`, `nuxt`, `analog`, or any integration that sets `build`. */
   framework: IntegrationRef;
   integrations?: IntegrationRef[];
@@ -96,11 +107,18 @@ export interface QuickLookConfig {
   public?: Record<string, unknown>;
   /** Settings the user edits in the app, read on the page with `settings()`. */
   settings?: Record<string, Setting>;
+  /** A file the dev server previews until one is dropped, relative to the project root. */
+  devFile?: string;
 }
 /** What the page sees as `config` from `virtual:quicklook`. */
-export type PageConfig = Pick<ResolvedConfig, 'name' | 'bundleId' | 'types' | 'public'>;
-export interface ResolvedConfig extends Required<Omit<QuickLookConfig, 'framework' | 'integrations' | 'icon'>>, Pick<QuickLookConfig, 'icon'> {
+export type PageConfig = Pick<ResolvedConfig, 'name' | 'public'> & {
+  macos?: Pick<MacosConfig, 'bundleId' | 'types'>;
+};
+export interface ResolvedConfig extends Required<Omit<QuickLookConfig, 'framework' | 'integrations' | 'macos' | 'windows' | 'devFile'>>, Pick<QuickLookConfig, 'windows' | 'devFile'> {
   root: string;
+  macos?: MacosConfig & {
+    minimumVersion: string;
+  };
   framework: Integration & {
     build: NonNullable<Integration['build']>;
   };
@@ -114,5 +132,4 @@ export declare const serializeCsp: (csp: Csp) => string;
 /** `csp` with `sources` appended to `directive`. */
 export declare const addSources: (csp: Csp, directive: string, ...sources: string[]) => Csp;
 export declare function loadConfig(root?: string): Promise<ResolvedConfig>;
-//#endregion
 export {};

package/dist/config.mjs

@@ -1 +1 @@
-export { t as addSources, n as defaultCsp, r as defineConfig, i as loadConfig, a as serializeCsp } from "./config-BVPHnCWr.mjs";
+export { t as addSources, n as defaultCsp, r as defineConfig, i as loadConfig, a as serializeCsp } from "./config-qdxXRvMf.mjs";

package/dist/runtime.d.mts

@@ -1,4 +1,3 @@
-//#region src/runtime.d.ts
 /** The file Quick Look asked to preview. */
 export interface QuickLookFile {
   name: string;
@@ -21,5 +20,4 @@ declare global {
 /** The previewed file inside Quick Look; `undefined` in the browser. */
 export declare function nativeFile(): QuickLookFile | undefined;
 /** The same shape from a file picked or dropped in the browser, for the dev server. */
-export declare function browserFile(file: File): Promise<QuickLookFile>;
-//#endregion
+export declare function browserFile(file: File): Promise<QuickLookFile>;

package/dist/runtime.mjs

@@ -1,4 +1,4 @@
-//#region src/runtime.ts
+// src/runtime.ts
 /** The previewed file inside Quick Look; `undefined` in the browser. */
 function nativeFile() {
 	const injected = window.quicklook;
@@ -17,5 +17,4 @@ async function browserFile(file) {
 		bytes: new Uint8Array(await file.arrayBuffer())
 	};
 }
-//#endregion
 export { browserFile, nativeFile };

package/dist/vite.d.mts

@@ -1,8 +1,6 @@
 import { Plugin } from "vite";
-//#region src/vite.d.ts
 /**
  * Provides `virtual:quicklook`, adds the integrations' Vite plugins, and makes
  * the dev server report what the extension's CSP would block.
  */
-export declare function quicklook(): Promise<Plugin[]>;
-//#endregion
+export declare function quicklook(): Promise<Plugin[]>;

package/dist/vite.mjs

@@ -1,5 +1,7 @@
-import { a as serializeCsp, i as loadConfig, t as addSources } from "./config-BVPHnCWr.mjs";
-//#region src/vite.ts
+import { a as serializeCsp, i as loadConfig, t as addSources } from "./config-qdxXRvMf.mjs";
+import { readFile } from "node:fs/promises";
+import { basename, extname, resolve } from "node:path";
+// src/vite.ts
 const virtualId = "virtual:quicklook";
 /** The schema's defaults as nested objects, the shape the extension injects. */
 function settingDefaults(settings) {
@@ -11,22 +13,38 @@ function settingDefaults(settings) {
 */
 async function quicklook() {
 	const config = await loadConfig();
-	const { name, bundleId, types } = config;
+	const { name, macos } = config;
 	const pageConfig = {
 		name,
-		bundleId,
-		types,
-		public: config.public
+		public: config.public,
+		...macos && { macos: {
+			bundleId: macos.bundleId,
+			types: macos.types
+		} }
 	};
 	const virtualSource = `export const config = ${JSON.stringify(pageConfig)};
 export { browserFile, nativeFile } from 'quicklook-kit/runtime';
 // The injected values in Quick Look, the defaults in the dev server and when prerendering.
 export const settings = () => globalThis.window?.quicklook?.settings ?? ${JSON.stringify(settingDefaults(config.settings))};`;
 	const devCsp = serializeCsp(addSources(addSources(config.csp, "script-src", "'unsafe-inline'"), "connect-src", "'self'", "ws:"));
+	let serve = false;
 	return [{
 		name: "quicklook",
+		config: (_, { command }) => {
+			serve = command === "serve";
+		},
 		resolveId: (source) => source === virtualId ? `\0${virtualId}` : void 0,
-		load: (source) => source === `\0${virtualId}` ? virtualSource : void 0,
+		async load(source) {
+			if (source !== `\0${virtualId}`) return;
+			if (!(serve && config.devFile)) return virtualSource;
+			const path = resolve(config.root, config.devFile);
+			const file = {
+				name: basename(path),
+				extension: extname(path).slice(1).toLowerCase(),
+				base64: (await readFile(path)).toString("base64")
+			};
+			return `if (globalThis.window && !window.quicklook) window.quicklook = ${JSON.stringify(file)};\n${virtualSource}`;
+		},
 		configureServer(server) {
 			server.middlewares.use((_request, response, next) => {
 				response.setHeader("Content-Security-Policy-Report-Only", devCsp);
@@ -35,5 +53,4 @@ export const settings = () => globalThis.window?.quicklook?.settings ?? ${JSON.s
 		}
 	}, ...config.integrations.flatMap((integration) => integration.hooks?.vite?.() ?? [])];
 }
-//#endregion
 export { quicklook };

package/native/Windows/Plugin.cs

@@ -0,0 +1,232 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Web;
+using System.Web.Script.Serialization;
+using System.Windows;
+using System.Windows.Controls;
+using Microsoft.Web.WebView2.Core;
+using Microsoft.Web.WebView2.Wpf;
+using QuickLook.Common.Helpers;
+using QuickLook.Common.Plugin;
+
+namespace QuickLookKit;
+
+/// <summary>
+/// Loads the bundled page from a fake HTTPS origin and hands it the previewed
+/// file as <c>window.quicklook</c>, like native/Extension/PreviewViewController.swift.
+/// Everything project-specific comes from quicklook.json, written by src/windows.ts.
+/// </summary>
+public class Plugin : IViewer
+{
+    private const string Origin = "https://quicklook.example/";
+
+    private static readonly string Folder = Path.GetDirectoryName(typeof(Plugin).Assembly.Location);
+    private static readonly string Web = Path.Combine(Folder, "web") + Path.DirectorySeparatorChar;
+    private static readonly JavaScriptSerializer Json = new() { MaxJsonLength = int.MaxValue };
+
+    private static readonly Dictionary<string, object> Manifest =
+        Json.Deserialize<Dictionary<string, object>>(File.ReadAllText(Path.Combine(Folder, "quicklook.json")));
+
+    private static readonly string Id = (string)Manifest["id"];
+    private static readonly string Csp = (string)Manifest["csp"];
+    private static readonly long MaxFileSize = Convert.ToInt64(Manifest["maxFileSize"]);
+    // JavaScriptSerializer turns JSON arrays into ArrayLists, which aren't IEnumerable<object>.
+    private static readonly HashSet<string> Extensions =
+        new(((IEnumerable)Manifest["extensions"]).Cast<string>(), StringComparer.OrdinalIgnoreCase);
+
+    private WebView2 _webView;
+
+    // Above QL-Win's built-in viewers, which claim common extensions like .json too.
+    public int Priority => 1;
+
+    public void Init()
+    {
+    }
+
+    // Larger files fall through to QL-Win's own viewers instead of stalling
+    // while megabytes of base64 cross into the page.
+    public bool CanHandle(string path) =>
+        !Directory.Exists(path)
+        && Extensions.Contains(Path.GetExtension(path).TrimStart('.'))
+        && new FileInfo(path).Length <= MaxFileSize;
+
+    public void Prepare(string path, ContextObject context)
+    {
+        context.PreferredSize = new Size(1000, 700);
+    }
+
+    public void View(string path, ContextObject context)
+    {
+        context.Title = Path.GetFileName(path);
+        _ = ShowAsync(path, context);
+    }
+
+    private async Task ShowAsync(string path, ContextObject context)
+    {
+        // QL-Win reuses this viewer and its context for the next file, calling
+        // Cleanup() in between; an outdated preview must leave the context alone.
+        WebView2 webView = null;
+        bool Current() => webView == _webView;
+        try
+        {
+            try
+            {
+                CoreWebView2Environment.GetAvailableBrowserVersionString();
+            }
+            catch (WebView2RuntimeNotFoundException)
+            {
+                context.ViewerContent = Notice(
+                    "This preview needs the Microsoft Edge WebView2 Runtime.\n\n" +
+                    "Install it from https://developer.microsoft.com/microsoft-edge/webview2/ and preview the file again.");
+                return;
+            }
+
+            webView = _webView = new WebView2
+            {
+                CreationProperties = new CoreWebView2CreationProperties
+                {
+                    UserDataFolder = Path.Combine(Path.GetTempPath(), Id),
+                },
+            };
+            context.ViewerContent = webView;
+            await webView.EnsureCoreWebView2Async();
+            if (!Current()) return;
+            var core = webView.CoreWebView2;
+
+            // Served by hand rather than mapped to the folder, so every response carries the CSP.
+            core.AddWebResourceRequestedFilter(Origin + "*", CoreWebView2WebResourceContext.All);
+            core.WebResourceRequested += (_, e) => e.Response = Serve(core.Environment, e.Request.Uri);
+            core.NavigationStarting += (_, e) => e.Cancel = !e.Uri.StartsWith(Origin, StringComparison.Ordinal);
+            core.NewWindowRequested += (_, e) => e.Handled = true;
+
+            var file = new Dictionary<string, object>
+            {
+                ["name"] = Path.GetFileName(path),
+                ["extension"] = Path.GetExtension(path).TrimStart('.').ToLowerInvariant(),
+                ["base64"] = Convert.ToBase64String(File.ReadAllBytes(path)),
+            };
+            var settings = ((IEnumerable)Manifest["settings"]).Cast<Dictionary<string, object>>();
+            if (settings.Any())
+            {
+                file["settings"] = ResolveSettings(settings);
+            }
+            // JSON is a valid JavaScript expression, so this needs no escaping of its own.
+            // WebView2 runs this in child frames too, which mustn't see the file.
+            await core.AddScriptToExecuteOnDocumentCreatedAsync(
+                $"if (window === window.top && location.origin + '/' === '{Origin}') window.quicklook = {Json.Serialize(file)};");
+            if (!Current()) return;
+
+            core.Navigate(Origin);
+        }
+        catch (Exception e)
+        {
+            if (Current())
+            {
+                context.ViewerContent = Notice(e.ToString());
+            }
+        }
+        finally
+        {
+            if (Current())
+            {
+                context.IsBusy = false;
+            }
+        }
+    }
+
+    private static CoreWebView2WebResourceResponse Serve(CoreWebView2Environment environment, string uri)
+    {
+        var path = Uri.UnescapeDataString(new Uri(uri).AbsolutePath).TrimStart('/');
+        if (path.Length == 0 || path.EndsWith("/"))
+        {
+            path += "index.html";
+        }
+        var file = Path.GetFullPath(Path.Combine(Web, path));
+        // `..%2f` arrives decoded as a real `..`; never serve anything outside web\.
+        var found = file.StartsWith(Web, StringComparison.OrdinalIgnoreCase) && File.Exists(file);
+        var headers =
+            $"Content-Type: {(found ? MimeMapping.GetMimeMapping(file) : "text/plain")}\r\n" +
+            $"Content-Security-Policy: {Csp}";
+        return environment.CreateWebResourceResponse(
+            found ? new MemoryStream(File.ReadAllBytes(file)) : null,
+            found ? 200 : 404,
+            found ? "OK" : "Not Found",
+            headers);
+    }
+
+    /// <summary>
+    /// Defaults overridden by valid values from QL-Win's settings file for this
+    /// plugin, <c>%APPDATA%\pooi.moe\QuickLook\&lt;id&gt;.config</c>, as nested objects.
+    /// </summary>
+    private static Dictionary<string, object> ResolveSettings(IEnumerable<Dictionary<string, object>> specs)
+    {
+        var values = new Dictionary<string, object>();
+        foreach (var spec in specs)
+        {
+            var key = (string)spec["key"];
+            var type = (string)spec["type"];
+            var fallback = Parse(Convert.ToString(spec["default"], CultureInfo.InvariantCulture), type);
+            var stored = SettingHelper.Get<string>(key, null, Id);
+            // Strings stay verbatim; other types tolerate whitespace around the value.
+            var value = stored == null ? null : Parse(type == "string" ? stored : stored.Trim(), type);
+            if (value == null || !IsValid(value, type, spec))
+            {
+                value = fallback;
+            }
+
+            var parts = key.Split('.');
+            var parent = values;
+            foreach (var part in parts.Take(parts.Length - 1))
+            {
+                if (!parent.TryGetValue(part, out var child))
+                {
+                    parent[part] = child = new Dictionary<string, object>();
+                }
+                parent = (Dictionary<string, object>)child;
+            }
+            parent[parts.Last()] = value;
+        }
+        return values;
+    }
+
+    /// <summary>The setting's value as bool, string, long or double, or null if it isn't one.</summary>
+    private static object Parse(string text, string type) => type switch
+    {
+        "boolean" => bool.TryParse(text, out var b) ? b : null,
+        "string" => text,
+        "integer" => long.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out var l) ? l : null,
+        "number" => double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var d) ? d : null,
+        _ => null,
+    };
+
+    private static bool IsValid(object value, string type, Dictionary<string, object> spec)
+    {
+        if (spec.TryGetValue("enum", out var options)
+            && !((IEnumerable)options).Cast<object>().Any(o =>
+                Equals(Parse(Convert.ToString(o, CultureInfo.InvariantCulture), type), value)))
+        {
+            return false;
+        }
+        if (value is long or double)
+        {
+            var number = Convert.ToDouble(value);
+            if (spec.TryGetValue("minimum", out var min) && number < Convert.ToDouble(min)) return false;
+            if (spec.TryGetValue("maximum", out var max) && number > Convert.ToDouble(max)) return false;
+        }
+        return true;
+    }
+
+    private static TextBox Notice(string text) =>
+        new() { Text = text, IsReadOnly = true, TextWrapping = TextWrapping.Wrap, Margin = new Thickness(16) };
+
+    public void Cleanup()
+    {
+        _webView?.Dispose();
+        _webView = null;
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "quicklook-kit",
-  "version": "0.6.0",
-  "description": "Build macOS Quick Look previews with any Vite-based web framework",
+  "version": "0.7.0",
+  "description": "Build Quick Look previews for macOS and Windows with Vite-based web frameworks",
   "license": "MIT",
   "keywords": [
     "quicklook",
@@ -53,7 +53,7 @@
     "@types/node": "24.19.2",
     "tsdown": "0.23.1",
     "typescript": "6.0.3",
-    "vite": "8.3.4",
+    "vite": "8.3.5",
     "vitest": "5.0.5"
   },
   "peerDependencies": {