windmill-components 1.473.0 → 1.493.2

package/package/components/Editor.svelte

@@ -7,22 +7,6 @@
 
 	languages.typescript.typescriptDefaults.addExtraLib(processStdContent, 'process.d.ts')
 
-	// languages.typescript.javascriptDefaults.setModeConfiguration({
-	// 	completionItems: true,
-	// 	hovers: true,
-	// 	documentSymbols: true,
-	// 	definitions: true,
-	// 	references: true,
-	// 	documentHighlights: true,
-	// 	rename: true,
-	// 	diagnostics: true,
-	// 	documentRangeFormattingEdits: true,
-	// 	signatureHelp: true,
-	// 	onTypeFormattingEdits: true,
-	// 	codeActions: true,
-	// 	inlayHints: true
-	// })
-
 	languages.typescript.typescriptDefaults.setModeConfiguration({
 		completionItems: true,
 		hovers: true,
@@ -52,8 +36,9 @@
 	languages.typescript.typescriptDefaults.setDiagnosticsOptions({
 		noSemanticValidation: false,
 		noSyntaxValidation: false,
+
 		noSuggestionDiagnostics: false,
-		diagnosticCodesToIgnore: [1108]
+		diagnosticCodesToIgnore: [1108, 7006, 7034, 7019, 7005]
 	})
 
 	languages.typescript.typescriptDefaults.setCompilerOptions({
@@ -80,26 +65,13 @@
 		strict: true,
 		noLib: false,
 		allowImportingTsExtensions: true,
-		moduleResolution: languages.typescript.ModuleResolutionKind.NodeJs
+		allowSyntheticDefaultImports: true,
+		moduleResolution: languages.typescript.ModuleResolutionKind.NodeJs,
+		jsx: languages.typescript.JsxEmit.React
 	})
-
-	// languages.typescript.javascriptDefaults.setCompilerOptions({
-	// 	target: languages.typescript.ScriptTarget.Latest,
-	// 	allowNonTsExtensions: true,
-	// 	noSemanticValidation: false,
-	// 	noSyntaxValidation: false,
-	// 	allowImportingTsExtensions: true,
-	// 	checkJs: true,
-	// 	allowJs: true,
-	// 	noUnusedParameters: true,
-	// 	noUnusedLocals: true,
-	// 	strict: true,
-	// 	noLib: true,
-	// 	moduleResolution: languages.typescript.ModuleResolutionKind.NodeJs
-	// })
 </script>
 
-<script>import { BROWSER } from 'esm-env';
+<script lang="ts">import { BROWSER } from 'esm-env';
 import { sendUserToast } from '../toast';
 import { createEventDispatcher, onDestroy, onMount } from 'svelte';
 // import libStdContent from '../es6.d.ts.txt?raw'
@@ -114,25 +86,31 @@ import { toSocket, WebSocketMessageReader, WebSocketMessageWriter } from 'vscode
 import { CloseAction, ErrorAction, RequestType } from 'vscode-languageclient';
 import { MonacoBinding } from 'y-monaco';
 import { dbSchemas, copilotInfo, codeCompletionSessionEnabled, lspTokenStore, formatOnSave, vimMode } from '../stores';
-import { createHash as randomHash, editorConfig, langToExt, updateOptions } from '../editorUtils';
+import { createHash as randomHash, editorConfig, langToExt, updateOptions, extToLang } from '../editorUtils';
 import { workspaceStore } from '../stores';
-import { UserService } from '../gen';
-import { initializeVscode } from './vscode';
+import { ResourceService, UserService } from '../gen';
+import { initializeVscode, keepModelAroundToAvoidDisposalOfWorkers } from './vscode';
 import { initializeMode } from 'monaco-graphql/esm/initializeMode.js';
-import { sleep } from '../utils';
-import { editorCodeCompletion } from './copilot/completion';
 import { editor as meditor, languages, KeyCode, KeyMod, Uri as mUri } from 'monaco-editor';
 import EditorTheme from './EditorTheme.svelte';
-import { BIGQUERY_TYPES, MSSQL_TYPES, MYSQL_TYPES, ORACLEDB_TYPES, POSTGRES_TYPES, SNOWFLAKE_TYPES } from '../consts';
+import { BIGQUERY_TYPES, DUCKDB_TYPES, MSSQL_TYPES, MYSQL_TYPES, ORACLEDB_TYPES, POSTGRES_TYPES, SNOWFLAKE_TYPES } from '../consts';
 import { setupTypeAcquisition } from '../ata/index';
 import { initWasmTs } from '../infer';
 import { initVim } from './monaco_keybindings';
-import { buildWorkerDefinition } from '../monaco_workers/build_workers';
 import { parseTypescriptDeps } from '../relative_imports';
+import { scriptLangToEditorLang } from '../scripts';
+import * as htmllang from '../svelteMonarch';
+import { conf, language } from '../vueMonarch';
+import { Autocompletor } from './copilot/autocomplete/monaco-adapter';
+import { AIChatEditorHandler } from './copilot/chat/monaco-adapter';
+import GlobalReviewButtons from './copilot/chat/GlobalReviewButtons.svelte';
+import { writable } from 'svelte/store';
+import { formatResourceTypes } from './copilot/chat/core';
+import FakeMonacoPlaceHolder from './FakeMonacoPlaceHolder.svelte';
 // import EditorTheme from './EditorTheme.svelte'
 let divEl = null;
 let editor = null;
-export let lang;
+// for related places search: ADD_NEW_LANG
 export let code = '';
 export let cmdEnterAction = undefined;
 export let formatAction = undefined;
@@ -156,16 +134,15 @@ export let small = false;
 export let scriptLang;
 export let disabled = false;
 export let lineNumbersMinChars = 3;
-const rHash = randomHash();
+export let files = {};
+export let extraLib = undefined;
+export let changeTimeout = 500;
+export let isAiPanelOpen = false;
+export let loadAsync = false;
+let lang = scriptLangToEditorLang(scriptLang);
+$: lang = scriptLangToEditorLang(scriptLang);
+let filePath = computePath(path);
 $: filePath = computePath(path);
-function computePath(path) {
-    if (path == '' || path == undefined || path.startsWith('/')) {
-        return rHash;
-    }
-    else {
-        return path;
-    }
-}
 let initialPath = path;
 $: path != initialPath &&
     (scriptLang == 'deno' || scriptLang == 'bun' || scriptLang == 'bunnative') &&
@@ -180,14 +157,64 @@ const dispatch = createEventDispatcher();
 let graphqlService = undefined;
 let dbSchema = undefined;
 let destroyed = false;
-const uri = lang != 'go' && lang != 'typescript' && lang != 'python'
-    ? `file:///${filePath ?? rHash}.${langToExt(lang)}`
-    : `file:///tmp/monaco/${randomHash()}.${langToExt(lang)}`;
+const uri = computeUri(filePath, scriptLang);
 console.log('uri', uri);
-buildWorkerDefinition();
+function computeUri(filePath, scriptLang) {
+    let file;
+    if (filePath.includes('.')) {
+        file = filePath;
+    }
+    else {
+        file = `${filePath}.${scriptLang == 'tsx' ? 'tsx' : langToExt(lang)}`;
+    }
+    if (file.startsWith('/')) {
+        file = file.slice(1);
+    }
+    return !['deno', 'go', 'python3'].includes(scriptLang ?? '')
+        ? `file:///${file}`
+        : `file:///tmp/monaco/${file}`;
+}
+function computePath(path) {
+    if (['deno', 'go', 'python3'].includes(scriptLang ?? '') ||
+        path == '' ||
+        path == undefined //||path.startsWith('/')
+    ) {
+        return randomHash();
+    }
+    else {
+        console.log('path', path);
+        return path;
+    }
+}
+export function switchToFile(path, value, lang) {
+    if (editor) {
+        const uri = mUri.parse(path);
+        console.log('switching to file', path, lang);
+        // vscode.workspace.fs.writeFile(uri, new TextEncoder().encode(value))
+        let nmodel = meditor.getModel(uri);
+        if (nmodel) {
+            console.log('using existing model', path);
+            editor.setModel(nmodel);
+        }
+        else {
+            console.log('creating model', path);
+            nmodel = meditor.createModel(value, lang, uri);
+            editor.setModel(nmodel);
+        }
+        model = nmodel;
+        setTypescriptExtraLibs();
+    }
+}
+let valueAfterDispose = undefined;
 export function getCode() {
+    if (valueAfterDispose != undefined) {
+        return valueAfterDispose;
+    }
     return editor?.getValue() ?? '';
 }
+export function getModel() {
+    return editor?.getModel() ?? undefined;
+}
 export function insertAtCursor(code) {
     if (editor) {
         editor.trigger('keyboard', 'type', { text: code });
@@ -256,7 +283,7 @@ export function setCode(ncode, noHistory = false) {
             editor.pushUndoStop();
             editor.executeEdits('set', [
                 {
-                    range: editor.getModel().getFullModelRange(),
+                    range: editor.getModel().getFullModelRange(), // full range
                     text: ncode
                 }
             ]);
@@ -287,7 +314,7 @@ export function append(code) {
 export async function format() {
     if (editor) {
         code = getCode();
-        if (lang != 'shell') {
+        if (lang != 'shell' && lang != 'nu') {
             if ($formatOnSave != false) {
                 if (scriptLang == 'deno' && languageClients.length > 0) {
                     languageClients.forEach(async (x) => {
@@ -373,7 +400,9 @@ function addSqlTypeCompletions() {
                                     ? MSSQL_TYPES
                                     : scriptLang === 'oracledb'
                                         ? ORACLEDB_TYPES
-                                        : []).map((t) => ({
+                                        : scriptLang === 'duckdb'
+                                            ? DUCKDB_TYPES
+                                            : []).map((t) => ({
                     label: t,
                     kind: languages.CompletionItemKind.Function,
                     insertText: t,
@@ -500,55 +529,88 @@ function addDBSchemaCompletions() {
         });
     }
 }
-let copilotCompletor = undefined;
-let copilotTs = Date.now();
-let abortController = undefined;
-function addCopilotSuggestions() {
-    if (copilotCompletor) {
-        copilotCompletor.dispose();
+let reviewingChanges = writable(false);
+let aiChatEditorHandler = undefined;
+export function reviewAndApplyCode(code) {
+    aiChatEditorHandler?.reviewAndApply(code);
+}
+function addChatHandler(editor) {
+    try {
+        aiChatEditorHandler = new AIChatEditorHandler(editor);
+        reviewingChanges = aiChatEditorHandler.reviewingChanges;
     }
-    copilotCompletor = vscode.languages.registerInlineCompletionItemProvider({ pattern: '**' }, {
-        async provideInlineCompletionItems(model, position, context, token) {
-            abortController?.abort();
-            const textUntilPosition = model.getText(new vscode.Range(0, 0, position.line, position.character));
-            let items = [];
-            const lastChar = textUntilPosition[textUntilPosition.length - 1];
-            if (textUntilPosition.trim().length > 5 && lastChar.match(/[\(\{\s:=]/)) {
-                const textAfterPosition = model.getText(new vscode.Range(position.line, position.character, model.lineCount + 1, 1));
-                const thisTs = Date.now();
-                copilotTs = thisTs;
-                await sleep(200);
-                if (copilotTs === thisTs) {
-                    abortController?.abort();
-                    abortController = new AbortController();
-                    token.onCancellationRequested(() => {
-                        abortController?.abort();
-                    });
-                    const aiProvider = $copilotInfo.ai_provider;
-                    const insertText = await editorCodeCompletion(textUntilPosition, textAfterPosition, lang, abortController, aiProvider);
-                    if (insertText) {
-                        items = [
-                            {
-                                insertText,
-                                range: new vscode.Range(position.line, position.character, position.line, position.character)
-                            }
-                        ];
-                    }
-                }
-            }
-            return {
-                items,
-                commands: []
-            };
+    catch (err) {
+        console.error('Could not add chat handler', err);
+    }
+}
+$: $reviewingChanges && autocompletor?.reject();
+let completorDisposable = undefined;
+let autocompletor = undefined;
+function addSuperCompletor(editor) {
+    try {
+        if (completorDisposable) {
+            completorDisposable.dispose();
         }
-    });
+        if (!scriptLang) {
+            throw new Error('No script lang');
+        }
+        autocompletor = new Autocompletor(editor, lang, scriptLang);
+        // last user events (currently disabled):
+        // let lastTs = Date.now()
+        // editor.onDidChangeModelContent((e) => {
+        // 	const thisTs = Date.now()
+        // 	lastTs = thisTs
+        // 	setTimeout(() => {
+        // 		if (thisTs === lastTs) {
+        // 			autocompletor?.savePatch()
+        // 		}
+        // 	}, 150)
+        // })
+        completorDisposable = editor.onDidChangeCursorPosition((e) => {
+            autocompletor?.reject();
+            if ($reviewingChanges) {
+                return;
+            }
+            const position = editor.getPosition();
+            if (!position) {
+                return;
+            }
+            const upToText = editor.getModel()?.getValueInRange({
+                startLineNumber: position.lineNumber,
+                startColumn: 0,
+                endLineNumber: position.lineNumber,
+                endColumn: position.column
+            });
+            const lastChar = upToText ? upToText[upToText.length - 1] : '';
+            if (lastChar && lastChar.match(/[\(\{\s:="',]/)) {
+                autocompletor?.predict();
+            }
+        });
+        editor.onKeyDown((e) => {
+            if (e.keyCode === KeyCode.Escape) {
+                autocompletor?.reject();
+            }
+            else if (e.keyCode === KeyCode.Tab && autocompletor?.hasChanges()) {
+                e.preventDefault();
+                e.stopPropagation();
+                autocompletor?.accept();
+                autocompletor?.predict();
+            }
+        });
+    }
+    catch (err) {
+        console.error('Could not add supercompletor', err);
+    }
 }
-$: $copilotInfo.exists_ai_resource &&
-    $copilotInfo.code_completion_model &&
+$: $copilotInfo.enabled &&
+    $copilotInfo.codeCompletionModel &&
     $codeCompletionSessionEnabled &&
     initialized &&
-    addCopilotSuggestions();
-$: !$codeCompletionSessionEnabled && copilotCompletor && copilotCompletor.dispose();
+    editor &&
+    scriptLang &&
+    addSuperCompletor(editor);
+$: $copilotInfo.enabled && initialized && editor && addChatHandler(editor);
+$: !$codeCompletionSessionEnabled && (completorDisposable?.dispose(), autocompletor?.reject());
 const outputChannel = {
     name: 'Language Server Client',
     appendLine: (msg) => {
@@ -564,8 +626,15 @@ const outputChannel = {
     dispose: () => { }
 };
 export async function reloadWebsocket() {
-    console.log('reloadWebsocket');
     await closeWebsockets();
+    if (!useWebsockets ||
+        !((lang == 'typescript' && scriptLang === 'deno') ||
+            lang == 'python' ||
+            lang == 'go' ||
+            lang == 'shell')) {
+        return;
+    }
+    console.log('reloadWebsocket');
     function createLanguageClient(transports, name, initializationOptions, middlewareOptions) {
         const client = new MonacoLanguageClient({
             name: name,
@@ -686,10 +755,6 @@ export async function reloadWebsocket() {
     const wsProtocol = BROWSER && window.location.protocol == 'https:' ? 'wss' : 'ws';
     const hostname = getHostname();
     let encodedImportMap = '';
-    // if (lang == 'typescript') {
-    // 	let worker = await languages.typescript.getTypeScriptWorker()
-    // 	console.log(worker)
-    // }
     if (useWebsockets) {
         if (lang == 'typescript' && scriptLang === 'deno') {
             ata = undefined;
@@ -827,7 +892,8 @@ export async function reloadWebsocket() {
                         !websocketAlive.go &&
                         !websocketAlive.shellcheck &&
                         !websocketAlive.ruff &&
-                        scriptLang != 'bun') {
+                        scriptLang != 'bun' &&
+                        scriptLang != 'tsx') {
                         console.log('reconnecting to language servers');
                         lastWsAttempt = new Date();
                         nbWsAttempt++;
@@ -904,21 +970,89 @@ function onVimMode() {
         vimDisposable = initVim(editor, statusDiv, saveDraft);
     }
 }
+$: files && model && onFileChanges();
+let svelteRegistered = false;
+let vueRegistered = false;
+function onFileChanges() {
+    if (files && Object.keys(files).find((x) => x.endsWith('.svelte')) != undefined) {
+        if (!svelteRegistered) {
+            svelteRegistered = true;
+            languages.register({
+                id: 'svelte',
+                extensions: ['.svelte'],
+                aliases: ['Svelte', 'svelte'],
+                mimetypes: ['application/svelte']
+            });
+            languages.setLanguageConfiguration('svelte', htmllang.conf);
+            languages.setMonarchTokensProvider('svelte', htmllang.language);
+        }
+    }
+    if (files && Object.keys(files).find((x) => x.endsWith('.vue')) != undefined) {
+        if (!vueRegistered) {
+            vueRegistered = true;
+            languages.register({
+                id: 'vue',
+                extensions: ['.vue'],
+                aliases: ['Vue', 'Vue'],
+                mimetypes: ['application/svelte']
+            });
+            languages.setLanguageConfiguration('vue', conf);
+            languages.setMonarchTokensProvider('vue', language);
+        }
+    }
+    if (files && model) {
+        for (const [path, { code, readonly }] of Object.entries(files)) {
+            const luri = mUri.file(path);
+            if (luri.toString() != model.uri.toString()) {
+                let nmodel = meditor.getModel(luri);
+                if (nmodel == undefined) {
+                    const lmodel = meditor.createModel(code, extToLang(path?.split('.')?.pop()), luri);
+                    if (readonly) {
+                        lmodel.onDidChangeContent((evt) => {
+                            // This will effectively undo any new edits
+                            if (lmodel.getValue() != code && code) {
+                                lmodel.setValue(code);
+                            }
+                        });
+                    }
+                }
+                else {
+                    const lmodel = meditor.getModel(luri);
+                    if (lmodel && code) {
+                        lmodel.setValue(code);
+                    }
+                }
+            }
+        }
+    }
+}
 let timeoutModel = undefined;
 async function loadMonaco() {
+    console.log('path', uri);
     try {
         console.log("Loading Monaco's language client");
-        await initializeVscode('editor');
+        await initializeVscode('editor', divEl);
         console.log('done loading Monaco and vscode');
     }
     catch (e) {
         console.log('error initializing services', e);
     }
+    // vscode.languages.registerDefinitionProvider('*', {
+    // 	provideDefinition(document, position, token) {
+    // 		// Get the word under the cursor (this will be the import or function being clicked)
+    // 		const wordRange = document.getWordRangeAtPosition(position)
+    // 		const word = document.getText(wordRange)
+    // 		// Do something with the word (for example, log it or handle it)
+    // 		console.log('Clicked on import or symbol:', word)
+    // 		// Optionally, you can also return a definition location
+    // 		return null // If you don't want to override the default behavior
+    // 	}
+    // })
     // console.log('bef ready')
     // console.log('af ready')
     initialized = true;
     try {
-        model = meditor.createModel(code, lang, mUri.parse(uri));
+        model = meditor.createModel(code, lang == 'nu' ? 'python' : lang, mUri.parse(uri));
     }
     catch (err) {
         console.log('model already existed', err);
@@ -929,6 +1063,7 @@ async function loadMonaco() {
         model = nmodel;
     }
     model.updateOptions(lang == 'python' ? { tabSize: 4, insertSpaces: true } : updateOptions);
+    onFileChanges();
     editor = meditor.create(divEl, {
         ...editorConfig(code, lang, automaticLayout, fixedOverflowWidgets),
         model,
@@ -938,6 +1073,7 @@ async function loadMonaco() {
         tabSize: lang == 'python' ? 4 : 2,
         folding
     });
+    keepModelAroundToAvoidDisposalOfWorkers();
     // updateEditorKeybindingsMode(editor, 'vim', undefined)
     let ataModel = undefined;
     editor?.onDidChangeModelContent((event) => {
@@ -945,11 +1081,13 @@ async function loadMonaco() {
         timeoutModel = setTimeout(() => {
             let ncode = getCode();
             code = ncode;
-            dispatch('change', code);
-        }, 500);
+            dispatch('change', ncode);
+        }, changeTimeout);
         ataModel && clearTimeout(ataModel);
         ataModel = setTimeout(() => {
-            ata?.(getCode());
+            if (scriptLang == 'bun') {
+                ata?.(getCode());
+            }
         }, 1000);
     });
     editor?.onDidBlurEditorText(() => {
@@ -969,25 +1107,48 @@ async function loadMonaco() {
             // CMD + slash (toggle comment) on some EU keyboards
             editor?.trigger('keyboard', 'editor.action.commentLine', {});
         });
+        editor?.addCommand(KeyMod.CtrlCmd | KeyCode.KeyL, function () {
+            const selectedLines = getSelectedLines();
+            const selection = editor?.getSelection();
+            const hasSelection = selection &&
+                (selection.startLineNumber !== selection.endLineNumber ||
+                    selection.startColumn !== selection.endColumn);
+            if (hasSelection && selectedLines) {
+                dispatch('addSelectedLinesToAiChat', {
+                    lines: selectedLines,
+                    startLine: selection.startLineNumber,
+                    endLine: selection.endLineNumber
+                });
+                if (!isAiPanelOpen) {
+                    dispatch('toggleAiPanel');
+                }
+            }
+            else {
+                dispatch('toggleAiPanel');
+            }
+        });
+        editor?.addCommand(KeyMod.CtrlCmd | KeyCode.KeyU, function () {
+            dispatch('toggleTestPanel');
+        });
         if (!websocketAlive.deno &&
             !websocketAlive.pyright &&
             !websocketAlive.ruff &&
             !websocketAlive.shellcheck &&
             !websocketAlive.go &&
-            !websocketInterval &&
-            scriptLang != 'bun') {
-            console.log('reconnecting to language servers on focus');
+            !websocketInterval) {
             reloadWebsocket();
         }
     });
     reloadWebsocket();
     setTypescriptExtraLibs();
+    setTypescriptRTNamespace();
     return () => {
         console.log('disposing editor');
         ata = undefined;
         try {
             closeWebsockets();
             vimDisposable?.dispose();
+            console.log('disposing editor');
             model?.dispose();
             editor && editor.dispose();
             console.log('disposed editor');
@@ -997,75 +1158,96 @@ async function loadMonaco() {
         }
     };
 }
+export async function fetchPackageDeps(deps) {
+    ata?.(deps);
+}
+async function setTypescriptRTNamespace() {
+    if (scriptLang &&
+        (scriptLang === 'bun' ||
+            scriptLang === 'deno' ||
+            scriptLang === 'bunnative' ||
+            scriptLang === 'nativets')) {
+        const resourceTypes = await ResourceService.listResourceType({
+            workspace: $workspaceStore ?? ''
+        });
+        const namespace = formatResourceTypes(resourceTypes, scriptLang === 'bunnative' ? 'bun' : scriptLang);
+        languages.typescript.typescriptDefaults.addExtraLib(namespace, 'rt.d.ts');
+    }
+}
 async function setTypescriptExtraLibs() {
-    if (lang === 'typescript' && scriptLang != 'deno') {
+    if (extraLib) {
+        const uri = mUri.parse('file:///extraLib.d.ts');
+        languages.typescript.typescriptDefaults.addExtraLib(extraLib, uri.toString());
+    }
+    if (lang === 'typescript' && (scriptLang == 'bun' || scriptLang == 'tsx') && ata == undefined) {
         const hostname = getHostname();
-        if (scriptLang == 'bun' && ata == undefined) {
-            const addLibraryToRuntime = async (code, _path) => {
-                const path = 'file://' + _path;
-                let uri = mUri.parse(path);
-                console.log('adding library to runtime', path);
-                languages.typescript.typescriptDefaults.addExtraLib(code, path);
-                try {
-                    await vscode.workspace.fs.writeFile(uri, new TextEncoder().encode(code));
+        const addLibraryToRuntime = async (code, _path) => {
+            const path = 'file://' + _path;
+            let uri = mUri.parse(path);
+            console.log('adding library to runtime', path);
+            languages.typescript.typescriptDefaults.addExtraLib(code, path);
+            try {
+                await vscode.workspace.fs.writeFile(uri, new TextEncoder().encode(code));
+            }
+            catch (e) {
+                console.log('error writing file', e);
+            }
+        };
+        const addLocalFile = async (code, _path) => {
+            let p = new URL(_path, uri).href;
+            // if (_path?.startsWith('/')) {
+            // 	p = 'file://' + p
+            // }
+            let nuri = mUri.parse(p);
+            console.log('adding local file', _path, nuri.toString());
+            if (editor) {
+                let localModel = meditor.getModel(nuri);
+                if (localModel) {
+                    localModel.setValue(code);
                 }
-                catch (e) {
-                    console.log('error writing file', e);
+                else {
+                    meditor.createModel(code, 'typescript', nuri);
                 }
-            };
-            const addLocalFile = async (code, _path) => {
-                let p = new URL(_path, uri).href;
-                // if (_path?.startsWith('/')) {
-                // 	p = 'file://' + p
-                // }
-                let nuri = mUri.parse(p);
-                console.log('adding local file', _path, nuri.toString());
-                if (editor) {
-                    let localModel = meditor.getModel(nuri);
-                    if (localModel) {
-                        localModel.setValue(code);
-                    }
-                    else {
-                        meditor.createModel(code, 'typescript', nuri);
-                    }
-                    try {
-                        if (model) {
-                            model?.setValue(model.getValue());
-                        }
-                    }
-                    catch (e) {
-                        console.log('error resetting model', e);
+                try {
+                    if (model) {
+                        model?.setValue(model.getValue());
                     }
                 }
-            };
-            await initWasmTs();
-            const root = await genRoot(hostname);
-            console.log('SETUP TYPE ACQUISITION', { root, path });
-            ata = setupTypeAcquisition({
-                projectName: 'Windmill',
-                depsParser: (c) => {
-                    return parseTypescriptDeps(c);
+                catch (e) {
+                    console.log('error resetting model', e);
+                }
+            }
+        };
+        await initWasmTs();
+        const root = await genRoot(hostname);
+        console.log('SETUP TYPE ACQUISITION', { root, path });
+        ata = setupTypeAcquisition({
+            projectName: 'Windmill',
+            depsParser: (c) => {
+                return parseTypescriptDeps(c);
+            },
+            root,
+            scriptPath: path,
+            logger: console,
+            delegate: {
+                receivedFile: addLibraryToRuntime,
+                localFile: addLocalFile,
+                progress: (downloaded, total) => {
+                    // console.log({ dl, ttl })
                 },
-                root,
-                scriptPath: path,
-                logger: console,
-                delegate: {
-                    receivedFile: addLibraryToRuntime,
-                    localFile: addLocalFile,
-                    progress: (downloaded, total) => {
-                        // console.log({ dl, ttl })
-                    },
-                    started: () => {
-                        console.log('ATA start');
-                    },
-                    finished: (f) => {
-                        console.log('ATA done');
-                    }
+                started: () => {
+                    console.log('ATA start');
+                },
+                finished: (f) => {
+                    console.log('ATA done');
                 }
-            });
+            }
+        });
+        if (scriptLang == 'bun') {
             ata?.('import "bun-types"');
             ata?.(code);
         }
+        dispatch('ataReady');
     }
 }
 export function addAction(id, label, callback, keybindings = []) {
@@ -1079,18 +1261,25 @@ export function addAction(id, label, callback, keybindings = []) {
         }
     });
 }
-onMount(() => {
+onMount(async () => {
     if (BROWSER) {
-        loadMonaco().then((x) => (disposeMethod = x));
+        if (loadAsync) {
+            setTimeout(() => loadMonaco().then((x) => (disposeMethod = x)), 0);
+        }
+        else {
+            let m = await loadMonaco();
+            disposeMethod = m;
+        }
     }
 });
 onDestroy(() => {
     console.log('destroying editor');
+    valueAfterDispose = getCode();
     destroyed = true;
     disposeMethod && disposeMethod();
     websocketInterval && clearInterval(websocketInterval);
     sqlSchemaCompletor && sqlSchemaCompletor.dispose();
-    copilotCompletor && copilotCompletor.dispose();
+    completorDisposable && completorDisposable.dispose();
     sqlTypeCompletor && sqlTypeCompletor.dispose();
     timeoutModel && clearTimeout(timeoutModel);
 });
@@ -1111,9 +1300,25 @@ async function genRoot(hostname) {
 </script>
 
 <EditorTheme />
-<div bind:this={divEl} class="{$$props.class} editor {disabled ? 'disabled' : ''}" />
+{#if !editor}
+	<div class="inset-0 absolute overflow-clip">
+		<FakeMonacoPlaceHolder {code} />
+	</div>
+{/if}
+<div bind:this={divEl} class="{$$props.class} editor {disabled ? 'disabled' : ''}"></div>
 {#if $vimMode}
-	<div class="fixed bottom-0 z-30" bind:this={statusDiv} />
+	<div class="fixed bottom-0 z-30" bind:this={statusDiv}></div>
+{/if}
+
+{#if $reviewingChanges}
+	<GlobalReviewButtons
+		on:acceptAll={() => {
+			aiChatEditorHandler?.acceptAll()
+		}}
+		on:rejectAll={() => {
+			aiChatEditorHandler?.rejectAll()
+		}}
+	/>
 {/if}
 
 <style global>