@foldkit/vite-plugin 0.20.0 → 0.20.1

package/dist/build.d.ts

@@ -1,4 +1,4 @@
-import { Schema as S } from 'effect';
+import { Schema } from 'effect';
 import nodePath from 'node:path';
 import type { Plugin } from 'vite';
 /** How a build materializes the URLs a server entry can render. */
@@ -54,25 +54,25 @@ export type FoldkitBuildOptions = Readonly<{
  * template. Reading it here is how a deployment target gets that right without
  * asking its user to configure it twice.
  */
-export declare const FoldkitBuildManifest: S.Struct<{
+export declare const FoldkitBuildManifest: Schema.Struct<{
     /**
      * The shape of this document. A consumer decodes before reading and refuses
      * a version it does not know, so a manifest written by a newer Foldkit is a
      * clear refusal rather than a field silently read as undefined.
      */
-    readonly schemaVersion: S.Literals<readonly [1]>;
+    readonly schemaVersion: Schema.Literals<readonly [1]>;
     /**
      * Where the browser build was written, as a POSIX path relative to the Vite
      * root. Relative and normalized so a manifest survives being moved with the
      * build it describes.
      */
-    readonly client: S.String;
+    readonly client: Schema.String;
     /** Where the server build was written, on the same terms as {@link client}. */
-    readonly server: S.String;
+    readonly server: Schema.String;
     /** The server build's entry file, relative to `server`. */
-    readonly serverEntry: S.String;
+    readonly serverEntry: Schema.String;
     /** Every path this build generated a page for, in the order it generated. */
-    readonly prerendered: S.$Array<S.String>;
+    readonly prerendered: Schema.$Array<Schema.String>;
 }>;
 /**
  * What the build produced, written beside the server bundle for whatever

package/dist/build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../src/build.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,IAAI,CAAC,EAAE,MAAM,QAAQ,CAAA;AAG3C,OAAO,QAAiD,MAAM,WAAW,CAAA;AAEzE,OAAO,KAAK,EAGV,MAAM,EAEP,MAAM,MAAM,CAAA;AAEb,mEAAmE;AACnE,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAC7C;;;OAGG;IACH,KAAK,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC7B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAC,CAAA;AAEF,4EAA4E;AAC5E,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IACzC;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,0CAA0C;IAC1C,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,yCAAyC;IACzC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,uBAAuB,CAAA;CAC9C,CAAC,CAAA;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;;;OAIG;;IAEH;;;;OAIG;;IAEH,+EAA+E;;IAE/E,2DAA2D;;IAE3D,6EAA6E;;EAE7E,CAAA;AAEF;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAA;AAcnE,eAAO,MAAM,YAAY,SACjB,MAAM,aACD,MAAM,YACR,OAAO,QAAQ,KACvB,MAQF,CAAA;AA2FD,eAAO,MAAM,eAAe,oBACT,MAAM,QACjB,MAAM,UACJ,MAAM,YACL,OAAO,QAAQ,KACvB,QAAQ,CAAC;IAAE,GAAG,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CA0CrC,CAAA;AA+DD;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,gBACV,MAAM,YACV,mBAAmB,KAC3B,MA8MF,CAAA"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../src/build.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAE,MAAM,QAAQ,CAAA;AAGtC,OAAO,QAAiD,MAAM,WAAW,CAAA;AAEzE,OAAO,KAAK,EAGV,MAAM,EAEP,MAAM,MAAM,CAAA;AAEb,mEAAmE;AACnE,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAC7C;;;OAGG;IACH,KAAK,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC7B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAC,CAAA;AAEF,4EAA4E;AAC5E,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IACzC;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,0CAA0C;IAC1C,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,yCAAyC;IACzC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,uBAAuB,CAAA;CAC9C,CAAC,CAAA;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;;;OAIG;;IAEH;;;;OAIG;;IAEH,+EAA+E;;IAE/E,2DAA2D;;IAE3D,6EAA6E;;EAE7E,CAAA;AAEF;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAA;AAcnE,eAAO,MAAM,YAAY,SACjB,MAAM,aACD,MAAM,YACR,OAAO,QAAQ,KACvB,MAQF,CAAA;AA2FD,eAAO,MAAM,eAAe,oBACT,MAAM,QACjB,MAAM,UACJ,MAAM,YACL,OAAO,QAAQ,KACvB,QAAQ,CAAC;IAAE,GAAG,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CA0CrC,CAAA;AA+DD;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,gBACV,MAAM,YACV,mBAAmB,KAC3B,MA8MF,CAAA"}

package/dist/build.js

@@ -1,4 +1,4 @@
-import { Array, Schema as S } from 'effect';
+import { Array, Schema } from 'effect';
 import { mkdir, writeFile } from 'node:fs/promises';
 import nodePath, { basename, dirname, extname, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
@@ -13,25 +13,25 @@ import { pathToFileURL } from 'node:url';
  * template. Reading it here is how a deployment target gets that right without
  * asking its user to configure it twice.
  */
-export const FoldkitBuildManifest = S.Struct({
+export const FoldkitBuildManifest = Schema.Struct({
     /**
      * The shape of this document. A consumer decodes before reading and refuses
      * a version it does not know, so a manifest written by a newer Foldkit is a
      * clear refusal rather than a field silently read as undefined.
      */
-    schemaVersion: S.Literals([1]),
+    schemaVersion: Schema.Literals([1]),
     /**
      * Where the browser build was written, as a POSIX path relative to the Vite
      * root. Relative and normalized so a manifest survives being moved with the
      * build it describes.
      */
-    client: S.String,
+    client: Schema.String,
     /** Where the server build was written, on the same terms as {@link client}. */
-    server: S.String,
+    server: Schema.String,
     /** The server build's entry file, relative to `server`. */
-    serverEntry: S.String,
+    serverEntry: Schema.String,
     /** Every path this build generated a page for, in the order it generated. */
-    prerendered: S.Array(S.String),
+    prerendered: Schema.Array(Schema.String),
 });
 const MANIFEST_SCHEMA_VERSION = 1;
 // Relative and POSIX so the manifest describes a layout rather than this
@@ -229,7 +229,7 @@ export const foldkitBuild = (serverEntry, options = {}) => {
         return paths;
     };
     const writeManifest = async (builder, serverDirectory, entryFileName, prerendered) => {
-        const manifest = S.encodeSync(FoldkitBuildManifest)({
+        const manifest = Schema.encodeSync(FoldkitBuildManifest)({
             schemaVersion: MANIFEST_SCHEMA_VERSION,
             client: manifestPath(builder.config.root, clientOutDir),
             server: manifestPath(builder.config.root, serverOutDir),

package/dist/devToolsOverlay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"devToolsOverlay.d.ts","sourceRoot":"","sources":["../src/devToolsOverlay.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAmGlC;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,YAC7B,OAAO,GAAG,OAAO,QACpB,MAAM,KACX,OAQF,CAAA;AAED,+EAA+E;AAC/E,eAAO,MAAM,qBAAqB,QAAO,MA6CxC,CAAA"}
+{"version":3,"file":"devToolsOverlay.d.ts","sourceRoot":"","sources":["../src/devToolsOverlay.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAsJlC;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,YAC7B,OAAO,GAAG,OAAO,QACpB,MAAM,KACX,OAQF,CAAA;AAED,+EAA+E;AAC/E,eAAO,MAAM,qBAAqB,QAAO,MA+DxC,CAAA"}

package/dist/devToolsOverlay.js

@@ -1,24 +1,40 @@
-import { Option, Record, Schema as S } from 'effect';
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { Array, Option, Record, Schema } from 'effect';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { dirname, join, resolve, sep } from 'node:path';
 const DEV_TOOLS_PACKAGE_NAME = '@foldkit/devtools';
+const FOLDKIT_PACKAGE_NAME = 'foldkit';
 const DEV_TOOLS_VITE_EXPORT = './vite';
 const DEV_TOOLS_OVERLAY_MODULE_ID = 'virtual:foldkit-devtools-overlay';
 const RESOLVED_DEV_TOOLS_OVERLAY_MODULE_ID = `\0${DEV_TOOLS_OVERLAY_MODULE_ID}`;
+const DEV_TOOLS_VITE_IMPORT_SPECIFIER = `${DEV_TOOLS_PACKAGE_NAME}${DEV_TOOLS_VITE_EXPORT.slice(1)}`;
+const DEV_TOOLS_HOST_IMPORT_SPECIFIER = 'foldkit/devtools-host';
+// NOTE: Vite's dependency scan cannot discover this virtual module's imports.
+// Declaring registry-installed imports before the first request avoids a
+// mid-session reoptimization and page reload.
+const DEV_TOOLS_OVERLAY_IMPORTS = [
+    {
+        specifier: DEV_TOOLS_VITE_IMPORT_SPECIFIER,
+        packageName: DEV_TOOLS_PACKAGE_NAME,
+    },
+    {
+        specifier: DEV_TOOLS_HOST_IMPORT_SPECIFIER,
+        packageName: FOLDKIT_PACKAGE_NAME,
+    },
+];
 const DEV_TOOLS_OVERLAY_MODULE_SOURCE = `
-import { overlay } from '@foldkit/devtools/vite'
-import { __setDevToolsOverlay } from 'foldkit/devtools-host'
+import { overlay } from '${DEV_TOOLS_VITE_IMPORT_SPECIFIER}'
+import { __setDevToolsOverlay } from '${DEV_TOOLS_HOST_IMPORT_SPECIFIER}'
 
 __setDevToolsOverlay(overlay)
 `;
-const ApplicationPackageJson = S.Struct({
-    dependencies: S.optional(S.Record(S.String, S.String)),
+const ApplicationPackageJson = Schema.Struct({
+    dependencies: Schema.optional(Schema.Record(Schema.String, Schema.String)),
 });
-const DevToolsPackageJson = S.Struct({
-    exports: S.optional(S.Record(S.String, S.Unknown)),
+const DevToolsPackageJson = Schema.Struct({
+    exports: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
 });
-const decodeApplicationPackageJson = S.decodeUnknownSync(ApplicationPackageJson);
-const decodeDevToolsPackageJson = S.decodeUnknownSync(DevToolsPackageJson);
+const decodeApplicationPackageJson = Schema.decodeUnknownSync(ApplicationPackageJson);
+const decodeDevToolsPackageJson = Schema.decodeUnknownSync(DevToolsPackageJson);
 const readPackageJson = (decode, packageJsonPath) => {
     try {
         return Option.some(decode(JSON.parse(readFileSync(packageJsonPath, 'utf8'))));
@@ -46,8 +62,9 @@ const findDirectoryUpward = (directory, isMatch) => {
 // package is installed, and `resolve.paths` appends this module's own lookup
 // chain, which under pnpm includes the hoisted virtual store. Both would make
 // the answer depend on something other than what the application installed.
-const devToolsPackageJsonPath = (directory) => join(directory, 'node_modules', DEV_TOOLS_PACKAGE_NAME, 'package.json');
-const findDevToolsPackageJsonPath = (root) => findDirectoryUpward(resolve(root), directory => existsSync(devToolsPackageJsonPath(directory))).pipe(Option.map(devToolsPackageJsonPath));
+const installedPackageJsonPath = (directory, packageName) => join(directory, 'node_modules', packageName, 'package.json');
+const findInstalledPackageJsonPath = (root, packageName) => findDirectoryUpward(resolve(root), directory => existsSync(installedPackageJsonPath(directory, packageName))).pipe(Option.map(directory => installedPackageJsonPath(directory, packageName)));
+const findDevToolsPackageJsonPath = (root) => findInstalledPackageJsonPath(root, DEV_TOOLS_PACKAGE_NAME);
 // NOTE: the virtual module imports `@foldkit/devtools/vite` statically, so an
 // installed copy that predates that export point would fail the build rather
 // than quietly skip the overlay. Injecting only when the export exists lets
@@ -58,6 +75,13 @@ const hasDevToolsViteExport = (root) => findDevToolsPackageJsonPath(root).pipe(O
 // nearest manifest keeps dependency placement meaningful for those layouts.
 const applicationPackageJsonPath = (directory) => join(directory, 'package.json');
 const findApplicationPackageJsonPath = (root) => findDirectoryUpward(resolve(root), directory => existsSync(applicationPackageJsonPath(directory))).pipe(Option.map(applicationPackageJsonPath));
+const resolvePackageDirectory = Option.liftThrowable((packageJsonPath) => realpathSync(dirname(packageJsonPath)));
+// NOTE: Vite serves linked packages from source rather than pre-bundling them.
+// A registry-installed package has a real path under `node_modules`, while a
+// workspace link resolves to its source checkout; force-including a link would
+// cache its current source and hide edits. Each owner is checked independently
+// because one package may be linked while the other is installed.
+const isPackageResolvedIntoNodeModules = (root, packageName) => findInstalledPackageJsonPath(root, packageName).pipe(Option.flatMap(resolvePackageDirectory), Option.exists(packageDirectory => packageDirectory.split(sep).includes('node_modules')));
 const isDevToolsProductionDependency = (root) => findApplicationPackageJsonPath(root).pipe(Option.flatMap(packageJsonPath => readPackageJson(decodeApplicationPackageJson, packageJsonPath)), Option.flatMapNullishOr(packageJson => packageJson.dependencies), Option.exists(Record.has(DEV_TOOLS_PACKAGE_NAME)));
 /**
  * Determines whether the Vite integration should include the DevTools overlay.
@@ -81,6 +105,18 @@ export const devToolsOverlayPlugin = () => {
     let isInjectionEnabled = false;
     return {
         name: 'foldkit:devtools-overlay',
+        config: (userConfig, environment) => {
+            const root = userConfig.root ?? process.cwd();
+            if (environment.command !== 'serve' ||
+                !shouldInjectDevToolsOverlay(environment.command, root)) {
+                return undefined;
+            }
+            const include = DEV_TOOLS_OVERLAY_IMPORTS.filter(({ packageName }) => isPackageResolvedIntoNodeModules(root, packageName)).map(({ specifier }) => specifier);
+            return Array.match(include, {
+                onEmpty: () => undefined,
+                onNonEmpty: () => ({ optimizeDeps: { include } }),
+            });
+        },
         configResolved: config => {
             isInjectionEnabled = shouldInjectDevToolsOverlay(config.command, config.root);
         },

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAmCA,OAAO,KAAK,EACV,MAAM,EAIP,MAAM,MAAM,CAAA;AAGb,OAAO,EAAE,KAAK,mBAAmB,EAAgB,MAAM,YAAY,CAAA;AAGnE,OAAO,EAAE,KAAK,iBAAiB,EAAc,MAAM,UAAU,CAAA;AAG7D,OAAO,EAAE,KAAK,eAAe,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACzE,OAAO,EACL,oBAAoB,EACpB,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,EAC5B,YAAY,GACb,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,KAAK,iBAAiB,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC7D,OAAO,EACL,KAAK,2BAA2B,EAChC,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,mBAAmB,CAAA;AAE1B,6CAA6C;AAC7C,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB;;;;;OAKG;IACH,GAAG,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,SAAS,CAAC,GACtC,QAAQ,CAAC;QACP;;;;;;;WAOG;QACH,KAAK,CAAC,EAAE,OAAO,GAAG,mBAAmB,CAAA;KACtC,CAAC,CAAA;IACJ;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAC,CAAA;AA4mBF,eAAO,MAAM,OAAO,aAAa,oBAAoB,KAAQ,KAAK,CAAC,MAAM,CAsFxE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAmCA,OAAO,KAAK,EACV,MAAM,EAIP,MAAM,MAAM,CAAA;AAGb,OAAO,EAAE,KAAK,mBAAmB,EAAgB,MAAM,YAAY,CAAA;AAGnE,OAAO,EAAE,KAAK,iBAAiB,EAAc,MAAM,UAAU,CAAA;AAG7D,OAAO,EAAE,KAAK,eAAe,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACzE,OAAO,EACL,oBAAoB,EACpB,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,EAC5B,YAAY,GACb,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,KAAK,iBAAiB,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC7D,OAAO,EACL,KAAK,2BAA2B,EAChC,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,mBAAmB,CAAA;AAE1B,6CAA6C;AAC7C,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB;;;;;OAKG;IACH,GAAG,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,SAAS,CAAC,GACtC,QAAQ,CAAC;QACP;;;;;;;WAOG;QACH,KAAK,CAAC,EAAE,OAAO,GAAG,mBAAmB,CAAA;KACtC,CAAC,CAAA;IACJ;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAC,CAAA;AA+mBF,eAAO,MAAM,OAAO,aAAa,oBAAoB,KAAQ,KAAK,CAAC,MAAM,CAsFxE,CAAA"}

package/dist/index.js

@@ -1,4 +1,4 @@
-import { Array, Console, Data, Duration, Effect, Exit, Fiber, HashMap, HashSet, Match as M, Option, Predicate, Queue, Ref, Schema as S, Schedule, Stream, pipe, } from 'effect';
+import { Array, Console, Data, Duration, Effect, Exit, Fiber, HashMap, HashSet, Match, Option, Predicate, Queue, Ref, Schedule, Schema, Stream, pipe, } from 'effect';
 import { Event as DevToolsEvent, EventFrame, RequestFrame, Response, ResponseFrame, } from 'foldkit/devtools-protocol';
 import { PreserveModelMessage, RequestModelMessage, RestoreModelMessage, } from 'foldkit/hmr-protocol';
 import { createRequire } from 'node:module';
@@ -111,9 +111,9 @@ const makeState = Effect.gen(function* () {
     };
     return state;
 });
-const encodeResponseFrameJson = S.encodeUnknownSync(S.fromJsonString(ResponseFrame));
+const encodeResponseFrameJson = Schema.encodeUnknownSync(Schema.fromJsonString(ResponseFrame));
 // HANDLERS
-const handlePreserveModelReceived = (state, payload) => Exit.match(S.decodeUnknownExit(PreserveModelMessage)(payload), {
+const handlePreserveModelReceived = (state, payload) => Exit.match(Schema.decodeUnknownExit(PreserveModelMessage)(payload), {
     onFailure: error => Console.warn('[foldkit:hmr] failed to decode preserve-model payload', error),
     onSuccess: ({ id, model, isHmrReload }) => Ref.update(state.preservedModels, current => {
         const existingFlag = Option.exists(HashMap.get(current, id), ({ isHmrReload }) => isHmrReload);
@@ -124,11 +124,11 @@ const handlePreserveModelReceived = (state, payload) => Exit.match(S.decodeUnkno
         return HashMap.set(current, id, entry);
     }),
 });
-const handleRequestModelReceived = (server, state, payload) => Exit.match(S.decodeUnknownExit(RequestModelMessage)(payload), {
+const handleRequestModelReceived = (server, state, payload) => Exit.match(Schema.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 }))));
+        const sendRestore = (model) => Effect.sync(() => server.ws.send('foldkit:restore-model', Schema.encodeUnknownSync(RestoreModelMessage)(RestoreModelMessage.make({ id, model }))));
         yield* Option.match(HashMap.get(current, id), {
             onNone: () => sendRestore(undefined),
             onSome: entry => {
@@ -142,7 +142,7 @@ const handleRequestModelReceived = (server, state, payload) => Exit.match(S.deco
     }),
 });
 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), {
+const handleBrowserEventFrameReceived = (state, data, client) => Exit.match(Schema.decodeUnknownExit(EventFrame)(data), {
     onFailure: error => Console.warn('[foldkit:devTools] failed to decode browser event frame', error),
     onSuccess: frame => DevToolsEvent.match(frame.event, {
         EventConnected: event => handleConnectedEvent(state, event, client),
@@ -175,7 +175,7 @@ const handleViteClientClosed = (state, client) => Effect.gen(function* () {
     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), {
+const handleBrowserResponseFrameReceived = (state, data) => Exit.match(Schema.decodeUnknownExit(ResponseFrame)(data), {
     onFailure: error => Console.warn('[foldkit:devTools] failed to decode browser response frame', error),
     onSuccess: frame => broadcastResponseToMcpClients(state, frame),
 });
@@ -200,9 +200,9 @@ const handleMcpClientDisconnected = (state, client) => Effect.gen(function* () {
     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), {
+const handleMcpRequestReceived = (server, state, client, raw) => Exit.match(Schema.decodeUnknownExit(Schema.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))),
+    onSuccess: frame => Match.value(frame.request).pipe(Match.tag('RequestListRuntimes', () => replyListRuntimes(state, client, frame.id)), Match.orElse(() => forwardRequestToBrowsers(server, frame))),
 });
 const replyListRuntimes = (state, client, requestId) => Effect.gen(function* () {
     const runtimes = pipe(yield* Ref.get(state.connectedRuntimes), HashMap.values, Array.fromIterable);
@@ -216,9 +216,9 @@ const replyListRuntimes = (state, client, requestId) => Effect.gen(function* ()
         }
     });
 });
-const forwardRequestToBrowsers = (server, frame) => Effect.sync(() => server.ws.send('foldkit:devTools:request', S.encodeUnknownSync(RequestFrame)(frame)));
+const forwardRequestToBrowsers = (server, frame) => Effect.sync(() => server.ws.send('foldkit:devTools:request', Schema.encodeUnknownSync(RequestFrame)(frame)));
 // EVENT DISPATCH
-const dispatchEvent = (server, state, event) => M.value(event).pipe(M.tagsExhaustive({
+const dispatchEvent = (server, state, event) => Match.value(event).pipe(Match.tagsExhaustive({
     PreserveModelReceived: ({ payload }) => handlePreserveModelReceived(state, payload),
     RequestModelReceived: ({ payload }) => handleRequestModelReceived(server, state, payload),
     BrowserEventFrameReceived: ({ data, client }) => handleBrowserEventFrameReceived(state, data, client),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foldkit/vite-plugin",
-  "version": "0.20.0",
+  "version": "0.20.1",
   "description": "Vite plugin for Foldkit hot module reloading with state preservation",
   "type": "module",
   "main": "./dist/index.js",
@@ -34,7 +34,7 @@
     "vite": "^8.2.2",
     "vite7": "npm:vite@^7.3.6",
     "vitest": "^4.1.11",
-    "foldkit": "0.155.0"
+    "foldkit": "0.157.0"
   },
   "keywords": [
     "vite",