@widgetic/creator 0.3.76 → 0.3.77

package/dist/CreatorApp.svelte

@@ -1091,7 +1091,7 @@
 	// so the backend can load multi-turn LLM history (Aider-style incremental edits).
 	let currentChatConversationId: string | null = null;
 	let brandKitEnabled = false;
-	let widgetLanguage = 'svelte';
+	let widgetLanguage: 'svelte' | 'react' = 'react';
 	let librariesEnabled = false;
 	let brandPrimary = '#314F2F';
 	let brandSecondary = '#7BA668';
@@ -7586,6 +7586,9 @@
 				...(lastCommitId ? { hasGeneratedCode: true } : {}),
 			});
 			if (lastCommitId) hasGeneratedCode = true;
+			if (widget.id === focusedPanelWidgetId) {
+				widgetLanguage = languageToShow(widget.id, widgetLanguage === 'svelte' ? 'svelte' : 'react');
+			}
 			// Fetch history whenever the widget has code (generated or published).
 			// Gating on `lastPublishedVersion` alone meant a widget that had only
 			// ever been generated never loaded its history — so its version picker
@@ -8965,6 +8968,47 @@ Requirements:
 		}
 	}
 
+	function generatedLanguageStorageKey(widgetId: string): string {
+		return `widgetic-generated-language:${widgetId}`;
+	}
+
+	function readGeneratedLanguage(widgetId: string): 'svelte' | 'react' | null {
+		try {
+			const value = localStorage.getItem(generatedLanguageStorageKey(widgetId));
+			return value === 'svelte' || value === 'react' ? value : null;
+		} catch (error) {
+			console.warn('[WidgetCreator] Could not read generated language', error);
+			return null;
+		}
+	}
+
+	function rememberGeneratedLanguage(widgetId: string, language: 'svelte' | 'react'): void {
+		try {
+			localStorage.setItem(generatedLanguageStorageKey(widgetId), language);
+		} catch (error) {
+			console.warn('[WidgetCreator] Could not store generated language', error);
+		}
+	}
+
+	function widgetHasGeneratedCode(widgetId: string): boolean {
+		const panel = getPanelState(widgetId);
+		const widget = getWidgetById(widgetId);
+		return !!(
+			panel.lastCommitId
+			|| loadCommitIdForWidget(widgetId)
+			|| panel.lastPublishedVersion != null
+			|| resolvePublishedVersionFromWidget(widget) !== null
+		);
+	}
+
+	/** A widget that already has code stays on the language it was generated with. Older widgets are Svelte. */
+	function languageToShow(widgetId: string, storedLanguage: 'svelte' | 'react' | null): 'svelte' | 'react' {
+		if (widgetHasGeneratedCode(widgetId)) {
+			return readGeneratedLanguage(widgetId) ?? 'svelte';
+		}
+		return storedLanguage ?? 'react';
+	}
+
 	function restoreGenerationOptions(widgetId: string): void {
 		const inMemory = generationOptionsMemory[widgetId];
 		let stored: Partial<RememberedGenerationOptions> | null = null;
@@ -8977,7 +9021,8 @@ Requirements:
 			}
 		}
 		const options = inMemory || stored;
-		widgetLanguage = options?.language === 'react' ? 'react' : 'svelte';
+		const storedLanguage = options?.language === 'svelte' || options?.language === 'react' ? options.language : null;
+		widgetLanguage = languageToShow(widgetId, storedLanguage);
 		librariesEnabled = !!options?.librariesEnabled;
 		brandKitLibraries = Array.isArray(options?.libraries) ? [...options.libraries] : [];
 		brandKitEnabled = !!options?.brandKitEnabled;
