@joinezco/codeblock 0.0.8 → 0.0.9

package/dist/utils/lsp.js

@@ -1,74 +1,109 @@
 import * as Comlink from 'comlink';
-import { LanguageServerClient, languageServerWithClient } from "@marimo-team/codemirror-languageserver";
-import MessagePortTransport from "../rpc/transport";
-import { HighlightStyle } from "@codemirror/language";
-import { languageSupportCompartment, renderMarkdownCode } from "../editor";
-import markdownit from 'markdown-it';
-import { vscodeLightDark } from "../themes/vscode";
+import { LSPClient, languageServerExtensions } from "@codemirror/lsp-client";
+import { messagePortTransport } from "../rpc/transport";
 const clients = new Map();
-// TODO: better fix for this reference sticking around to prevent Comlink from releasing the port
-export const languageServerFactory = new Map();
+// FileChangeType from LSP spec
+export const FileChangeType = { Created: 1, Changed: 2, Deleted: 3 };
+const MAX_LOG_ENTRIES = 200;
+const lspLogBuffer = [];
+const lspLogListeners = new Set();
+export var LspLog;
+(function (LspLog) {
+    function entries() {
+        return lspLogBuffer;
+    }
+    LspLog.entries = entries;
+    function push(level, message) {
+        lspLogBuffer.push({ timestamp: Date.now(), level, message });
+        if (lspLogBuffer.length > MAX_LOG_ENTRIES) {
+            lspLogBuffer.splice(0, lspLogBuffer.length - MAX_LOG_ENTRIES);
+        }
+        for (const listener of lspLogListeners)
+            listener();
+    }
+    LspLog.push = push;
+    function clear() {
+        lspLogBuffer.length = 0;
+        for (const listener of lspLogListeners)
+            listener();
+    }
+    LspLog.clear = clear;
+    function subscribe(fn) {
+        lspLogListeners.add(fn);
+        return () => { lspLogListeners.delete(fn); };
+    }
+    LspLog.subscribe = subscribe;
+})(LspLog || (LspLog = {}));
+// Cached factory (Comlink-wrapped) and LSP port per language
+const languageServerFactory = new Map();
+const lspPorts = new Map();
 export const lspWorkers = new Map();
 export var LSP;
 (function (LSP) {
-    async function worker(language, fs) {
-        let factory, worker;
-        console.debug('language', { language });
+    async function worker(language, fs, libFiles) {
+        let factory;
+        let worker;
         switch (language) {
             case 'javascript':
             case 'typescript':
                 factory = languageServerFactory.get('javascript');
                 worker = lspWorkers.get('javascript');
-                console.debug('got worker', { worker, factory });
                 if (!factory) {
                     worker = new SharedWorker(new URL('../workers/javascript.worker.js', import.meta.url), { type: 'module' });
                     worker.port.start();
                     lspWorkers.set('javascript', worker);
-                    const { createLanguageServer } = Comlink.wrap(worker.port);
-                    factory = createLanguageServer;
+                    const wrapped = Comlink.wrap(worker.port);
+                    factory = wrapped.createLanguageServer;
                     languageServerFactory.set('javascript', factory);
                 }
                 break;
+            default:
+                return null;
         }
-        await factory?.(Comlink.proxy({ fs }));
-        return { worker };
+        // fs is proxied (has methods), libFiles is plain data (structured clone)
+        // The factory returns a MessagePort for the LSP connection (separate from Comlink's port)
+        const lspPort = await factory(Comlink.proxy(fs), libFiles);
+        lspPort.start();
+        lspPorts.set(language, lspPort);
+        return { worker: worker, lspPort };
     }
     LSP.worker = worker;
-    async function client({ fs, language, path, view }) {
+    async function client({ fs, language, path, libFiles }) {
         let client = clients.get(language);
-        let clientExtension;
         const uri = `file:///${path}`;
         if (!client) {
-            const { worker } = await LSP.worker(language, fs);
-            if (!worker)
+            const result = await LSP.worker(language, fs, libFiles);
+            if (!result)
                 return null;
-            console.debug('got worker', { worker });
-            client = new LanguageServerClient({
-                transport: new MessagePortTransport(worker.port),
+            const { lspPort } = result;
+            client = new LSPClient({
                 rootUri: 'file:///',
-                workspaceFolders: [{ name: 'workspace', uri: 'file:///' }]
+                extensions: languageServerExtensions(),
+                notificationHandlers: {
+                    "window/logMessage": (_client, params) => {
+                        const level = params.type === 1 ? 'error' : params.type === 2 ? 'warn' : params.type === 3 ? 'info' : 'log';
+                        LspLog.push(level, params.message);
+                        return false; // fall through to default handler (console)
+                    }
+                },
             });
+            client.connect(messagePortTransport(lspPort));
+            clients.set(language, client);
         }
-        clients.set(language, client);
-        clientExtension = { client, extension: [] };
-        clientExtension.extension = languageServerWithClient({
-            client: clientExtension.client,
-            documentUri: uri,
-            languageId: language,
-            allowHTMLContent: true,
-            markdownRenderer(markdown) {
-                const support = languageSupportCompartment.get(view.state);
-                const highlighter = vscodeLightDark[1].find(item => item.value instanceof HighlightStyle)?.value;
-                const parser = support.language?.parser;
-                const md = markdownit({
-                    highlight: (str) => {
-                        return renderMarkdownCode(str, parser, highlighter);
-                    }
-                });
-                return md.render(markdown);
-            },
-        });
-        return clientExtension;
+        return client.plugin(uri, language);
     }
     LSP.client = client;
+    /**
+     * Notify all connected LSP clients that a file was created, changed, or deleted.
+     * This sends workspace/didChangeWatchedFiles so the server re-evaluates the project.
+     */
+    function notifyFileChanged(path, type = FileChangeType.Changed) {
+        const uri = `file:///${path}`;
+        for (const client of clients.values()) {
+            client.notification("workspace/didChangeWatchedFiles", {
+                changes: [{ uri, type }]
+            });
+        }
+    }
+    LSP.notifyFileChanged = notifyFileChanged;
 })(LSP || (LSP = {}));

package/dist/utils/search.d.ts

@@ -15,7 +15,9 @@ export type HighlightedSearch = SearchResult & {
 };
 export declare class SearchIndex {
     index: MiniSearch;
+    savePath?: string;
     constructor(index: MiniSearch);
+    add(path: string): void;
     search(...params: Parameters<MiniSearch['search']>): HighlightedSearch[];
     /**
      *

package/dist/utils/search.js

@@ -7,9 +7,16 @@ export const defaultFilter = (path) => {
 };
 export class SearchIndex {
     index;
+    /// The VFS path this index was loaded from / saved to, if known.
+    savePath;
     constructor(index) {
         this.index = index;
     }
+    add(path) {
+        if (!this.index.has(path)) {
+            this.index.add({ path });
+        }
+    }
     search(...params) {
         const results = this.index.search(...params);
         const highlights = this.highlight(results);
@@ -48,10 +55,12 @@ export class SearchIndex {
         return new SearchIndex(index);
     }
     static async get(fs, path, fields = defaultFields) {
-        const index = await fs.exists(path) ? await fs.readFile(path) : null;
-        return index ?
-            SearchIndex.from(index, fields) :
-            SearchIndex.build(fs, { fields, idField: 'path' }).then(index => index.save(fs, path));
+        const data = await fs.exists(path) ? await fs.readFile(path) : null;
+        let index = data
+            ? SearchIndex.from(data, fields)
+            : await SearchIndex.build(fs, { fields, idField: 'path' }).then(idx => idx.save(fs, path));
+        index.savePath = path;
+        return index;
     }
     static async build(fs, { filter = defaultFilter, ...rest }) {
         const index = new MiniSearch({ ...rest });

package/dist/utils/typescript-defaults.d.ts

@@ -0,0 +1,57 @@
+import { VfsInterface } from "../types";
+export type TypescriptDefaultsConfig = {
+    /** ES target, determines which lib files are needed. Default: "ES2020" */
+    target?: string;
+    /** Additional lib names to load beyond the ES target libs.
+     *  Defaults to TypeScript's `.full` environment libs (dom, dom.iterable,
+     *  dom.asynciterable, webworker.importscripts, scripthost).
+     *  Pass `[]` to disable. */
+    additionalLibs?: string[];
+    /** Custom tsconfig compilerOptions merged with defaults */
+    compilerOptions?: Record<string, any>;
+};
+/**
+ * Returns the list of TypeScript lib file names required for a given ES target,
+ * plus any additional libs (DOM by default).
+ * Names are without the `lib.` prefix and `.d.ts` suffix (e.g. "es5", "dom").
+ */
+export declare function getRequiredLibs(target?: string, additionalLibs?: string[]): string[];
+/**
+ * Returns all individual lib names for the tsconfig `lib` field.
+ *
+ * Lists every individual lib file (e.g. "es5", "es2015.promise", "dom") instead of
+ * just the top-level entry (e.g. "ES2020"). This is critical for browser-based
+ * TypeScript via Volar: the virtual filesystem is async, so each
+ * `/// <reference lib="..." />` chain level requires a separate async round-trip.
+ * By listing all libs explicitly, TypeScript loads them all in a single pass.
+ */
+export declare function getLibFieldForTarget(target?: string, additionalLibs?: string[]): string[];
+/**
+ * Returns the cached lib file contents from the last prefill, if available.
+ * These are keyed by full path (e.g. "/node_modules/typescript/lib/lib.es5.d.ts").
+ * Includes the tsconfig.json content as well.
+ */
+export declare function getCachedLibFiles(): Record<string, string> | undefined;
+/**
+ * Pre-fills the virtual filesystem with TypeScript default lib definitions and tsconfig.
+ * Writes to `/node_modules/typescript/lib/` where Volar's TypeScript language server
+ * expects to find them in a browser environment.
+ *
+ * - Skips files that already exist on the filesystem
+ * - Only runs once per session (subsequent calls are no-ops)
+ * - Should be called lazily when a TypeScript file is first opened
+ *
+ * Returns a map of file paths to their contents for direct use by the LSP worker,
+ * bypassing the need for the worker to read through nested Comlink proxies.
+ *
+ * @param fs - Virtual filesystem to write to
+ * @param resolveLib - Function that resolves a lib name to its `.d.ts` content.
+ *                     Receives names like "es5", "es2015.collection".
+ *                     In Vite, use `import.meta.glob('typescript/lib/*.d.ts', { query: '?raw' })`.
+ * @param config - Optional target and tsconfig overrides
+ */
+export declare function prefillTypescriptDefaults(fs: VfsInterface, resolveLib: (name: string) => Promise<string>, config?: TypescriptDefaultsConfig): Promise<Record<string, string>>;
+/**
+ * Resets the prefilled state. Primarily useful for testing.
+ */
+export declare function resetPrefillState(): void;

package/dist/utils/typescript-defaults.js

@@ -0,0 +1,208 @@
+const LIB_DIR = '/node_modules/typescript/lib';
+const TSCONFIG_PATH = '/tsconfig.json';
+/**
+ * Maps ES target names to the list of TypeScript lib files they require.
+ * Each target includes all libs from previous targets plus its own additions.
+ * Derived from the `/// <reference lib="..." />` chains in TypeScript's lib files.
+ */
+const TARGET_LIBS = {
+    es5: [
+        'es5',
+        'decorators',
+        'decorators.legacy',
+    ],
+    es2015: [
+        'es5', 'decorators', 'decorators.legacy',
+        'es2015',
+        'es2015.core', 'es2015.collection', 'es2015.iterable',
+        'es2015.generator', 'es2015.promise', 'es2015.proxy',
+        'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown',
+    ],
+    es2016: [
+        'es5', 'decorators', 'decorators.legacy',
+        'es2015',
+        'es2015.core', 'es2015.collection', 'es2015.iterable',
+        'es2015.generator', 'es2015.promise', 'es2015.proxy',
+        'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown',
+        'es2016',
+        'es2016.array.include', 'es2016.intl',
+    ],
+    es2017: [
+        'es5', 'decorators', 'decorators.legacy',
+        'es2015',
+        'es2015.core', 'es2015.collection', 'es2015.iterable',
+        'es2015.generator', 'es2015.promise', 'es2015.proxy',
+        'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown',
+        'es2016',
+        'es2016.array.include', 'es2016.intl',
+        'es2017',
+        'es2017.arraybuffer', 'es2017.date', 'es2017.intl',
+        'es2017.object', 'es2017.sharedmemory', 'es2017.string',
+        'es2017.typedarrays',
+    ],
+    es2018: [
+        'es5', 'decorators', 'decorators.legacy',
+        'es2015',
+        'es2015.core', 'es2015.collection', 'es2015.iterable',
+        'es2015.generator', 'es2015.promise', 'es2015.proxy',
+        'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown',
+        'es2016',
+        'es2016.array.include', 'es2016.intl',
+        'es2017',
+        'es2017.arraybuffer', 'es2017.date', 'es2017.intl',
+        'es2017.object', 'es2017.sharedmemory', 'es2017.string',
+        'es2017.typedarrays',
+        'es2018',
+        'es2018.asynciterable', 'es2018.asyncgenerator',
+        'es2018.promise', 'es2018.regexp', 'es2018.intl',
+    ],
+    es2019: [
+        'es5', 'decorators', 'decorators.legacy',
+        'es2015',
+        'es2015.core', 'es2015.collection', 'es2015.iterable',
+        'es2015.generator', 'es2015.promise', 'es2015.proxy',
+        'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown',
+        'es2016',
+        'es2016.array.include', 'es2016.intl',
+        'es2017',
+        'es2017.arraybuffer', 'es2017.date', 'es2017.intl',
+        'es2017.object', 'es2017.sharedmemory', 'es2017.string',
+        'es2017.typedarrays',
+        'es2018',
+        'es2018.asynciterable', 'es2018.asyncgenerator',
+        'es2018.promise', 'es2018.regexp', 'es2018.intl',
+        'es2019',
+        'es2019.array', 'es2019.object', 'es2019.string',
+        'es2019.symbol', 'es2019.intl',
+    ],
+    es2020: [
+        'es5', 'decorators', 'decorators.legacy',
+        'es2015',
+        'es2015.core', 'es2015.collection', 'es2015.iterable',
+        'es2015.generator', 'es2015.promise', 'es2015.proxy',
+        'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown',
+        'es2016',
+        'es2016.array.include', 'es2016.intl',
+        'es2017',
+        'es2017.arraybuffer', 'es2017.date', 'es2017.intl',
+        'es2017.object', 'es2017.sharedmemory', 'es2017.string',
+        'es2017.typedarrays',
+        'es2018',
+        'es2018.asynciterable', 'es2018.asyncgenerator',
+        'es2018.promise', 'es2018.regexp', 'es2018.intl',
+        'es2019',
+        'es2019.array', 'es2019.object', 'es2019.string',
+        'es2019.symbol', 'es2019.intl',
+        'es2020',
+        'es2020.bigint', 'es2020.date', 'es2020.number',
+        'es2020.promise', 'es2020.sharedmemory', 'es2020.string',
+        'es2020.symbol.wellknown', 'es2020.intl',
+    ],
+};
+/**
+ * Environment lib files included by TypeScript's `.full` variants (e.g. lib.es2020.full.d.ts).
+ * TypeScript includes these by default when no explicit `lib` is specified in tsconfig.
+ * We list them explicitly to match VS Code's default behavior.
+ */
+const DEFAULT_ENV_LIBS = ['dom', 'dom.iterable', 'dom.asynciterable', 'webworker.importscripts', 'scripthost'];
+/**
+ * Returns the list of TypeScript lib file names required for a given ES target,
+ * plus any additional libs (DOM by default).
+ * Names are without the `lib.` prefix and `.d.ts` suffix (e.g. "es5", "dom").
+ */
+export function getRequiredLibs(target = 'es2020', additionalLibs = DEFAULT_ENV_LIBS) {
+    const targetLibs = TARGET_LIBS[target.toLowerCase()] || TARGET_LIBS.es2020;
+    return [...targetLibs, ...additionalLibs];
+}
+/**
+ * Returns all individual lib names for the tsconfig `lib` field.
+ *
+ * Lists every individual lib file (e.g. "es5", "es2015.promise", "dom") instead of
+ * just the top-level entry (e.g. "ES2020"). This is critical for browser-based
+ * TypeScript via Volar: the virtual filesystem is async, so each
+ * `/// <reference lib="..." />` chain level requires a separate async round-trip.
+ * By listing all libs explicitly, TypeScript loads them all in a single pass.
+ */
+export function getLibFieldForTarget(target = 'es2020', additionalLibs = DEFAULT_ENV_LIBS) {
+    const t = target.toLowerCase();
+    const targetLibs = TARGET_LIBS[t] || TARGET_LIBS.es2020;
+    return [...targetLibs, ...additionalLibs];
+}
+let prefilled = false;
+let cachedLibFiles;
+/**
+ * Returns the cached lib file contents from the last prefill, if available.
+ * These are keyed by full path (e.g. "/node_modules/typescript/lib/lib.es5.d.ts").
+ * Includes the tsconfig.json content as well.
+ */
+export function getCachedLibFiles() {
+    return cachedLibFiles;
+}
+/**
+ * Pre-fills the virtual filesystem with TypeScript default lib definitions and tsconfig.
+ * Writes to `/node_modules/typescript/lib/` where Volar's TypeScript language server
+ * expects to find them in a browser environment.
+ *
+ * - Skips files that already exist on the filesystem
+ * - Only runs once per session (subsequent calls are no-ops)
+ * - Should be called lazily when a TypeScript file is first opened
+ *
+ * Returns a map of file paths to their contents for direct use by the LSP worker,
+ * bypassing the need for the worker to read through nested Comlink proxies.
+ *
+ * @param fs - Virtual filesystem to write to
+ * @param resolveLib - Function that resolves a lib name to its `.d.ts` content.
+ *                     Receives names like "es5", "es2015.collection".
+ *                     In Vite, use `import.meta.glob('typescript/lib/*.d.ts', { query: '?raw' })`.
+ * @param config - Optional target and tsconfig overrides
+ */
+export async function prefillTypescriptDefaults(fs, resolveLib, config = {}) {
+    if (prefilled) {
+        return cachedLibFiles || {};
+    }
+    prefilled = true;
+    const target = config.target || 'ES2020';
+    const additionalLibs = config.additionalLibs ?? DEFAULT_ENV_LIBS;
+    const fileContents = {};
+    // Write tsconfig.json if it doesn't exist
+    const tsconfigExists = await fs.exists(TSCONFIG_PATH);
+    const tsconfigContent = JSON.stringify({
+        compilerOptions: {
+            target,
+            lib: getLibFieldForTarget(target, additionalLibs),
+            module: "ESNext",
+            moduleResolution: "bundler",
+            strict: true,
+            skipLibCheck: true,
+            ...config.compilerOptions,
+        }
+    }, null, 2);
+    fileContents[TSCONFIG_PATH] = tsconfigContent;
+    if (!tsconfigExists) {
+        await fs.writeFile(TSCONFIG_PATH, tsconfigContent);
+    }
+    // Write lib files to the path Volar expects in browser environments
+    const libs = getRequiredLibs(target, additionalLibs);
+    await fs.mkdir(LIB_DIR, { recursive: true });
+    await Promise.all(libs.map(async (name) => {
+        const path = `${LIB_DIR}/lib.${name}.d.ts`;
+        try {
+            const content = await resolveLib(name);
+            fileContents[path] = content;
+            if (!(await fs.exists(path))) {
+                await fs.writeFile(path, content);
+            }
+        }
+        catch (e) {
+            console.error(`Failed to load TypeScript lib: ${name}`, e);
+        }
+    }));
+    cachedLibFiles = fileContents;
+    return fileContents;
+}
+/**
+ * Resets the prefilled state. Primarily useful for testing.
+ */
+export function resetPrefillState() {
+    prefilled = false;
+}

package/dist/utils/typescript-defaults.test.d.ts

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

package/dist/utils/typescript-defaults.test.js

@@ -0,0 +1,197 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { getRequiredLibs, getLibFieldForTarget, prefillTypescriptDefaults, resetPrefillState } from './typescript-defaults';
+function createMockFs() {
+    const files = new Map();
+    return {
+        readFile: vi.fn(async (path) => {
+            if (!files.has(path))
+                throw new Error(`ENOENT: ${path}`);
+            return files.get(path);
+        }),
+        writeFile: vi.fn(async (path, data) => {
+            files.set(path, data);
+        }),
+        exists: vi.fn(async (path) => files.has(path)),
+        mkdir: vi.fn(async () => { }),
+        readDir: vi.fn(async () => []),
+        stat: vi.fn(async () => null),
+        watch: vi.fn(),
+    };
+}
+describe('getRequiredLibs', () => {
+    it('returns ES5 libs for es5 target', () => {
+        const libs = getRequiredLibs('es5');
+        expect(libs).toContain('es5');
+        expect(libs).toContain('decorators');
+        expect(libs).toContain('decorators.legacy');
+        expect(libs).not.toContain('es2015');
+    });
+    it('returns ES2015 libs including ES5 for es2015 target', () => {
+        const libs = getRequiredLibs('es2015');
+        expect(libs).toContain('es5');
+        expect(libs).toContain('es2015');
+        expect(libs).toContain('es2015.promise');
+        expect(libs).toContain('es2015.collection');
+        expect(libs).not.toContain('es2016');
+    });
+    it('returns ES2020 libs for es2020 target', () => {
+        const libs = getRequiredLibs('es2020');
+        expect(libs).toContain('es5');
+        expect(libs).toContain('es2015');
+        expect(libs).toContain('es2020');
+        expect(libs).toContain('es2020.bigint');
+        expect(libs).toContain('es2020.promise');
+    });
+    it('is case-insensitive', () => {
+        expect(getRequiredLibs('ES2020')).toEqual(getRequiredLibs('es2020'));
+    });
+    it('defaults to ES2020 for unknown targets', () => {
+        expect(getRequiredLibs('unknown')).toEqual(getRequiredLibs('es2020'));
+    });
+    it('defaults to ES2020 when no target is provided', () => {
+        expect(getRequiredLibs()).toEqual(getRequiredLibs('es2020'));
+    });
+});
+describe('getLibFieldForTarget', () => {
+    it('returns all individual lib names for a target', () => {
+        const libs = getLibFieldForTarget('es2020');
+        expect(libs).toContain('es5');
+        expect(libs).toContain('es2015');
+        expect(libs).toContain('es2015.promise');
+        expect(libs).toContain('es2020');
+        expect(libs).toContain('es2020.bigint');
+        expect(libs).toEqual(getRequiredLibs('es2020'));
+    });
+    it('returns es2015 libs for es2015 target', () => {
+        const libs = getLibFieldForTarget('ES2015');
+        expect(libs).toContain('es5');
+        expect(libs).toContain('es2015');
+        expect(libs).not.toContain('es2016');
+    });
+    it('defaults to es2020 libs for unknown targets', () => {
+        expect(getLibFieldForTarget('unknown')).toEqual(getRequiredLibs('es2020'));
+    });
+    it('defaults to es2020 libs when no target is provided', () => {
+        expect(getLibFieldForTarget()).toEqual(getRequiredLibs('es2020'));
+    });
+});
+describe('prefillTypescriptDefaults', () => {
+    let mockFs;
+    const mockResolveLib = vi.fn(async (name) => `// lib.${name}.d.ts content`);
+    beforeEach(() => {
+        mockFs = createMockFs();
+        mockResolveLib.mockClear();
+        resetPrefillState();
+    });
+    it('writes tsconfig.json with default settings', async () => {
+        await prefillTypescriptDefaults(mockFs, mockResolveLib);
+        expect(mockFs.writeFile).toHaveBeenCalledWith('/tsconfig.json', expect.stringContaining('"target"'));
+        const tsconfigCall = vi.mocked(mockFs.writeFile).mock.calls.find(([path]) => path === '/tsconfig.json');
+        const tsconfig = JSON.parse(tsconfigCall[1]);
+        expect(tsconfig.compilerOptions.target).toBe('ES2020');
+        expect(tsconfig.compilerOptions.lib).toEqual(getRequiredLibs('es2020'));
+        expect(tsconfig.compilerOptions.module).toBe('ESNext');
+        expect(tsconfig.compilerOptions.strict).toBe(true);
+    });
+    it('does not overwrite existing tsconfig.json', async () => {
+        // Pre-create tsconfig.json
+        await mockFs.writeFile('/tsconfig.json', '{"existing": true}');
+        vi.mocked(mockFs.writeFile).mockClear();
+        await prefillTypescriptDefaults(mockFs, mockResolveLib);
+        const tsconfigWrites = vi.mocked(mockFs.writeFile).mock.calls.filter(([path]) => path === '/tsconfig.json');
+        expect(tsconfigWrites).toHaveLength(0);
+    });
+    it('merges custom compilerOptions into tsconfig', async () => {
+        await prefillTypescriptDefaults(mockFs, mockResolveLib, {
+            compilerOptions: { jsx: 'react-jsx', strict: false },
+        });
+        const tsconfigCall = vi.mocked(mockFs.writeFile).mock.calls.find(([path]) => path === '/tsconfig.json');
+        const tsconfig = JSON.parse(tsconfigCall[1]);
+        expect(tsconfig.compilerOptions.jsx).toBe('react-jsx');
+        expect(tsconfig.compilerOptions.strict).toBe(false);
+    });
+    it('writes TypeScript lib files to /node_modules/typescript/lib/', async () => {
+        await prefillTypescriptDefaults(mockFs, mockResolveLib, { target: 'es5' });
+        expect(mockFs.mkdir).toHaveBeenCalledWith('/node_modules/typescript/lib', { recursive: true });
+        // ES5 needs 3 target libs + 5 default env libs (dom, dom.iterable, etc.)
+        const libWrites = vi.mocked(mockFs.writeFile).mock.calls.filter(([path]) => path.startsWith('/node_modules/typescript/lib/'));
+        expect(libWrites).toHaveLength(8);
+        expect(libWrites.map(([path]) => path)).toEqual(expect.arrayContaining([
+            '/node_modules/typescript/lib/lib.es5.d.ts',
+            '/node_modules/typescript/lib/lib.decorators.d.ts',
+            '/node_modules/typescript/lib/lib.decorators.legacy.d.ts',
+            '/node_modules/typescript/lib/lib.dom.d.ts',
+            '/node_modules/typescript/lib/lib.dom.iterable.d.ts',
+            '/node_modules/typescript/lib/lib.dom.asynciterable.d.ts',
+            '/node_modules/typescript/lib/lib.webworker.importscripts.d.ts',
+            '/node_modules/typescript/lib/lib.scripthost.d.ts',
+        ]));
+    });
+    it('calls resolveLib for each lib file', async () => {
+        await prefillTypescriptDefaults(mockFs, mockResolveLib, { target: 'es5' });
+        expect(mockResolveLib).toHaveBeenCalledWith('es5');
+        expect(mockResolveLib).toHaveBeenCalledWith('decorators');
+        expect(mockResolveLib).toHaveBeenCalledWith('decorators.legacy');
+        expect(mockResolveLib).toHaveBeenCalledWith('dom');
+        expect(mockResolveLib).toHaveBeenCalledWith('dom.iterable');
+        expect(mockResolveLib).toHaveBeenCalledWith('dom.asynciterable');
+        expect(mockResolveLib).toHaveBeenCalledWith('webworker.importscripts');
+        expect(mockResolveLib).toHaveBeenCalledWith('scripthost');
+    });
+    it('does not overwrite existing lib files', async () => {
+        // Pre-create one lib file
+        await mockFs.writeFile('/node_modules/typescript/lib/lib.es5.d.ts', '// existing');
+        vi.mocked(mockFs.writeFile).mockClear();
+        mockResolveLib.mockClear();
+        await prefillTypescriptDefaults(mockFs, mockResolveLib, { target: 'es5' });
+        // resolveLib is called for all libs (to populate the return cache)
+        expect(mockResolveLib).toHaveBeenCalledWith('es5');
+        // But the existing file should NOT be overwritten in the VFS
+        const es5Writes = vi.mocked(mockFs.writeFile).mock.calls.filter(([path]) => path === '/node_modules/typescript/lib/lib.es5.d.ts');
+        expect(es5Writes).toHaveLength(0);
+        // Other libs should still be written
+        expect(mockResolveLib).toHaveBeenCalledWith('decorators');
+        expect(mockResolveLib).toHaveBeenCalledWith('decorators.legacy');
+    });
+    it('only runs once per session', async () => {
+        const result1 = await prefillTypescriptDefaults(mockFs, mockResolveLib, { target: 'es5' });
+        const firstCallCount = mockResolveLib.mock.calls.length;
+        const result2 = await prefillTypescriptDefaults(mockFs, mockResolveLib, { target: 'es5' });
+        // Should not have been called again
+        expect(mockResolveLib).toHaveBeenCalledTimes(firstCallCount);
+        // Second call returns cached result
+        expect(result2).toEqual(result1);
+    });
+    it('returns lib file contents keyed by path', async () => {
+        const result = await prefillTypescriptDefaults(mockFs, mockResolveLib, { target: 'es5' });
+        expect(result['/tsconfig.json']).toBeDefined();
+        expect(result['/node_modules/typescript/lib/lib.es5.d.ts']).toBe('// lib.es5.d.ts content');
+        expect(result['/node_modules/typescript/lib/lib.decorators.d.ts']).toBe('// lib.decorators.d.ts content');
+        expect(result['/node_modules/typescript/lib/lib.decorators.legacy.d.ts']).toBe('// lib.decorators.legacy.d.ts content');
+        expect(result['/node_modules/typescript/lib/lib.dom.d.ts']).toBe('// lib.dom.d.ts content');
+        expect(result['/node_modules/typescript/lib/lib.dom.iterable.d.ts']).toBe('// lib.dom.iterable.d.ts content');
+    });
+    it('handles resolveLib errors gracefully', async () => {
+        const errorResolve = vi.fn(async (name) => {
+            if (name === 'decorators')
+                throw new Error('Network error');
+            return `// lib.${name}.d.ts`;
+        });
+        const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        await prefillTypescriptDefaults(mockFs, errorResolve, { target: 'es5' });
+        // Should have logged the error
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('decorators'), expect.any(Error));
+        // Other libs should still have been written
+        const es5Write = vi.mocked(mockFs.writeFile).mock.calls.find(([path]) => path === '/node_modules/typescript/lib/lib.es5.d.ts');
+        expect(es5Write).toBeTruthy();
+        consoleSpy.mockRestore();
+    });
+    it('uses custom target when specified', async () => {
+        await prefillTypescriptDefaults(mockFs, mockResolveLib, { target: 'ES2015' });
+        // Should include ES2015-specific libs
+        expect(mockResolveLib).toHaveBeenCalledWith('es2015.promise');
+        expect(mockResolveLib).toHaveBeenCalledWith('es2015.collection');
+        // Should not include ES2016+ libs
+        expect(mockResolveLib).not.toHaveBeenCalledWith('es2016');
+    });
+});