@foldkit/vite-plugin 0.3.1 → 0.4.0

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,MAAM,EAAkC,MAAM,MAAM,CAAA;AAGlE,6CAA6C;AAC7C,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAAC,CAAA;AAqBF,eAAO,MAAM,OAAO,GAAI,UAAS,oBAAyB,KAAG,MAO5D,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA+BA,OAAO,KAAK,EAAE,MAAM,EAAkC,MAAM,MAAM,CAAA;AAGlE,6CAA6C;AAC7C,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAAC,CAAA;AAofF,eAAO,MAAM,OAAO,GAAI,UAAS,oBAAyB,KAAG,MAgC5D,CAAA"}

package/dist/index.js

@@ -1,174 +1,268 @@
-import { Array, Effect, Either, HashMap, HashSet, Match, Option, Ref, Schema as S, pipe, } from 'effect';
+import { Array, Console, Data, Effect, Exit, Fiber, HashMap, HashSet, Match as M, Option, Queue, Ref, Schema as S, Stream, pipe, } from 'effect';
 import { EventFrame, RequestFrame, ResponseFrame, ResponseRuntimes, } from 'foldkit/devtools-protocol';
+import { PreserveModelMessage, RequestModelMessage, RestoreModelMessage, } from 'foldkit/hmr-protocol';
 import { WebSocketServer } from 'ws';