@@ -8991,18 +9036,12 @@ Requirements:
 	}
 
 	function languageForGeneration(widgetId: string): 'svelte' | 'react' {
-		const panel = getPanelState(widgetId);
-		const hasCode = !!(panel.lastCommitId || panel.lastPublishedVersion != null);
-		let language: 'svelte' | 'react' = widgetLanguage === 'react' ? 'react' : 'svelte';
-		if (hasCode) {
-			try {
-				const saved = localStorage.getItem(languageStorageKey(widgetId));
-				language = saved === 'react' ? 'react' : 'svelte';
-			} catch (error) {
-				console.warn('[WidgetCreator] Could not read widget language', error);
-			}
-		}
+		const hasCode = widgetHasGeneratedCode(widgetId);
+		const language: 'svelte' | 'react' = hasCode
+			? (readGeneratedLanguage(widgetId) ?? 'svelte')
+			: (widgetLanguage === 'svelte' ? 'svelte' : 'react');
 		widgetLanguage = language;
+		rememberGeneratedLanguage(widgetId, language);
 		rememberGenerationOptions(widgetId);
 		return language;
 	}

package/dist/components/BrandKitPanel.svelte

@@ -55,7 +55,7 @@
 		libraryUploads = $bindable([] as { name: string; content: string; encoding: string }[]),
 		fontUploads = $bindable([] as { name: string; content: string; encoding: string }[]),
 		showLanguage = false,
-		language = $bindable('svelte'),
+		language = $bindable('react'),
 		languageLocked = false,
 	}: Props = $props();
 
@@ -317,10 +317,12 @@
 					</HoverTooltip>
 					{/if}
 				{/if}
