@joinezco/codeblock 0.0.8 → 0.0.10

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');
+    });
+});

package/dist/workers/fs.worker.d.ts

@@ -1,11 +1,7 @@
-import { MountArgs, MountResult } from "../types";
-export declare const mount: ({ buffer, mountPoint }: MountArgs) => Promise<MountResult>;
-/**
- * Optimized mount function that loads snapshots directly from URLs.
- * This is much more efficient for large snapshots as it avoids transferring
- * data through the main thread.
- */
+import * as Comlink from "comlink";
+import { MountArgs } from "../types";
+export declare const mount: ({ buffer, mountPoint }: MountArgs) => Promise<import("..").VfsInterface & Comlink.ProxyMarked>;
 export declare const mountFromUrl: ({ url, mountPoint }: {
     url: string;
     mountPoint?: string;
-}) => Promise<MountResult>;
+}) => Promise<import("..").VfsInterface & Comlink.ProxyMarked>;

package/dist/workers/fs.worker.js

@@ -1,93 +1,63 @@
 import * as Comlink from "comlink";
 import { watchOptionsTransferHandler, asyncGeneratorTransferHandler } from '../rpc/serde';
 import { Snapshot } from "../utils";
+import { fs } from '@joinezco/memfs';
+import { Vfs } from "../utils/fs";
 Comlink.transferHandlers.set('asyncGenerator', asyncGeneratorTransferHandler);
 Comlink.transferHandlers.set('watchOptions', watchOptionsTransferHandler);
 let filesystems = [];
