@brightspot/ui-builder 1.1.0 → 2.0.0

package/configs/prettier.config.mjs

@@ -1,3 +1,15 @@
+import { createRequire } from 'node:module'
+
+const require = createRequire(import.meta.url)
+const plugins = ['prettier-plugin-organize-imports']
+
+try {
+  require.resolve('prettier-plugin-svelte')
+  plugins.push('prettier-plugin-svelte')
+} catch {
+  // prettier-plugin-svelte is an optional peer dep — skip if not installed
+}
+
 /** @type {import('prettier').Config} */
 export default {
   arrowParens: 'avoid',
@@ -15,5 +27,5 @@ export default {
   tabWidth: 2,
   useTabs: false,
   organizeImportsSkipDestructiveCodeActions: true,
-  plugins: ['prettier-plugin-organize-imports'],
+  plugins,
 }

package/dist/commands/_load-config.d.ts

@@ -0,0 +1,2 @@
+import { type BuilderConfig } from '../lib/resolve-config.js';
+export declare function loadOrExit(): BuilderConfig;

package/dist/commands/_load-config.js

@@ -0,0 +1,23 @@
+import { log } from '../lib/logger.js';
+import { ConfigError, resolveConfig } from '../lib/resolve-config.js';
+// CLI-side wrapper around resolveConfig: prints warnings + a one-line
+// summary, and on ConfigError logs the message and exits 1. Lives next
+// to commands so the lib module stays free of process termination.
+export function loadOrExit() {
+    try {
+        const { config, warnings } = resolveConfig();
+        for (const w of warnings)
+            log.warn(w);
+        log.info(`basePath: ${config.basePath}`);
+        log.info(`entry: ${config.entry}`);
+        log.info(`format: ${config.format}${config.format === 'iife' && config.name ? ` (name: ${config.name})` : ''}`);
+        return config;
+    }
+    catch (e) {
+        if (e instanceof ConfigError) {
+            log.error(e.message);
+            process.exit(1);
+        }
+        throw e;
+    }
+}

package/dist/commands/build.js

@@ -1,11 +1,11 @@
 import { build as viteBuild } from 'vite';
 import { log } from '../lib/logger.js';
-import { resolveConfig } from '../lib/resolve-config.js';
 import { createBuildConfig } from '../vite/vite-config.js';
+import { loadOrExit } from './_load-config.js';
 export async function build() {
-    log.info('Building IIFE bundle...');
-    const { basePath } = resolveConfig();
-    const config = createBuildConfig(basePath);
+    const builder = loadOrExit();
+    log.info(`Building ${builder.format.toUpperCase()} bundle...`);
+    const config = await createBuildConfig({ builder });
     await viteBuild(config);
-    log.success('Build complete — output in dist/');
+    log.success(`Build complete — output in ${builder.output.dir}/`);
 }

package/dist/commands/dev.js

@@ -1,14 +1,31 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import { createServer } from 'vite';
 import { log } from '../lib/logger.js';
-import { resolveConfig } from '../lib/resolve-config.js';
-import { resolveTarget } from '../lib/resolve-target.js';
 import { createDevConfig } from '../vite/vite-config.js';
+import { loadOrExit } from './_load-config.js';
+const LOCAL_URL_PATH = path.join(os.homedir(), '.brightspot', 'local-url');
+const DEFAULT_TARGET = 'http://localhost';
 export async function dev(opts) {
-    const { basePath } = resolveConfig();
-    const target = opts.url ?? resolveTarget();
-    const config = createDevConfig({ target, port: opts.port, basePath });
+    const builder = loadOrExit();
+    const target = opts.url ?? readLocalTarget();
+    const config = await createDevConfig({ builder, target, port: opts.port });
     const server = await createServer(config);
     await server.listen();
     server.printUrls();
     log.success('Dev server running — proxying to ' + target);
 }
+function readLocalTarget() {
+    try {
+        const url = fs.readFileSync(LOCAL_URL_PATH, 'utf8').trim();
+        if (url) {
+            log.info(`Proxy target: ${url}`);
+            return url;
+        }
+    }
+    catch {
+        log.warn(`${LOCAL_URL_PATH} not found — falling back to ${DEFAULT_TARGET}`);
+    }
+    return DEFAULT_TARGET;
+}

package/dist/commands/init.js

@@ -1,7 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { log } from '../lib/logger.js';
-import { resolveTarget } from '../lib/resolve-target.js';
 const cwd = process.cwd();
 export async function init() {
     log.info('Initializing Brightspot UI project...');
@@ -9,7 +8,6 @@ export async function init() {
     writeEslintConfig();
     patchPackageJson();
     scaffoldEntryPoint();
-    resolveTarget();
     log.success('Project initialized. Run `brightspot-ui dev` to start developing.');
 }
 function writeTsConfig() {

package/dist/index.js

@@ -18,7 +18,7 @@ program
 });
 program
     .command('build')
-    .description('Build IIFE bundle for production')
+    .description('Build production bundle')
     .action(async () => {
     const { build } = await import('./commands/build.js');
     await build();

package/dist/lib/resolve-config.d.ts

@@ -1,5 +1,19 @@
-interface BuilderConfig {
+export interface BuilderConfig {
     basePath: string;
+    entry: string;
+    format: 'es' | 'iife';
+    name?: string;
+    output: {
+        dir: string;
+        jsName: string;
+        cssName: string;
+    };
 }
-export declare function resolveConfig(): BuilderConfig;
-export {};
+export interface ResolveResult {
+    config: BuilderConfig;
+    warnings: string[];
+}
+export declare class ConfigError extends Error {
+    constructor(message: string);
+}
+export declare function resolveConfig(): ResolveResult;

package/dist/lib/resolve-config.js

@@ -1,25 +1,115 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { log } from './logger.js';
-const DEFAULT_BASE_PATH = '/_resource/dist/';
+export class ConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ConfigError';
+    }
+}
+const DEFAULTS = {
+    entry: 'src/index.ts',
+    format: 'es',
+    output: {
+        dir: 'dist',
+        jsName: 'bundle.js',
+        cssName: 'style.css',
+    },
+};
 export function resolveConfig() {
     const pkgPath = path.resolve(process.cwd(), 'package.json');
+    let pkg;
     try {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-        const config = pkg['brightspot-ui'];
-        if (config?.basePath) {
-            const basePath = config.basePath;
-            if (!basePath.startsWith('/') || !basePath.endsWith('/')) {
-                log.warn(`basePath "${basePath}" must start and end with "/" — using default`);
-                return { basePath: DEFAULT_BASE_PATH };
-            }
-            log.info(`basePath: ${basePath}`);
-            return { basePath };
-        }
+        pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
     }
     catch {
-        // package.json not found or unreadable — use defaults
+        throw new ConfigError(`Could not read ${pkgPath}.`);
+    }
+    const raw = pkg['brightspot-ui'] ?? {};
+    const warnings = [];
+    const pkgName = pkg.name;
+    const basePath = resolveBasePath(raw.basePath, pkgName, warnings);
+    // Normalize leading `./` so downstream consumers (the proxy regex,
+    // the dev-entry bootstrap import URL) get a canonical form.
+    const entry = (raw.entry ?? DEFAULTS.entry).replace(/^\.\//, '');
+    const format = resolveFormat(raw.format);
+    const name = resolveIifeName(raw.name, format, pkgName, warnings);
+    const output = {
+        dir: raw.output?.dir ?? DEFAULTS.output.dir,
+        jsName: raw.output?.jsName ?? DEFAULTS.output.jsName,
+        cssName: raw.output?.cssName ?? DEFAULTS.output.cssName,
+    };
+    return { config: { basePath, entry, format, name, output }, warnings };
+}
+function resolveBasePath(explicit, pkgName, warnings) {
+    if (explicit) {
+        if (!explicit.startsWith('/') || !explicit.endsWith('/')) {
+            throw new ConfigError(`basePath "${explicit}" must start and end with "/".`);
+        }
+        return explicit;
+    }
+    if (!pkgName) {
+        // BREAKING (2.0): pre-2.0 builds silently fell back to /_resource/dist/
+        // when both knobs were absent. We now exit so misconfigured monorepo
+        // packages don't ship to the wrong URL. Migration paths below.
+        throw new ConfigError('No basePath set in package.json#brightspot-ui.basePath, and no package.json#name to derive one from. ' +
+            'To migrate from @brightspot/ui-builder 1.x: ' +
+            'either set "name": "<slug>" in package.json (basePath will be inferred as /_resource/<slug>/cms/dist/), ' +
+            'or set "brightspot-ui": { "basePath": "/_resource/<slug>/cms/dist/" } explicitly.');
+    }
+    const inferred = `/_resource/${stripScope(pkgName)}/cms/dist/`;
+    warnings.push(`basePath was not set — inferred "${inferred}" from package.json#name "${pkgName}". ` +
+        `Set "brightspot-ui": { "basePath": "..." } in package.json to silence this warning.`);
+    return inferred;
+}
+function resolveFormat(value) {
+    if (value === undefined)
+        return DEFAULTS.format;
+    if (value !== 'es' && value !== 'iife') {
+        throw new ConfigError(`format "${value}" must be "es" or "iife".`);
+    }
+    return value;
+}
+// Vite library mode requires `name` whenever formats include 'iife' or
+// 'umd' — it's a config-time check, not a function-of-whether-the-entry-
+// has-exports check. So when the consumer chooses iife and hasn't set
+// name, we derive a PascalCase identifier from package.json#name
+// (@brightspot/platform-tours -> PlatformTours) and warn. Returns
+// undefined when format is es (name is irrelevant). Throws when iife
+// is chosen but no valid identifier can be derived.
+function resolveIifeName(explicit, format, pkgName, warnings) {
+    if (explicit !== undefined) {
+        if (!isValidJsIdentifier(explicit)) {
+            throw new ConfigError(`name "${explicit}" is not a valid JavaScript identifier — Vite library mode emits ` +
+                `\`var ${explicit} = ...\` for iife output, which would produce a syntax error. ` +
+                `Set "brightspot-ui": { "name": "..." } to a PascalCase identifier (e.g. "PlatformTours").`);
+        }
+        return explicit;
     }
-    log.info(`basePath: ${DEFAULT_BASE_PATH} (default)`);
-    return { basePath: DEFAULT_BASE_PATH };
+    if (format !== 'iife')
+        return undefined;
+    const derived = deriveIifeName(pkgName);
+    if (derived === null) {
+        throw new ConfigError(`format "iife" requires a "name" — could not derive a valid JavaScript identifier from package.json#name "${pkgName ?? '<unset>'}". ` +
+            `Set "brightspot-ui": { "name": "..." } in package.json (e.g. "PlatformTours").`);
+    }
+    warnings.push(`name was not set — derived "${derived}" from package.json#name "${pkgName}". ` +
+        `Set "brightspot-ui": { "name": "..." } in package.json to silence this warning.`);
+    return derived;
+}
+function deriveIifeName(pkgName) {
+    if (!pkgName)
+        return null;
+    const parts = stripScope(pkgName).split(/[-_.]/).filter(Boolean);
+    if (parts.length === 0)
+        return null;
+    const pascal = parts.map(p => p[0].toUpperCase() + p.slice(1)).join('');
+    return isValidJsIdentifier(pascal) ? pascal : null;
+}
+// ASCII-only by design: matches what minifiers and bundlers handle
+// without surprises. ECMAScript permits a wider Unicode range.
+function isValidJsIdentifier(s) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(s);
+}
+function stripScope(pkgName) {
+    return pkgName.replace(/^@[^/]+\//, '');
 }

package/dist/vite/auto-plugins.d.ts

@@ -0,0 +1,2 @@
+import type { PluginOption } from 'vite';
+export declare function loadAutoPlugins(cwd: string): Promise<PluginOption[]>;

package/dist/vite/auto-plugins.js

@@ -0,0 +1,41 @@
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { resolve as resolveEsm } from 'import-meta-resolve';
+import { log } from '../lib/logger.js';
+export async function loadAutoPlugins(cwd) {
+    const candidates = await Promise.all([loadSveltePlugin(cwd)]);
+    return candidates.filter(p => p !== null);
+}
+// Resolve peer-optional plugins from the consumer's cwd, not the builder's
+// own location. A bare `await import(specifier)` resolves relative to this
+// file, which only works under npm flat hoisting. It breaks for yarn 1
+// link, yarn 2+ workspaces, and pnpm strict — exactly the layouts
+// consumers use during development. We use ESM resolution rooted at the
+// consumer's package.json so the `import` condition is honored, unlike CJS
+// require.resolve which trips on ESM-only packages with an `exports`
+// block. Node's native import.meta.resolve has a 2-arg form that does
+// exactly this, but it remains flag-gated behind
+// --experimental-import-meta-resolve in Node 22; the import-meta-resolve
+// polyfill mirrors the same semantics without the flag. Only
+// module-not-found resolution failures become silent skips; other
+// resolution failures (broken package.json#exports, malformed
+// node_modules) and factory errors propagate so the consumer sees a real
+// diagnostic instead of a confusing "plugin not installed".
+async function loadOptionalPlugin(specifier, cwd, detectedMessage, invoke) {
+    const parent = pathToFileURL(path.join(cwd, 'package.json')).href;
+    let resolved;
+    try {
+        resolved = resolveEsm(specifier, parent);
+    }
+    catch (e) {
+        if (e.code === 'ERR_MODULE_NOT_FOUND')
+            return null;
+        throw e;
+    }
+    log.info(detectedMessage);
+    const mod = (await import(resolved));
+    return invoke(mod);
+}
+function loadSveltePlugin(cwd) {
+    return loadOptionalPlugin('@sveltejs/vite-plugin-svelte', cwd, 'Detected @sveltejs/vite-plugin-svelte — registering Svelte plugin.', mod => mod.svelte());
+}

package/dist/vite/plugin-html-inject.d.ts

@@ -1,7 +1,16 @@
 import type { Plugin } from 'vite';
+export interface DevEntryOptions {
+    basePath: string;
+    entry: string;
+    jsName: string;
+    cssName: string;
+}
 /**
- * Serves a dev bootstrap script at the bundle.js path so that Vite's
+ * Serves a dev bootstrap script at the bundle path so that Vite's
  * HMR client and the real entry point are loaded as ES modules.
- * Also serves an empty style.css since Vite injects CSS via JS in dev.
+ * Also serves an empty stylesheet at the css path since Vite injects
+ * CSS via JS in dev. Both filenames mirror the build output knobs
+ * (output.jsName / output.cssName) so a consumer who renames them
+ * keeps dev/build parity.
  */
-export declare function devEntryPlugin(basePath: string, entry: string): Plugin;
+export declare function devEntryPlugin({ basePath, entry, jsName, cssName }: DevEntryOptions): Plugin;

package/dist/vite/plugin-html-inject.js

@@ -1,11 +1,14 @@
 /**
- * Serves a dev bootstrap script at the bundle.js path so that Vite's
+ * Serves a dev bootstrap script at the bundle path so that Vite's
  * HMR client and the real entry point are loaded as ES modules.
- * Also serves an empty style.css since Vite injects CSS via JS in dev.
+ * Also serves an empty stylesheet at the css path since Vite injects
+ * CSS via JS in dev. Both filenames mirror the build output knobs
+ * (output.jsName / output.cssName) so a consumer who renames them
+ * keeps dev/build parity.
  */
-export function devEntryPlugin(basePath, entry) {
-    const bundlePath = `${basePath}bundle.js`;
-    const cssPath = `${basePath}style.css`;
+export function devEntryPlugin({ basePath, entry, jsName, cssName }) {
+    const bundlePath = `${basePath}${jsName}`;
+    const cssPath = `${basePath}${cssName}`;
     return {
         name: 'brightspot-dev-entry',
         configureServer(server) {

package/dist/vite/vite-config.d.ts

@@ -1,10 +1,12 @@
-import type { InlineConfig } from 'vite';
-interface DevConfigOptions {
+import { type InlineConfig } from 'vite';
+import type { BuilderConfig } from '../lib/resolve-config.js';
+export interface DevConfigOptions {
+    builder: BuilderConfig;
     target: string;
     port?: number;
-    basePath: string;
-    entry?: string;
 }
-export declare function createDevConfig({ target, port, basePath, entry }: DevConfigOptions): InlineConfig;
-export declare function createBuildConfig(basePath: string): InlineConfig;
-export {};
+export declare function createDevConfig({ builder, target, port }: DevConfigOptions): Promise<InlineConfig>;
+export interface BuildConfigOptions {
+    builder: BuilderConfig;
+}
+export declare function createBuildConfig({ builder }: BuildConfigOptions): Promise<InlineConfig>;

package/dist/vite/vite-config.js

@@ -1,20 +1,34 @@
 import path from 'node:path';
+import { loadConfigFromFile, mergeConfig } from 'vite';
+import { log } from '../lib/logger.js';
+import { loadAutoPlugins } from './auto-plugins.js';
 import { devEntryPlugin } from './plugin-html-inject.js';
-export function createDevConfig({ target, port, basePath, entry = 'src/index.ts' }) {
+export async function createDevConfig({ builder, target, port }) {
     const cwd = process.cwd();
-    const escaped = basePath.replace(/^\//, '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const entryDir = entry.split('/')[0] + '/';
-    return {
+    const { basePath, entry, output: { jsName, cssName }, } = builder;
+    const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const escaped = escapeRegex(basePath.replace(/^\//, ''));
+    // entry.split('/')[0] yields the file itself (e.g. 'index.ts') for a
+    // root-level entry, which never matches a URL — skip the segment in
+    // that case so /index.ts isn't proxied to the upstream application.
+    const entryParts = entry.split('/');
+    const entryDirAlt = entryParts.length > 1 ? `|${escapeRegex(entryParts[0])}/` : '';
+    const [mkcert, autoPlugins] = await Promise.all([loadMkcertPlugin(), loadAutoPlugins(cwd)]);
+    const base = {
         root: cwd,
         base: '/',
-        plugins: [mkcertPlugin(), devEntryPlugin(basePath, entry)],
+        plugins: [mkcert, devEntryPlugin({ basePath, entry, jsName, cssName }), ...autoPlugins],
         resolve: {
             preserveSymlinks: true,
+            // Vite 8 native: replaces the deprecated vite-tsconfig-paths plugin.
+            // Follows tsconfig `extends` chains and applies to all importers
+            // (including .svelte / .vue) without the plugin's loose-mode dance.
+            tsconfigPaths: true,
         },
         server: {
             port,
             proxy: {
-                [`^/(?!(${escaped}|${entryDir}|@vite|@fs|node_modules))`]: {
+                [`^/(?!(${escaped}${entryDirAlt}|@vite|@fs|node_modules))`]: {
                     target,
                     autoRewrite: true,
                     changeOrigin: true,
@@ -28,32 +42,77 @@ export function createDevConfig({ target, port, basePath, entry = 'src/index.ts'
             },
         },
     };
+    return applyUserConfig(base, cwd, 'serve');
 }
-export function createBuildConfig(basePath) {
+export async function createBuildConfig({ builder }) {
     const cwd = process.cwd();
-    return {
+    const { basePath, entry, format, name, output } = builder;
+    const autoPlugins = await loadAutoPlugins(cwd);
+    const base = {
         root: cwd,
-        base: basePath,
+        plugins: [...autoPlugins],
         resolve: {
             preserveSymlinks: true,
+            // Vite 8 native: replaces the deprecated vite-tsconfig-paths plugin.
+            // Follows tsconfig `extends` chains and applies to all importers
+            // (including .svelte / .vue) without the plugin's loose-mode dance.
+            tsconfigPaths: true,
+        },
+        build: {
+            cssCodeSplit: false,
+            // Vite 7's `build.lib` implied a single bundle. Vite 8 dropped that
+            // default, so any consumer with `await import(...)` in its graph
+            // emits sidecar `*-<hash>.mjs` chunks that the toolkit's promised
+            // two-file output (bundle.js + style.css) doesn't account for —
+            // and that the gradle processResources task doesn't pattern-match
+            // against, so chunks 404 in production. Default-off here restores
+            // the contract; consumers who want code-splitting can opt back in
+            // via Layer 3 (vite.config.ts → build.rollupOptions.output.
+            // codeSplitting = true). Note: Rolldown deprecated the equivalent
+            // `inlineDynamicImports: true` in favor of `codeSplitting: false`.
+            rollupOptions: {
+                output: {
+                    codeSplitting: false,
+                },
+            },
         },
+    };
+    const knobs = {
+        base: basePath,
         build: {
             lib: {
-                entry: path.resolve(cwd, 'src/index.ts'),
-                formats: ['iife'],
-                name: 'BrightspotTheme',
-                fileName: () => 'bundle.js',
+                entry: path.resolve(cwd, entry),
+                formats: [format],
+                fileName: () => output.jsName,
+                // Vite library mode requires `name` whenever format is 'iife'.
+                // resolveConfig guarantees this is set when format is iife (explicit
+                // or derived from package.json#name), so this guard is defensive
+                // against a manually-constructed BuilderConfig that violates the
+                // invariant — we propagate undefined to Vite rather than inject a
+                // silent default; Vite then surfaces its own clear error.
+                ...(format === 'iife' && name ? { name } : {}),
             },
+            outDir: output.dir,
             rollupOptions: {
                 output: {
-                    assetFileNames: () => 'style.css',
+                    assetFileNames: () => output.cssName,
                 },
             },
-            cssCodeSplit: false,
         },
     };
+    return applyUserConfig(mergeConfig(base, knobs), cwd, 'build');
+}
+async function applyUserConfig(merged, cwd, command) {
+    const loaded = await loadConfigFromFile({ command, mode: command === 'serve' ? 'development' : 'production' }, undefined, cwd);
+    if (loaded)
+        log.info(`Merging consumer Vite config from ${path.relative(cwd, loaded.path)}.`);
+    const base = loaded ? mergeConfig(merged, loaded.config) : merged;
+    // configFile: false prevents Vite from re-resolving + double-merging
+    // the consumer's vite.config when the InlineConfig is passed to
+    // viteBuild / createServer.
+    return { ...base, configFile: false };
 }
-async function mkcertPlugin() {
+async function loadMkcertPlugin() {
     const mkcert = await import('vite-plugin-mkcert');
     return mkcert.default();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brightspot/ui-builder",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "type": "module",
   "license": "UNLICENSED",
   "description": "Zero-config build toolkit for Brightspot CMS front-end development.",
@@ -18,26 +18,49 @@
   ],
   "scripts": {
     "build": "tsc --noEmitOnError && chmod +x ./dist/index.js",
-    "clean": "shx rm -rf ./dist/*"
+    "clean": "shx rm -rf ./dist/*",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "dependencies": {
+    "@eslint/js": "^9.23.0",
+    "autoprefixer": "^10.0.0",
     "commander": "^13.0.0",
-    "picocolors": "^1.1.0",
-    "vite": "^7.0.0",
-    "vite-plugin-mkcert": "^1.17.0",
     "eslint": "^9.39.0",
-    "@eslint/js": "^9.23.0",
-    "typescript-eslint": "^8.29.0",
-    "eslint-plugin-prettier": "^5.5.0",
     "eslint-config-prettier": "^10.0.0",
+    "eslint-plugin-prettier": "^5.5.0",
+    "globals": "^16.0.0",
+    "import-meta-resolve": "^4.2.0",
+    "picocolors": "^1.1.0",
     "prettier": "^3.2.0",
     "prettier-plugin-organize-imports": "^4.3.0",
     "typescript": "^5.9.0",
-    "autoprefixer": "^10.0.0",
-    "globals": "^16.0.0"
+    "typescript-eslint": "^8.29.0",
+    "vite": "^8.0.0",
+    "vite-plugin-mkcert": "^1.17.0"
+  },
+  "peerDependencies": {
+    "@sveltejs/vite-plugin-svelte": "^7.0.0",
+    "prettier-plugin-svelte": "^3.0.0",
+    "svelte": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@sveltejs/vite-plugin-svelte": {
+      "optional": true
+    },
+    "svelte": {
+      "optional": true
+    },
+    "prettier-plugin-svelte": {
+      "optional": true
+    }
   },
   "devDependencies": {
+    "@types/node": "^24.10.0",
     "shx": "^0.4.0",
-    "@types/node": "^24.10.0"
+    "vitest": "^4.1.5"
+  },
+  "resolutions": {
+    "vite": "^8.0.0"
   }
 }