+				{#if showPresetLibraries}
 				<label class="generation-option-toggle flex h-10 shrink-0 cursor-pointer items-center gap-1.5 rounded-lg border px-2 text-sm {librariesEnabled ? 'border-[#314F2F] bg-[#314F2F] text-white' : 'border-gray-300 bg-white text-gray-800'}">
 					<input class="generation-option-check cursor-pointer" type="checkbox" checked={librariesEnabled} onchange={onLibrariesChange} />
 					Libraries
 				</label>
+				{/if}
 				{#if librariesEnabled && showPresetLibraries}
 					{#each libraryChoices as choice (choice.id)}
 						<label class="generation-library flex items-center gap-1 text-xs text-gray-700">
@@ -334,7 +336,7 @@
 						</label>
 					{/each}
 				{/if}
-				{#if librariesEnabled}
+				{#if librariesEnabled && showPresetLibraries}
 					<HoverTooltip class="inline-flex shrink-0" text="Add Library">
 						<button
 							type="button"
@@ -345,7 +347,7 @@
 					</HoverTooltip>
 				{/if}
 			</div>
-			{#if librariesEnabled}
+			{#if librariesEnabled && showPresetLibraries}
 				{#each libraryRows as row (row.id)}
 					<div class="generation-source-row flex items-center gap-1">
 						<FileUrlSourceControl

package/dist/utils/widgeticChatUpload.d.ts

@@ -19,6 +19,16 @@ export type ChatUploadOptions = {
     onProgress?: (percentage: number) => void;
     abortSignal?: AbortSignal;
 };
+/**
+ * POST …/complete. A 409 `TUS_UPLOAD_BUSY` means another request still has the upload (the chunk that
+ * just finished, or a retried one), so ask again after a short pause. Every other answer is final: a
+ * 409 `TUS_UPLOAD_INCOMPLETE` means chunks are missing, and asking again cannot bring them.
+ * Returns the last answer; the caller tells success from failure.
+ */
+export declare function requestTusComplete(url: string, init: RequestInit, options?: {
+    retryDelaysMs?: readonly number[];
+    abortSignal?: AbortSignal;
+}): Promise<Response>;
 export declare function shouldUseTusForChatUpload(file: File): boolean;
 /**
  * Upload a chat attachment via multipart (≤10MB) or TUS (>10MB).

package/dist/utils/widgeticChatUpload.js

@@ -2,12 +2,62 @@ import * as tus from 'tus-js-client';
 /** Matches api-gateway MULTIPART_MAX_UPLOAD_BYTES. */
 export const CHAT_MULTIPART_MAX_BYTES = 10 * 1024 * 1024;
 const DEFAULT_TUS_CHUNK_SIZE = 5 * 1024 * 1024;
+/** The `error.code` api-gateway answers `POST …/complete` with (HTTP 409) while another request still has the upload. */
+const TUS_UPLOAD_BUSY_CODE = 'TUS_UPLOAD_BUSY';
+/** Pauses before asking again after a "busy" answer: 0.5, 1, 2, 4 and 8 seconds, about 15 seconds in all. */
+const COMPLETE_BUSY_RETRY_DELAYS_MS = [500, 1000, 2000, 4000, 8000];
 function parseErrorMessage(response, fallback) {
     return response
         .json()
         .then((json) => json?.message || json?.error?.message || fallback)
         .catch(() => fallback);
 }
+/** The `error.code` of a failed answer, or undefined when the body is not the API's error envelope. */
+function readErrorCode(response) {
+    return response
+        .json()
+        .then((json) => (typeof json?.error?.code === 'string' ? json.error.code : undefined))
+        .catch(() => undefined);
+}
+/** Resolves after `delayMs`, or at once when the upload is cancelled meanwhile. */
+function waitBeforeRetry(delayMs, abortSignal) {
+    return new Promise((resolve) => {
+        if (abortSignal?.aborted) {
+            resolve();
+            return;
+        }
+        const finish = () => {
+            clearTimeout(timer);
+            abortSignal?.removeEventListener('abort', finish);
+            resolve();
+        };
+        const timer = setTimeout(finish, delayMs);
+        abortSignal?.addEventListener('abort', finish, { once: true });
+    });
+}
+/**
+ * POST …/complete. A 409 `TUS_UPLOAD_BUSY` means another request still has the upload (the chunk that
+ * just finished, or a retried one), so ask again after a short pause. Every other answer is final: a
+ * 409 `TUS_UPLOAD_INCOMPLETE` means chunks are missing, and asking again cannot bring them.
+ * Returns the last answer; the caller tells success from failure.
+ */
+export async function requestTusComplete(url, init, options = {}) {
+    const retryDelaysMs = options.retryDelaysMs ?? COMPLETE_BUSY_RETRY_DELAYS_MS;
+    let retriesDone = 0;
+    for (;;) {
+        const response = await fetch(url, init);
+        if (response.status !== 409 || retriesDone >= retryDelaysMs.length)
+            return response;
+        // Read a copy, so the caller can still read the message of an answer that turns out to be final.
+        if ((await readErrorCode(response.clone())) !== TUS_UPLOAD_BUSY_CODE)
+            return response;
+        console.warn(`[ChatUpload] Upload is busy; asking again in ${retryDelaysMs[retriesDone]} ms (retry ${retriesDone + 1} of ${retryDelaysMs.length})`);
+        await waitBeforeRetry(retryDelaysMs[retriesDone], options.abortSignal);
+        if (options.abortSignal?.aborted)
+            return response;
+        retriesDone += 1;
+    }
+}
 function mapUploadResponse(data, file) {
     const url = data.url || '';
     if (!url) {
@@ -101,14 +151,19 @@ function uploadTus(file, config, options = {}) {
                     return;
                 }
                 try {
-                    const completeResponse = await fetch(`${endpoint}/${tusId}/complete`, {
+                    const completeResponse = await requestTusComplete(`${endpoint}/${tusId}/complete`, {
                         method: 'POST',
                         headers: {
                             Authorization: `Bearer ${token}`,
                             'Content-Type': 'application/json',
                         },
-                    });
+                    }, { abortSignal: options.abortSignal });
                     if (!completeResponse.ok) {
+                        // Cancelled while waiting to ask again: say so, instead of repeating the server's "busy" answer.
+                        if (options.abortSignal?.aborted) {
+                            reject(new Error('Upload cancelled.'));
+                            return;
+                        }
                         reject(new Error(await parseErrorMessage(completeResponse, `Complete failed (${completeResponse.status})`)));
                         return;
                     }

package/dist/utils/widgeticChatUpload.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/widgeticChatUpload.test.js

@@ -0,0 +1,257 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { CHAT_MULTIPART_MAX_BYTES, requestTusComplete, uploadChatFileToWidgeticApi } from './widgeticChatUpload';
+// The real client opens connections and sends the file in chunks. This stand-in "finishes" the moment it is
+// started, so each test only decides how the gateway answers `POST …/complete`.
+vi.mock('tus-js-client', () => {
+    class Upload {
+        file;
+        options;
+        url = 'https://api.test/v1/uploads/tus/0b9e0f7e-6d2c-4a39-8d36-2f6a5f0c7a11~0123456789abcdef0123456789abcdef';
+        constructor(file, options) {
+            this.file = file;
+            this.options = options;
+        }
+        findPreviousUploads() {
+            return Promise.resolve([]);
+        }
+        resumeFromPreviousUpload() { }
+        start() {
+            this.options.onSuccess();
+        }
+        abort() {
+            return Promise.resolve();
+        }
+    }
+    return { Upload };
+});
+const COMPLETE_URL = 'https://api.test/v1/uploads/tus/0b9e0f7e-6d2c-4a39-8d36-2f6a5f0c7a11~0123456789abcdef0123456789abcdef/complete';
+const BUSY_MESSAGE = 'The upload is in use by another request. Try again in a moment.';
+const INCOMPLETE_MESSAGE = 'Upload is not complete: 4 of 10 bytes received. Send the remaining chunks, then complete the upload.';
+const config = { apiBasePath: 'https://api.test/v1/', accessToken: 'Bearer test-token' };
+/** A file big enough to be sent with TUS, without allocating its bytes (the stand-in never reads them). */
+function largeFile() {
+    const file = new File(['0123456789'], 'clip.mp4', { type: 'video/mp4' });
+    Object.defineProperty(file, 'size', { value: CHAT_MULTIPART_MAX_BYTES + 1 });
+    return file;
+}
+function jsonResponse(status, body) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { 'Content-Type': 'application/json' }
+    });
+}
+/** What api-gateway answers while another request still has the upload. */
+const busyAnswer = () => jsonResponse(409, {
+    success: false,
+    message: BUSY_MESSAGE,
+    error: { code: 'TUS_UPLOAD_BUSY', message: BUSY_MESSAGE }
+});
+/** What api-gateway answers while chunks are missing: asking again cannot help. */
+const incompleteAnswer = () => jsonResponse(409, {
+    success: false,
+    message: INCOMPLETE_MESSAGE,
+    error: { code: 'TUS_UPLOAD_INCOMPLETE', message: INCOMPLETE_MESSAGE }
+});
+const completedAnswer = () => jsonResponse(200, {
+    success: true,
+    data: {
+        id: 'file_1',
+        url: 'https://cdn.test/clip.mp4',
+        file_name: 'clip.mp4',
+        file_size: 10,
+        mime_type: 'video/mp4'
+    }
+});
+const fetchMock = vi.fn();
+const realSetTimeout = globalThis.setTimeout;
+/** Lets every pause end at once and records how long each one was asked to be. */
+function skipPauses() {
+    const requestedPauses = [];
+    vi.spyOn(globalThis, 'setTimeout').mockImplementation(((handler, delayMs) => {
+        requestedPauses.push(delayMs ?? 0);
+        return realSetTimeout(handler, 0);
+    }));
+    return requestedPauses;
+}
+beforeEach(() => {
+    fetchMock.mockReset();
+    vi.stubGlobal('fetch', fetchMock);
+    vi.spyOn(console, 'warn').mockImplementation(() => { });
+    vi.spyOn(console, 'error').mockImplementation(() => { });
+});
+afterEach(() => {
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+});
+describe('requestTusComplete', () => {
+    const init = { method: 'POST', headers: { Authorization: 'Bearer test-token' } };
+    it('asks once when the first answer is a success', async () => {
+        fetchMock.mockResolvedValueOnce(completedAnswer());
+        const response = await requestTusComplete(COMPLETE_URL, init);
+        expect(response.ok).toBe(true);
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(fetchMock).toHaveBeenCalledWith(COMPLETE_URL, init);
+    });
+    it('asks again after a "busy" answer and returns the answer that follows', async () => {
+        fetchMock
+            .mockResolvedValueOnce(busyAnswer())
+            .mockResolvedValueOnce(busyAnswer())
+            .mockResolvedValueOnce(completedAnswer());
+        const response = await requestTusComplete(COMPLETE_URL, init, { retryDelaysMs: [0, 0, 0] });
+        expect(response.ok).toBe(true);
+        expect(fetchMock).toHaveBeenCalledTimes(3);
+    });
+    it('pauses for each given delay, in order, before it asks again', async () => {
+        fetchMock
+            .mockResolvedValueOnce(busyAnswer())
+            .mockResolvedValueOnce(busyAnswer())
+            .mockResolvedValueOnce(completedAnswer());
+        const requestedPauses = skipPauses();
+        await requestTusComplete(COMPLETE_URL, init, { retryDelaysMs: [1111, 2222, 3333] });
+        expect(requestedPauses.filter((delayMs) => delayMs > 1000)).toEqual([1111, 2222]);
+    });
+    it('gives up after the last delay and returns the "busy" answer, message still readable', async () => {
+        fetchMock.mockImplementation(async () => busyAnswer());
+        const response = await requestTusComplete(COMPLETE_URL, init, { retryDelaysMs: [0, 0] });
+        expect(fetchMock).toHaveBeenCalledTimes(3);
+        expect(response.status).toBe(409);
+        expect(await response.json()).toMatchObject({
+            error: { code: 'TUS_UPLOAD_BUSY', message: BUSY_MESSAGE }
+        });
+    });
+    it('does not ask again when chunks are missing (409 TUS_UPLOAD_INCOMPLETE)', async () => {
+        fetchMock.mockResolvedValueOnce(incompleteAnswer());
+        const response = await requestTusComplete(COMPLETE_URL, init, { retryDelaysMs: [0, 0, 0] });
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(response.status).toBe(409);
+        expect(await response.json()).toMatchObject({ error: { code: 'TUS_UPLOAD_INCOMPLETE' } });
+    });
+    it('does not ask again when a 409 carries another code', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse(409, { success: false, error: { code: 'SOMETHING_ELSE' } }));
+        await requestTusComplete(COMPLETE_URL, init, { retryDelaysMs: [0, 0, 0] });
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+    });
+    it('does not ask again when the "busy" code comes with another status', async () => {
+        fetchMock.mockResolvedValueOnce(jsonResponse(503, { success: false, error: { code: 'TUS_UPLOAD_BUSY' } }));
+        await requestTusComplete(COMPLETE_URL, init, { retryDelaysMs: [0, 0, 0] });
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+    });
+    it('does not ask again when a 409 has no JSON body', async () => {
+        fetchMock.mockResolvedValueOnce(new Response('<html>Conflict</html>', { status: 409 }));
+        await requestTusComplete(COMPLETE_URL, init, { retryDelaysMs: [0, 0, 0] });
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+    });
+    it.each([
+        [404, 'TUS_UPLOAD_NOT_FOUND'],
+        [413, 'QUOTA_STORAGE_EXCEEDED'],
+        [415, 'UPLOAD_UNSUPPORTED_TYPE'],
+        [503, 'TUS_DISABLED']
+    ])('does not ask again after a %i %s', async (status, code) => {
+        fetchMock.mockResolvedValueOnce(jsonResponse(status, { success: false, error: { code } }));
+        const response = await requestTusComplete(COMPLETE_URL, init, { retryDelaysMs: [0, 0, 0] });
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(response.status).toBe(status);
+    });
+    it('stops waiting when the upload is cancelled during a pause, and does not ask again', async () => {
+        fetchMock.mockImplementation(async () => busyAnswer());
+        const controller = new AbortController();
+        // A pause long enough that only the cancel can end it.
+        const pauseStarted = new Promise((resolve) => {
+            vi.spyOn(globalThis, 'setTimeout').mockImplementation(((handler, delayMs) => {
+                if (delayMs === 600_000)
+                    resolve();
+                return realSetTimeout(handler, delayMs);
+            }));
+        });
+        const answer = requestTusComplete(COMPLETE_URL, init, {
+            retryDelaysMs: [600_000],
+            abortSignal: controller.signal
+        });
+        await pauseStarted;
+        controller.abort();
+        const response = await answer;
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(response.status).toBe(409);
+    });
+    it('does not wait or ask again when the upload was already cancelled', async () => {
+        fetchMock.mockImplementation(async () => busyAnswer());
+        const controller = new AbortController();
+        controller.abort();
+        const response = await requestTusComplete(COMPLETE_URL, init, {
+            retryDelaysMs: [600_000],
+            abortSignal: controller.signal
+        });
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(response.status).toBe(409);
+    });
+});
+describe('uploadChatFileToWidgeticApi (file above the multipart limit)', () => {
+    it('finishes the upload when /complete answers at once', async () => {
+        fetchMock.mockResolvedValueOnce(completedAnswer());
+        const result = await uploadChatFileToWidgeticApi(largeFile(), config);
+        expect(result).toEqual({
+            id: 'file_1',
+            url: 'https://cdn.test/clip.mp4',
+            fileType: 'video/mp4',
+            fileName: 'clip.mp4',
+            fileSize: 10
+        });
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        const [calledUrl, calledInit] = fetchMock.mock.calls[0];
+        expect(calledUrl).toBe(COMPLETE_URL);
+        expect(calledInit).toMatchObject({
+            method: 'POST',
+            headers: { Authorization: 'Bearer test-token' }
+        });
+    });
+    it('asks again after 0.5 s and then 1 s when /complete says the upload is busy, then finishes', async () => {
+        fetchMock
+            .mockResolvedValueOnce(busyAnswer())
+            .mockResolvedValueOnce(busyAnswer())
+            .mockResolvedValueOnce(completedAnswer());
+        const requestedPauses = skipPauses();
+        const result = await uploadChatFileToWidgeticApi(largeFile(), config);
+        expect(result.id).toBe('file_1');
+        expect(fetchMock).toHaveBeenCalledTimes(3);
+        expect(requestedPauses.filter((delayMs) => delayMs >= 500)).toEqual([500, 1000]);
+    });
+    it('gives up after five more tries and fails with the message of the last answer', async () => {
+        fetchMock.mockImplementation(async () => busyAnswer());
+        const requestedPauses = skipPauses();
+        await expect(uploadChatFileToWidgeticApi(largeFile(), config)).rejects.toThrow(BUSY_MESSAGE);
+        expect(fetchMock).toHaveBeenCalledTimes(6);
+        expect(requestedPauses.filter((delayMs) => delayMs >= 500)).toEqual([
+            500, 1000, 2000, 4000, 8000
+        ]);
+    });
+    it('does not ask again when chunks are missing, and says so', async () => {
+        fetchMock.mockResolvedValueOnce(incompleteAnswer());
+        const requestedPauses = skipPauses();
+        await expect(uploadChatFileToWidgeticApi(largeFile(), config)).rejects.toThrow(INCOMPLETE_MESSAGE);
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(requestedPauses.filter((delayMs) => delayMs >= 500)).toEqual([]);
+    });
+    it('says the upload was cancelled, not that it was busy, when it is cancelled while waiting to ask again', async () => {
+        fetchMock.mockImplementation(async () => busyAnswer());
+        const controller = new AbortController();
+        const pauseStarted = new Promise((resolve) => {
+            vi.spyOn(globalThis, 'setTimeout').mockImplementation(((handler, delayMs) => {
+                // Hold the first pause (0.5 s) open until the cancel arrives.
+                if (delayMs === 500) {
+                    resolve();
+                    return realSetTimeout(handler, 600_000);
+                }
+                return realSetTimeout(handler, 0);
+            }));
+        });
+        const pending = uploadChatFileToWidgeticApi(largeFile(), config, {
+            abortSignal: controller.signal
+        });
+        // Keep the rejection from being reported as unhandled before the test reads it.
+        const outcome = pending.then(() => 'resolved', (error) => error.message);
+        await pauseStarted;
+        controller.abort();
+        expect(await outcome).toBe('Upload cancelled.');
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@widgetic/creator",
-	"version": "0.3.76",
+	"version": "0.3.77",
 	"type": "module",
 	"peerDependencies": {
 		"@sveltejs/kit": "^2.20.0",