-let preservedModel = undefined;
-let isHmrReload = false;
-const connectedRuntimesRef = Ref.unsafeMake(HashMap.empty());
-const mcpClientsRef = Ref.unsafeMake(HashSet.empty());
-const clientConnectionsRef = Ref.unsafeMake(HashMap.empty());
-const trackedClientsRef = Ref.unsafeMake(HashSet.empty());
-let viteServer = null;
-let mcpWebSocketServer = null;
-export const foldkit = (options = {}) => {
-    return {
-        name: 'foldkit-hmr',
-        apply: 'serve',
-        configureServer: server => configureServer(server, options),
-        handleHotUpdate,
+// NOTE: Vite's dep optimizer scans the consumer's source for `effect`
+// imports and pre-bundles only those exports into a single `effect.js`
+// blob. It does not follow imports through workspace/node_modules
+// packages, so any `effect` namespace foldkit's compiled dist references
+// that the consumer does not mention by name is missing from the blob
+// and crashes at runtime in dev. The list below covers every top-level
+// namespace foldkit imports from bare `'effect'`. Over-inclusion is
+// harmless; under-inclusion is the bug. Kept in sync with foldkit's
+// source by `scripts/check-effect-prebundle.ts` (runs in `pnpm check`).
+const FORCE_INCLUDED_EFFECT_NAMESPACES = [
+    'effect/Array',
+    'effect/Cause',
+    'effect/Clock',
+    'effect/Context',
+    'effect/Data',
+    'effect/DateTime',
+    'effect/Duration',
+    'effect/Effect',
+    'effect/Equal',
+    'effect/Equivalence',
+    'effect/Exit',
+    'effect/Fiber',
+    'effect/Function',
+    'effect/Hash',
+    'effect/HashMap',
+    'effect/HashSet',
+    'effect/Layer',
+    'effect/Match',
+    'effect/Number',
+    'effect/Option',
+    'effect/Order',
+    'effect/Predicate',
+    'effect/PubSub',
+    'effect/Queue',
+    'effect/Record',
+    'effect/Ref',
+    'effect/Result',
+    'effect/Scheduler',
+    'effect/Schema',
+    'effect/SchemaIssue',
+    'effect/SchemaTransformation',
+    'effect/Stream',
+    'effect/String',
+    'effect/Struct',
+    'effect/SubscriptionRef',
+    'effect/Types',
+];
+const Event = Data.taggedEnum();
+const makeState = Effect.gen(function* () {
+    const preservedModels = yield* Ref.make(HashMap.empty());
+    const connectedRuntimes = yield* Ref.make(HashMap.empty());
+    const mcpClients = yield* Ref.make(HashSet.empty());
+    const clientConnections = yield* Ref.make(HashMap.empty());
+    const trackedClients = yield* Ref.make(HashSet.empty());
+    const state = {
+        preservedModels,
+        connectedRuntimes,
+        mcpClients,
+        clientConnections,
+        trackedClients,
     };
-};
-const configureServer = (server, options) => {
-    viteServer = server;
-    server.ws.on('foldkit:preserve-model', model => {
-        preservedModel = model;
+    return state;
+});
+const encodeResponseFrameJson = S.encodeUnknownSync(S.fromJsonString(ResponseFrame));
+// HANDLERS
+const handlePreserveModelReceived = (state, payload) => Exit.match(S.decodeUnknownExit(PreserveModelMessage)(payload), {
+    onFailure: error => Console.warn('[foldkit:hmr] failed to decode preserve-model payload', error),
+    onSuccess: ({ id, model }) => {
+        const entry = { model, isHmrReload: false };
+        return Ref.update(state.preservedModels, HashMap.set(id, entry));
+    },
+});
+const handleRequestModelReceived = (server, state, payload) => Exit.match(S.decodeUnknownExit(RequestModelMessage)(payload), {
+    onFailure: error => Console.warn('[foldkit:hmr] failed to decode request-model payload', error),
+    onSuccess: ({ id }) => Effect.gen(function* () {
+        const current = yield* Ref.get(state.preservedModels);
+        const sendRestore = (model) => Effect.sync(() => server.ws.send('foldkit:restore-model', S.encodeUnknownSync(RestoreModelMessage)(RestoreModelMessage.make({ id, model }))));
+        yield* Option.match(HashMap.get(current, id), {
+            onNone: () => sendRestore(undefined),
+            onSome: entry => {
+                if (entry.isHmrReload) {
+                    const served = { ...entry, isHmrReload: false };
+                    return Ref.update(state.preservedModels, HashMap.set(id, served)).pipe(Effect.flatMap(() => sendRestore(entry.model)));
+                }
+                return Ref.update(state.preservedModels, HashMap.remove(id)).pipe(Effect.flatMap(() => sendRestore(undefined)));
+            },
+        });
+    }),
+});
+const handleHotUpdateFired = (state) => Ref.update(state.preservedModels, current => HashMap.map(current, entry => ({ ...entry, isHmrReload: true })));
+const handleBrowserEventFrameReceived = (state, data, client) => Exit.match(S.decodeUnknownExit(EventFrame)(data), {
+    onFailure: error => Console.warn('[foldkit:devTools] failed to decode browser event frame', error),
+    onSuccess: frame => M.value(frame.event).pipe(M.tagsExhaustive({
+        EventConnected: event => handleConnectedEvent(state, event, client),
+        EventDisconnected: event => handleDisconnectedEvent(state, event),
+    })),
+});
+const handleConnectedEvent = (state, event, client) => Effect.gen(function* () {
+    yield* Ref.update(state.connectedRuntimes, HashMap.set(event.runtime.connectionId, event.runtime));
+    yield* Ref.update(state.clientConnections, currentMap => {
+        const existing = HashMap.get(currentMap, client).pipe(Option.getOrElse(() => HashSet.empty()));
+        return HashMap.set(currentMap, client, HashSet.add(existing, event.runtime.connectionId));
     });
-    server.ws.on('foldkit:request-model', () => {
-        server.ws.send('foldkit:restore-model', isHmrReload ? preservedModel : undefined);
-        if (!isHmrReload) {
-            preservedModel = undefined;
-        }
-        isHmrReload = false;
+    yield* Console.log(`[foldkit:devTools] runtime connected: ${event.runtime.connectionId} (${event.runtime.title})`);
+});
+const handleDisconnectedEvent = (state, event) => Effect.gen(function* () {
+    yield* Ref.update(state.connectedRuntimes, HashMap.remove(event.connectionId));
+    yield* Console.log(`[foldkit:devTools] runtime disconnected: ${event.connectionId}`);
+});
+const pruneRuntime = (state, connectionId) => Effect.gen(function* () {
+    yield* Ref.update(state.connectedRuntimes, HashMap.remove(connectionId));
+    yield* Console.log(`[foldkit:devTools] runtime pruned (socket close): ${connectionId}`);
+});
+const pruneRuntimesForClient = (state, connectionIds) => Effect.forEach(Array.fromIterable(connectionIds), connectionId => pruneRuntime(state, connectionId), { discard: true });
+const handleViteClientClosed = (state, client) => Effect.gen(function* () {
+    const connections = yield* Ref.get(state.clientConnections);
+    yield* Option.match(HashMap.get(connections, client), {
+        onNone: () => Effect.void,
+        onSome: connectionIds => pruneRuntimesForClient(state, connectionIds),
     });
-    server.ws.on('foldkit:devTools:event', (data, client) => {
-        ensureClientTracked(client);
-        handleBrowserEventFrame(data, client);
+    yield* Ref.update(state.clientConnections, HashMap.remove(client));
+    yield* Ref.update(state.trackedClients, HashSet.remove(client));
+});
+const handleBrowserResponseFrameReceived = (state, data) => Exit.match(S.decodeUnknownExit(ResponseFrame)(data), {
+    onFailure: error => Console.warn('[foldkit:devTools] failed to decode browser response frame', error),
+    onSuccess: frame => broadcastResponseToMcpClients(state, frame),
+});
+const broadcastResponseToMcpClients = (state, frame) => Effect.gen(function* () {
+    const clients = yield* Ref.get(state.mcpClients);
+    const payload = encodeResponseFrameJson(frame);
+    yield* Effect.sync(() => {
+        for (const client of clients) {
+            if (client.readyState === client.OPEN) {
+                client.send(payload);
+            }
+        }
     });
-    server.ws.on('foldkit:devTools:response', (data) => {
-        handleBrowserResponseFrame(data);
+});
+const handleMcpClientConnected = (state, client) => Effect.gen(function* () {
+    yield* Ref.update(state.mcpClients, HashSet.add(client));
+    const total = HashSet.size(yield* Ref.get(state.mcpClients));
+    yield* Console.log(`[foldkit:devTools] MCP client connected (${total} total)`);
+});
+const handleMcpClientDisconnected = (state, client) => Effect.gen(function* () {
+    yield* Ref.update(state.mcpClients, HashSet.remove(client));
+    const remaining = HashSet.size(yield* Ref.get(state.mcpClients));
+    yield* Console.log(`[foldkit:devTools] MCP client disconnected (${remaining} remaining)`);
+});
+const handleMcpRequestReceived = (server, state, client, raw) => Exit.match(S.decodeUnknownExit(S.fromJsonString(RequestFrame))(raw), {
+    onFailure: error => Console.warn('[foldkit:devTools] failed to decode MCP request frame', error),
+    onSuccess: frame => M.value(frame.request).pipe(M.tag('RequestListRuntimes', () => replyListRuntimes(state, client, frame.id)), M.orElse(() => forwardRequestToBrowsers(server, frame))),
+});
+const replyListRuntimes = (state, client, requestId) => Effect.gen(function* () {
+    const runtimes = pipe(yield* Ref.get(state.connectedRuntimes), HashMap.values, Array.fromIterable);
+    const responseFrame = {
+        id: requestId,
+        response: ResponseRuntimes({ runtimes }),
+    };
+    yield* Effect.sync(() => {
+        if (client.readyState === client.OPEN) {
+            client.send(encodeResponseFrameJson(responseFrame));
+        }
     });
-    if (options.devToolsMcpPort !== undefined) {
-        startMcpWebSocketServer(options.devToolsMcpPort);
-        server.httpServer?.on('close', stopMcpWebSocketServer);
+});
+const forwardRequestToBrowsers = (server, frame) => Effect.sync(() => server.ws.send('foldkit:devTools:request', S.encodeUnknownSync(RequestFrame)(frame)));
+// EVENT DISPATCH
+const dispatchEvent = (server, state, event) => M.value(event).pipe(M.tagsExhaustive({
+    PreserveModelReceived: ({ payload }) => handlePreserveModelReceived(state, payload),
+    RequestModelReceived: ({ payload }) => handleRequestModelReceived(server, state, payload),
+    BrowserEventFrameReceived: ({ data, client }) => handleBrowserEventFrameReceived(state, data, client),
+    BrowserResponseFrameReceived: ({ data }) => handleBrowserResponseFrameReceived(state, data),
+    ViteClientClosed: ({ client }) => handleViteClientClosed(state, client),
+    HotUpdateFired: () => handleHotUpdateFired(state),
+    McpClientConnected: ({ client }) => handleMcpClientConnected(state, client),
+    McpClientDisconnected: ({ client }) => handleMcpClientDisconnected(state, client),
+    McpRequestReceived: ({ client, raw }) => handleMcpRequestReceived(server, state, client, raw),
+}));
+// VITE WS BRIDGE
+const ensureClientTracked = (state, client, enqueue) => Effect.gen(function* () {
+    const tracked = yield* Ref.get(state.trackedClients);
+    if (HashSet.has(tracked, client)) {
+        return;
     }
-};
-const startMcpWebSocketServer = (port) => {
+    yield* Ref.update(state.trackedClients, HashSet.add(client));
+    yield* Effect.sync(() => client.socket.on('close', () => enqueue(Event.ViteClientClosed({ client }))));
+});
+const registerViteWsHandlers = (server, state, enqueue) => Effect.sync(() => {
+    server.ws.on('foldkit:preserve-model', payload => enqueue(Event.PreserveModelReceived({ payload })));
+    server.ws.on('foldkit:request-model', payload => enqueue(Event.RequestModelReceived({ payload })));
+    server.ws.on('foldkit:devTools:event', (data, client) => {
+        Effect.runFork(ensureClientTracked(state, client, enqueue));
+        enqueue(Event.BrowserEventFrameReceived({ data, client }));
+    });
+    server.ws.on('foldkit:devTools:response', (data) => enqueue(Event.BrowserResponseFrameReceived({ data })));
+});
+// MCP RELAY
+const startMcpRelay = (port, enqueue) => Effect.acquireRelease(Effect.sync(() => {
     const wss = new WebSocketServer({ port });
-    mcpWebSocketServer = wss;
     wss.on('error', error => {
-        console.error(`[foldkit:devTools] MCP relay failed to start on port ${port}; continuing without the relay`, error);
-        mcpWebSocketServer = null;
+        if ('code' in error && error.code === 'EADDRINUSE') {
+            console.error(`\n[foldkit:devTools] Port ${port} is already in use, so the DevTools MCP relay could not start.\n` +
+                `[foldkit:devTools] This usually means another Foldkit project is already running and bound to this port.\n` +
+                `[foldkit:devTools] Until the port is freed, agents will not be able to connect to this app via the Foldkit DevTools MCP server.\n` +
+                `[foldkit:devTools] Stop the other project, or set a different \`devToolsMcpPort\` in this project's vite config.\n`);
+        }
+        else {
+            console.error(`[foldkit:devTools] MCP relay failed to start on port ${port}; continuing without the relay`, error);
+        }
     });
     wss.on('connection', client => {
-        Effect.runSync(Ref.update(mcpClientsRef, HashSet.add(client)));
-        const total = HashSet.size(Effect.runSync(Ref.get(mcpClientsRef)));
-        console.log(`[foldkit:devTools] MCP client connected (${total} total)`);
-        client.on('message', raw => {
-            handleMcpMessage(client, raw.toString());
-        });
-        client.on('close', () => {
-            Effect.runSync(Ref.update(mcpClientsRef, HashSet.remove(client)));
-            const remaining = HashSet.size(Effect.runSync(Ref.get(mcpClientsRef)));
-            console.log(`[foldkit:devTools] MCP client disconnected (${remaining} remaining)`);
-        });
+        enqueue(Event.McpClientConnected({ client }));
+        client.on('message', raw => enqueue(Event.McpRequestReceived({ client, raw: raw.toString() })));
+        client.on('close', () => enqueue(Event.McpClientDisconnected({ client })));
         client.on('error', error => {
             console.error('[foldkit:devTools] MCP client error', error);
         });
     });
-    console.log(`[foldkit:devTools] MCP relay listening on ws://localhost:${port}`);
-};
-const stopMcpWebSocketServer = () => {
-    const clients = Effect.runSync(Ref.get(mcpClientsRef));
-    HashSet.forEach(clients, client => {
-        client.close();
+    wss.on('listening', () => {
+        console.log(`[foldkit:devTools] MCP relay listening on ws://localhost:${port}`);
     });
-    Effect.runSync(Ref.set(mcpClientsRef, HashSet.empty()));
-    mcpWebSocketServer?.close();
-    mcpWebSocketServer = null;
+    return wss;
+}), wss => Effect.sync(() => {
+    wss.close();
     console.log('[foldkit:devTools] MCP relay stopped');
-};
-const handleBrowserEventFrame = (data, client) => {
-    const decoded = S.decodeUnknownEither(EventFrame)(data);
-    Either.match(decoded, {
-        onLeft: error => {
-            console.warn('[foldkit:devTools] failed to decode browser event frame', error);
-        },
-        onRight: frame => Match.value(frame.event).pipe(Match.tagsExhaustive({
-            EventConnected: event => handleConnectedEvent(event, client),
-            EventDisconnected: handleDisconnectedEvent,
-        })),
-    });
-};
-const ensureClientTracked = (client) => {
-    const tracked = Effect.runSync(Ref.get(trackedClientsRef));
-    if (HashSet.has(tracked, client)) {
-        return;
+}));
+// PROGRAM
+const main = (server, events, options) => Effect.gen(function* () {
+    const state = yield* makeState;
+    const enqueue = (event) => {
+        Queue.offerUnsafe(events, event);
+    };
+    yield* registerViteWsHandlers(server, state, enqueue);
+    if (options.devToolsMcpPort !== undefined) {
+        yield* startMcpRelay(options.devToolsMcpPort, enqueue);
     }
-    Effect.runSync(Ref.update(trackedClientsRef, HashSet.add(client)));
-    client.socket.on('close', () => handleClientClose(client));
-};
-const handleClientClose = (client) => {
-    pipe(Effect.runSync(Ref.get(clientConnectionsRef)), HashMap.get(client), Option.match({
-        onNone: () => { },
-        onSome: connectionIds => HashSet.forEach(connectionIds, connectionId => {
-            Effect.runSync(Ref.update(connectedRuntimesRef, HashMap.remove(connectionId)));
-            console.log(`[foldkit:devTools] runtime pruned (socket close): ${connectionId}`);
+    yield* Stream.fromQueue(events).pipe(Stream.runForEach(event => dispatchEvent(server, state, event)));
+});
+// PLUGIN ENTRY
+export const foldkit = (options = {}) => {
+    const events = Effect.runSync(Queue.unbounded());
+    return {
+        name: 'foldkit-hmr',
+        apply: 'serve',
+        config: () => ({
+            optimizeDeps: {
+                include: [...FORCE_INCLUDED_EFFECT_NAMESPACES],
+            },
         }),
-    }));
-    Effect.runSync(Ref.update(clientConnectionsRef, HashMap.remove(client)));
-    Effect.runSync(Ref.update(trackedClientsRef, HashSet.remove(client)));
-};
-const handleBrowserResponseFrame = (data) => {
-    const decoded = S.decodeUnknownEither(ResponseFrame)(data);
-    Either.match(decoded, {
-        onLeft: error => {
-            console.warn('[foldkit:devTools] failed to decode browser response frame', error);
+        configureServer: server => {
+            const fiber = Effect.runFork(Effect.scoped(main(server, events, options)));
+            server.httpServer?.on('close', () => {
+                Effect.runFork(Fiber.interrupt(fiber));
+            });
         },
-        onRight: forwardResponseToMcpClients,
-    });
-};
-const handleConnectedEvent = (event, client) => {
-    Effect.runSync(Ref.update(connectedRuntimesRef, HashMap.set(event.runtime.connectionId, event.runtime)));
-    Effect.runSync(Ref.update(clientConnectionsRef, currentMap => {
-        const existing = pipe(HashMap.get(currentMap, client), Option.getOrElse(() => HashSet.empty()));
-        return HashMap.set(currentMap, client, HashSet.add(existing, event.runtime.connectionId));
-    }));
-    console.log(`[foldkit:devTools] runtime connected: ${event.runtime.connectionId} (${event.runtime.title})`);
-};
-const handleDisconnectedEvent = (event) => {
-    Effect.runSync(Ref.update(connectedRuntimesRef, HashMap.remove(event.connectionId)));
-    console.log(`[foldkit:devTools] runtime disconnected: ${event.connectionId}`);
-};
-const broadcastToMcpClients = (payload) => {
-    const clients = Effect.runSync(Ref.get(mcpClientsRef));
-    HashSet.forEach(clients, client => {
-        if (client.readyState === client.OPEN) {
-            client.send(payload);
-        }
-    });
-};
-const forwardResponseToMcpClients = (responseFrame) => {
-    broadcastToMcpClients(JSON.stringify(responseFrame));
-};
-const handleMcpMessage = (client, raw) => {
-    const decoded = S.decodeUnknownEither(S.parseJson(RequestFrame))(raw);
-    Either.match(decoded, {
-        onLeft: error => {
-            console.warn('[foldkit:devTools] failed to decode MCP request frame', error);
+        handleHotUpdate: ({ server, modules, }) => {
+            if (modules.length === 0) {
+                return;
+            }
+            server.ws.send({ type: 'full-reload' });
+            Queue.offerUnsafe(events, Event.HotUpdateFired());
+            return [];
         },
-        onRight: frame => Match.value(frame.request).pipe(Match.tag('RequestListRuntimes', () => replyListRuntimes(client, frame.id)), Match.orElse(() => forwardRequestToBrowsers(frame))),
-    });
-};
-const replyListRuntimes = (client, requestId) => {
-    const runtimes = pipe(Effect.runSync(Ref.get(connectedRuntimesRef)), HashMap.values, Array.fromIterable);
-    const responseFrame = {
-        id: requestId,
-        response: ResponseRuntimes({ runtimes }),
     };
-    if (client.readyState === client.OPEN) {
-        client.send(JSON.stringify(responseFrame));
-    }
-};
-const forwardRequestToBrowsers = (frame) => {
-    if (viteServer === null) {
-        return;
-    }
-    viteServer.ws.send('foldkit:devTools:request', frame);
-};
-const handleHotUpdate = ({ server, modules, }) => {
-    if (modules.length === 0) {
-        return;
-    }
-    isHmrReload = true;
-    server.ws.send({ type: 'full-reload' });
-    return [];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foldkit/vite-plugin",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Vite plugin for Foldkit hot module reloading with state preservation",
   "type": "module",
   "main": "./dist/index.js",
@@ -16,7 +16,7 @@
     "dist"
   ],
   "peerDependencies": {
-    "effect": "^3.18.2",
+    "effect": "4.0.0-beta.59",
     "foldkit": "^0",
     "vite": "^7.0.0"
   },
@@ -25,10 +25,10 @@
   },
   "devDependencies": {
     "@types/ws": "^8.5.13",
-    "effect": "^3.19.19",
+    "effect": "4.0.0-beta.59",
     "typescript": "^6.0.2",
     "vite": "^7.3.1",
-    "foldkit": "0.76.1"
+    "foldkit": "0.82.0"
   },
   "keywords": [
     "vite",