+// Create VfsInterface directly in the worker so all memfs calls are local (no nested Comlink proxies)
+function createWorkerVfs() {
+    return Vfs.fromMemfs(fs);
+}
 export const mount = async ({ buffer, mountPoint = '/' }) => {
-    let filesystem;
     try {
-        console.log('Importing memfs after FS mount...');
-        const { fs } = await import('@joinezco/memfs');
-        console.log("FS imported");
-        try {
-            if (buffer) {
-                console.log(`Mounting filesystem snapshot at [${mountPoint}]...`, buffer);
-                // Convert Node Buffer to ArrayBuffer if needed
-                const uint8 = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-                const aligned = uint8.byteOffset === 0 && uint8.byteLength === uint8.buffer.byteLength
-                    ? uint8.buffer
-                    : uint8.buffer.slice(uint8.byteOffset, uint8.byteOffset + uint8.byteLength);
-                console.log('Aligned ArrayBuffer:', aligned);
-                await Snapshot.mount(new Uint8Array(aligned), {
-                    // @ts-ignore
-                    fs,
-                });
-            }
-            else {
-                console.log('Getting storage directory...');
-                // const handle = await navigator.storage.getDirectory();
-                console.log('Got storage directory');
-                console.log('Attempting to remove directory...');
-                try {
-                    // TODO: clear storage button
-                    // @ts-ignore
-                    // await handle.remove({ recursive: true });
-                    console.log('Successfully removed directory');
-                }
-                catch (removeErr) {
-                    console.error('Error removing directory:', removeErr);
-                    // Continue anyway, this might not be critical
-                }
-            }
-            console.log('Returning proxy from worker', fs);
-            filesystem = Comlink.proxy({ fs });
-            filesystems.push(filesystem);
-        }
-        catch (e) {
-            console.error('Worker initialization failed with error:', e);
-            throw e; // Make sure error propagates
+        if (buffer) {
+            console.debug(`Mounting filesystem snapshot at [${mountPoint}]...`, buffer);
+            const uint8 = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+            const aligned = uint8.byteOffset === 0 && uint8.byteLength === uint8.buffer.byteLength
+                ? uint8.buffer
+                : uint8.buffer.slice(uint8.byteOffset, uint8.byteOffset + uint8.byteLength);
+            await Snapshot.mount(new Uint8Array(aligned), {
+                // @ts-ignore
+                fs,
+            });
         }
     }
     catch (e) {
-        console.error('Error importing memfs:', e);
+        console.error('Worker initialization failed:', e);
+        throw e;
     }
-    console.log('mounting fs', { buffer, mountPoint });
-    return filesystem;
+    const vfs = createWorkerVfs();
+    const proxy = Comlink.proxy(vfs);
+    filesystems.push(proxy);
+    return proxy;
 };
-/**
- * Optimized mount function that loads snapshots directly from URLs.
- * This is much more efficient for large snapshots as it avoids transferring
- * data through the main thread.
- */
 export const mountFromUrl = async ({ url, mountPoint = '/' }) => {
-    let filesystem;
     try {
-        const { fs } = await import('@joinezco/memfs');
-        console.log(`Loading and mounting filesystem snapshot from URL: ${url} at [${mountPoint}]...`);
+        console.debug(`Loading snapshot from URL: ${url} at [${mountPoint}]...`);
         const startTime = performance.now();
         await Snapshot.loadAndMount(url, {
             // @ts-ignore
             fs,
             path: mountPoint
         });
-        const endTime = performance.now();
-        console.log(`Snapshot loaded and mounted in ${Math.round(endTime - startTime)}ms`);
-        console.log('Returning proxy from worker', fs);
-        filesystem = Comlink.proxy({ fs });
-        filesystems.push(filesystem);
+        console.debug(`Snapshot mounted in ${Math.round(performance.now() - startTime)}ms`);
     }
     catch (e) {
         console.error('Error loading snapshot from URL:', e);
         throw e;
     }
-    return filesystem;
+    const vfs = createWorkerVfs();
+    const proxy = Comlink.proxy(vfs);
+    filesystems.push(proxy);
+    return proxy;
 };
 onconnect = async function (event) {
     const [port] = event.ports;
-    console.log('workers/fs connected on port: ', port);
+    console.debug('workers/fs connected on port: ', port);
     port.addEventListener('close', () => {
-        console.log('fs port closed');
+        console.debug('fs port closed');
     });
     Comlink.expose({ mount, mountFromUrl }, port);
 };

package/dist/workers/javascript.worker.js

@@ -2,19 +2,21 @@ import * as Comlink from 'comlink';
 import { createLanguageServer } from '../lsps/typescript';
 import { createConnection } from 'vscode-languageserver/browser';
 import { BrowserMessageReader, BrowserMessageWriter } from '@volar/language-server/browser';
-// TODO: get rid of this
-// instead, create language specific workers (with a smarter client)
-// i.e typescript.worker.ts / rust.worker.ts / ...
 onconnect = async (event) => {
     const [port] = event.ports;
-    console.debug('LSP worker connected on port: ', port);
-    const reader = new BrowserMessageReader(port);
-    const writer = new BrowserMessageWriter(port);
+    // Use a MessageChannel to separate Comlink RPC from LSP protocol.
+    // Both Comlink and BrowserMessageReader listen on the same port's
+    // 'message' event, so Comlink messages get misinterpreted as LSP messages.
+    const { port1: lspPort, port2: clientLspPort } = new MessageChannel();
+    lspPort.start();
+    const reader = new BrowserMessageReader(lspPort);
+    const writer = new BrowserMessageWriter(lspPort);
     const connection = createConnection(reader, writer);
     connection.listen();
-    const proxy = async ({ fs }) => {
-        console.log('creating language server');
-        await createLanguageServer({ fs, connection });
+    const proxy = async (fsProxy, libFiles) => {
+        await createLanguageServer({ fs: fsProxy, connection, libFiles });
+        // Return the LSP port for the client to use (separate from Comlink port)
+        return Comlink.transfer(clientLspPort, [clientLspPort]);
     };
     Comlink.expose({ createLanguageServer: proxy }, port);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joinezco/codeblock",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "type": "module",
   "module": "dist/index.js",
   "main": "dist/index.js",
@@ -26,6 +26,7 @@
     "@types/sharedworker": "^0.0.181",
     "multimatch": "^7.0.0",
     "process": "^0.11.10",
+    "puppeteer-core": "^24.37.5",
     "tsx": "^4.19.4",
     "vite": "^7.0.6",
     "vitest": "^3.2.4"
@@ -58,7 +59,7 @@
     "@jsonjoy.com/json-pack": "^1.2.0",
     "@jsonjoy.com/util": "^1.6.0",
     "@lezer/highlight": "^1.2.1",
-    "@open-rpc/client-js": "^1.8.1",
+    "@m234/nerd-fonts": "^0.5.0",
     "@typescript/vfs": "^1.6.1",
     "@uiw/codemirror-theme-vscode": "^4.23.12",
     "@volar/language-server": "2.4.13",
@@ -66,6 +67,7 @@
     "@volar/typescript": "2.4.13",
     "comlink": "^4.4.2",
     "events": "^3.3.0",
+    "ghostty-web": "^0.4.0",
     "ignore": "^7.0.4",
     "lodash": "^4.17.21",
     "lz-string": "^1.5.0",
@@ -82,7 +84,7 @@
     "vscode-languageserver-protocol": "^3.17.5",
     "vscode-languageserver-textdocument": "^1.0.12",
     "vscode-uri": "^3.1.0",
-    "@marimo-team/codemirror-languageserver": "1.16.0",
+    "@codemirror/lsp-client": "6.2.2",
     "@joinezco/jswasi": "0.0.1",
     "@joinezco/memfs": "4.23.0"
   },
@@ -90,6 +92,8 @@
     "dev": "vite",
     "build": "tsc",
     "build:preview": "vite build",
-    "preview": "vite preview"
+    "preview": "vite preview",
+    "test": "vitest run src/e2e/",
+    "test:e2e": "vitest run src/e2e/"
   }
 }