@foldkit/vite-plugin 0.24.0 → 0.25.0-canary.9f851d747bdd

package/dist/index.js

@@ -1,16 +1,21 @@
-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 { Array, Clock, ConfigProvider, Console, Crypto, Data, Duration, Effect, Exit, Fiber, HashMap, HashSet, Layer, Match, Option, Predicate, Queue, Ref, Schedule, Schema, Stream, pipe, } from 'effect';
+import { Event as DevToolsEvent, EventFrame, RELAY_RECORD_VERSION, RequestFrame, Response, ResponseFrame, } from 'foldkit/devtools-protocol';
 import { PreserveModelMessage, RequestModelMessage, RestoreModelMessage, } from 'foldkit/model-preservation';
-import { createRequire } from 'node:module';
-import { resolve } from 'node:path';
+import { timingSafeEqual } from 'node:crypto';
+import { createServer as createHttpServer, } from 'node:http';
 import { WebSocketServer } from 'ws';
+import * as NodeCrypto from '@effect/platform-node/NodeCrypto';
+import * as NodeFileSystem from '@effect/platform-node/NodeFileSystem';
+import * as NodePath from '@effect/platform-node/NodePath';
 import { foldkitBuild } from './build.js';
 import { foldkitBuildToken } from './buildToken.js';
 import { devToolsOverlayPlugin } from './devToolsOverlay.js';
+import { resolveInstalledFoldkitPackages } from './foldkitPackages.js';
+import { publishRelayRecord, retireRelayRecord } from './relayRegistry.js';
 import { foldkitSsr } from './ssr.js';
 import { foldkitViewIdentity } from './viewIdentity.js';
 export { brandDistDirectory } from './brandDist.js';
-export { FOLDKIT_FETCH_MODULE_ID, FoldkitBuildManifest, foldkitBuild, } from './build.js';
+export { FOLDKIT_FETCH_MODULE_ID, FoldkitBuildManifest, FoldkitBuildMetadata, foldkitBuild, } from './build.js';
 export { foldkitSsr } from './ssr.js';
 export { foldkitViewIdentity, transformViewIdentity, } from './viewIdentity.js';
 // NOTE: Vite's dep optimizer scans the consumer's source for `effect`
@@ -65,37 +70,6 @@ const FORCE_INCLUDED_EFFECT_NAMESPACES = [
     'effect/SubscriptionRef',
     'effect/Types',
 ];
-// NOTE: a duplicate `foldkit` instance is its own hazard. If a bundler
-// resolves `foldkit` (or a foldkit-consuming package like `@foldkit/ui`) to
-// more than one copy, the copies get distinct Schema and tagged-message
-// identities (decode and tag matching fail across the boundary) and separate
-// module-level singleton state. `resolve.dedupe` (below) collapses every
-// installed Foldkit package to one resolved copy.
-const FOLDKIT_SINGLETON_PACKAGES = [
-    'foldkit',
-    '@foldkit/ui',
-    '@foldkit/devtools',
-];
-// NOTE: `@foldkit/ui` and `@foldkit/devtools` are optional, so dedupe only
-// the ones the consumer installed. An installed ESM package resolves to
-// ERR_PACKAGE_PATH_NOT_EXPORTED rather than succeeding, so a missing package
-// is signalled only by MODULE_NOT_FOUND.
-const resolveInstalledFoldkitPackages = (root) => {
-    // NOTE: `root` (Vite's `config.root`) can be relative at config-hook time,
-    // and createRequire requires an absolute path; `resolve` normalizes it.
-    const requireFromRoot = createRequire(resolve(root, 'noop.js'));
-    return Array.filter(FOLDKIT_SINGLETON_PACKAGES, packageName => {
-        try {
-            requireFromRoot.resolve(packageName);
-            return true;
-        }
-        catch (error) {
-            return !(error instanceof Error &&
-                Predicate.hasProperty(error, 'code') &&
-                error.code === 'MODULE_NOT_FOUND');
-        }
-    });
-};
 const Event = Data.taggedEnum();
 const makeState = Effect.gen(function* () {
     const preservedModels = yield* Ref.make(HashMap.empty());
@@ -249,18 +223,24 @@ const registerViteWsHandlers = (server, state, enqueue) => Effect.sync(() => {
     server.ws.on('foldkit:devTools:response', (data) => enqueue(Event.BrowserResponseFrameReceived({ data })));
 });
 // MCP RELAY
-// NOTE: Restarting a dev server briefly leaves two of them alive. Vite builds
-// the replacement, which binds its relay, before closing the server it
-// replaces, which still owns the port. The bind loses that race and has to
-// wait for the outgoing server to release the port, so it retries for four
-// seconds before reporting the port as taken.
+// NOTE: Vite starts a replacement server before closing the old one. A
+// configured relay port can stay occupied during the overlap, so binding
+// retries for four seconds.
 const RELAY_BIND_RETRY_DELAY = Duration.millis(100);
 const RELAY_BIND_RETRY_COUNT = 40;
+const RELAY_PATH = '/__foldkit/devtools-mcp';
+const RELAY_LOOPBACK_HOST = '127.0.0.1';
+const RELAY_CONFIGURED_PORT_HOST = 'localhost';
+const RELAY_TOKEN_PARAMETER = 'token';
+const RELAY_TOKEN_BYTES = 32;
 class RelayBindFailed extends Data.TaggedError('RelayBindFailed') {
 }
 const isPortInUse = (error) => Predicate.hasProperty(error, 'code') && error.code === 'EADDRINUSE';
-const bindMcpRelay = (port, enqueue) => Effect.callback(resume => {
-    const wss = new WebSocketServer({ port });
+const relayId = Effect.gen(function* () {
+    const crypto = yield* Crypto.Crypto;
+    return yield* crypto.randomUUIDv4.pipe(Effect.orDie);
+});
+const attachRelayHandlers = (wss, enqueue) => {
     wss.on('connection', client => {
         enqueue(Event.McpClientConnected({ client }));
         client.on('message', raw => enqueue(Event.McpRequestReceived({ client, raw: raw.toString() })));
@@ -269,45 +249,206 @@ const bindMcpRelay = (port, enqueue) => Effect.callback(resume => {
             console.error('[foldkit:devTools] MCP client error', error);
         });
     });
+};
+const parseRequestUrl = Option.liftThrowable((request) => new URL(request.url ?? '/', 'http://relay'));
+const boundPort = (address) => address === null || Predicate.isString(address)
+    ? Option.none()
+    : Option.some(address.port);
+const relayHasNoBoundPort = () => new Error('[foldkit:devTools] the MCP relay listener has no bound port');
+const relayToken = Effect.gen(function* () {
+    const crypto = yield* Crypto.Crypto;
+    const bytes = yield* crypto.randomBytes(RELAY_TOKEN_BYTES).pipe(Effect.orDie);
+    return Buffer.from(bytes).toString('hex');
+});
+const relayUrlForLog = (url) => {
+    const parsed = new URL(url);
+    parsed.search = '';
+    return parsed.toString();
+};
+const withRelayToken = (url, token) => {
+    url.search = '';
+    url.searchParams.set(RELAY_TOKEN_PARAMETER, token);
+    return url.toString();
+};
+const requestPresentsToken = (url, token) => {
+    const maybePresented = Option.fromNullishOr(url.searchParams.get(RELAY_TOKEN_PARAMETER));
+    const expected = Buffer.from(token, 'utf8');
+    return Option.exists(maybePresented, presented => {
+        const actual = Buffer.from(presented, 'utf8');
+        return (expected.length === actual.length && timingSafeEqual(expected, actual));
+    });
+};
+const refuseUpgrade = (socket) => {
+    socket.write('HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n');
+    socket.destroy();
+};
+// NOTE: Vite resolves `server.resolvedUrls` in a listener it prepends to
+// `listening`, so they are set by the time the relay's own listener runs.
+const hostedRelayUrl = (server, token) => (httpServer) => {
+    const maybeResolvedUrl = pipe(Option.fromNullishOr(server.resolvedUrls), Option.flatMap(resolvedUrls => Option.orElse(Array.head(resolvedUrls.local), () => Array.head(resolvedUrls.network))));
+    const url = new URL(pipe(maybeResolvedUrl, Option.orElse(() => Option.map(boundPort(httpServer.address()), port => `http://${RELAY_LOOPBACK_HOST}:${port}/`)), Option.getOrThrowWith(relayHasNoBoundPort)));
+    url.protocol = 'ws:';
+    url.pathname = RELAY_PATH;
+    return withRelayToken(url, token);
+};
+const loopbackRelayUrl = (token) => (httpServer) => {
+    const port = Option.getOrThrowWith(boundPort(httpServer.address()), relayHasNoBoundPort);
+    const url = new URL(`ws://${RELAY_LOOPBACK_HOST}:${port}${RELAY_PATH}`);
+    return withRelayToken(url, token);
+};
+const hostRelayOnServer = (httpServer, id, token, toUrl, enqueue) => Effect.callback(resume => {
+    const wss = new WebSocketServer({ noServer: true });
+    attachRelayHandlers(wss, enqueue);
+    const onUpgrade = (request, socket, head) => {
+        const maybeUrl = parseRequestUrl(request);
+        if (Option.isNone(maybeUrl)) {
+            socket.destroy();
+            return;
+        }
+        const url = maybeUrl.value;
+        if (url.pathname !== RELAY_PATH) {
+            return;
+        }
+        if (!requestPresentsToken(url, token)) {
+            refuseUpgrade(socket);
+            return;
+        }
+        wss.handleUpgrade(request, socket, head, client => {
+            wss.emit('connection', client, request);
+        });
+    };
+    httpServer.on('upgrade', onUpgrade);
+    const detach = () => {
+        httpServer.off('upgrade', onUpgrade);
+        httpServer.off('listening', onListening);
+    };
+    const onListening = () => {
+        resume(Effect.sync(() => ({ id, wss, url: toUrl(httpServer), detach })));
+    };
+    if (httpServer.listening) {
+        onListening();
+    }
+    else {
+        httpServer.once('listening', onListening);
+    }
+    return Effect.sync(detach);
+});
+const bindLoopbackHttpServer = Effect.callback(resume => {
+    const httpServer = createHttpServer();
+    const onBindFailed = (cause) => {
+        httpServer.close();
+        resume(Effect.fail(new RelayBindFailed({ maybePort: Option.none(), cause })));
+    };
+    httpServer.once('error', onBindFailed);
+    httpServer.listen(0, RELAY_LOOPBACK_HOST, () => {
+        httpServer.off('error', onBindFailed);
+        httpServer.on('error', error => {
+            console.error('[foldkit:devTools] MCP relay error', error);
+        });
+        resume(Effect.succeed(httpServer));
+    });
+    return Effect.sync(() => {
+        httpServer.close();
+    });
+});
+const bindLoopbackRelay = (id, token, enqueue) => Effect.gen(function* () {
+    const httpServer = yield* bindLoopbackHttpServer;
+    const relay = yield* hostRelayOnServer(httpServer, id, token, loopbackRelayUrl(token), enqueue);
+    return {
+        ...relay,
+        detach: () => {
+            relay.detach();
+            httpServer.close();
+        },
+    };
+});
+const bindStandaloneRelay = (port, id, enqueue) => Effect.callback(resume => {
+    const wss = new WebSocketServer({ port });
+    attachRelayHandlers(wss, enqueue);
     const onListening = () => {
         wss.off('error', onBindFailed);
         wss.on('error', error => {
             console.error('[foldkit:devTools] MCP relay error', error);
         });
-        console.log(`[foldkit:devTools] MCP relay listening on ws://localhost:${port}`);
-        resume(Effect.succeed(wss));
+        const listeningPort = Option.getOrThrowWith(boundPort(wss.address()), relayHasNoBoundPort);
+        resume(Effect.succeed({
+            id,
+            wss,
+            url: `ws://${RELAY_CONFIGURED_PORT_HOST}:${listeningPort}`,
+            detach: () => undefined,
+        }));
     };
     const onBindFailed = (cause) => {
         wss.off('listening', onListening);
         wss.close();
-        resume(Effect.fail(new RelayBindFailed({ cause })));
+        resume(Effect.fail(new RelayBindFailed({ maybePort: Option.some(port), cause })));
     };
     wss.once('listening', onListening);
     wss.once('error', onBindFailed);
 });
-const reportRelayBindFailed = (port, cause) => {
-    if (isPortInUse(cause)) {
-        return 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` +
-            `[foldkit:devTools] If you change \`devToolsMcpPort\`, also set \`FOLDKIT_DEVTOOLS_MCP_PORT\` to the same value for your MCP server.\n`);
+const reportRelayBindFailed = (maybePort, cause) => {
+    const where = Option.match(maybePort, {
+        onNone: () => 'an assigned loopback port',
+        onSome: port => `port ${port}`,
+    });
+    if (Option.isSome(maybePort) && isPortInUse(cause)) {
+        const port = maybePort.value;
+        return Console.error(`\n[foldkit:devTools] Port ${port} is in use; the MCP relay did not start.\n` +
+            `[foldkit:devTools] Stop the process using that port, or remove \`devToolsMcpPort\` from your Vite config to use automatic discovery.\n` +
+            `[foldkit:devTools] If you choose another fixed port, set \`FOLDKIT_DEVTOOLS_MCP_PORT\` to match.\n`);
     }
     else {
-        return Console.error(`[foldkit:devTools] MCP relay failed to start on port ${port}; continuing without the relay`, cause);
+        return Console.error(`[foldkit:devTools] MCP relay failed to start on ${where}; continuing without the relay`, cause);
     }
 };
-const startMcpRelay = (port, enqueue) => Effect.acquireRelease(bindMcpRelay(port, enqueue), wss => Effect.gen(function* () {
-    for (const client of wss.clients) {
-        client.terminate();
-    }
-    wss.close();
-    yield* Console.log('[foldkit:devTools] MCP relay stopped');
-})).pipe(Effect.retry({
-    while: ({ cause }) => isPortInUse(cause),
-    times: RELAY_BIND_RETRY_COUNT,
-    schedule: Schedule.spaced(RELAY_BIND_RETRY_DELAY),
-}), Effect.catchTag('RelayBindFailed', ({ cause }) => reportRelayBindFailed(port, cause)));
+const unpublishedRelayMessage = (reason) => `[foldkit:devTools] Cannot publish the MCP relay address: ${reason}. Set matching devToolsMcpPort and FOLDKIT_DEVTOOLS_MCP_PORT values for MCP access, or set FOLDKIT_DEVTOOLS_RELAY_DIRECTORY to a private directory on a platform that verifies ownership.`;
+const publishRelay = (root, relay) => Effect.gen(function* () {
+    const startedAt = yield* Clock.currentTimeMillis;
+    yield* publishRelayRecord({
+        version: RELAY_RECORD_VERSION,
+        id: relay.id,
+        root,
+        url: relay.url,
+        pid: process.pid,
+        startedAt,
+    });
+}).pipe(Effect.catchTag('RelayRegistryDirectoryRefused', ({ directory, reason }) => Console.error(unpublishedRelayMessage(`the registry directory ${directory} ${reason}`))), Effect.catch(error => Console.error(unpublishedRelayMessage('the registry could not be written'), error)));
+const startMcpRelay = (server, devToolsMcpPort, enqueue) => {
+    const root = server.config.root;
+    // NOTE: The MCP server cannot verify a development HTTPS certificate, so
+    // HTTPS uses a separate loopback listener.
+    const maybeHttpServer = Option.filter(Option.fromNullishOr(server.httpServer), () => server.config.server.https === undefined);
+    // NOTE: A configured port keeps the previous unauthenticated behavior.
+    // An assigned port binds only to loopback and is found through the registry.
+    const acquire = Effect.gen(function* () {
+        const id = yield* relayId;
+        if (devToolsMcpPort !== undefined) {
+            return yield* bindStandaloneRelay(devToolsMcpPort, id, enqueue);
+        }
+        const token = yield* relayToken;
+        return yield* Option.match(maybeHttpServer, {
+            onNone: () => bindLoopbackRelay(id, token, enqueue),
+            onSome: httpServer => hostRelayOnServer(httpServer, id, token, hostedRelayUrl(server, token), enqueue),
+        });
+    });
+    return Effect.acquireRelease(acquire.pipe(Effect.tap(relay => Console.log(`[foldkit:devTools] MCP relay listening at ${relayUrlForLog(relay.url)}`)), Effect.tap(relay => publishRelay(root, relay))), relay => Effect.gen(function* () {
+        relay.detach();
+        for (const client of relay.wss.clients) {
+            client.terminate();
+        }
+        relay.wss.close();
+        yield* retireRelayRecord(root, relay.id);
+        yield* Console.log('[foldkit:devTools] MCP relay stopped');
+    })).pipe(Effect.retry({
+        while: ({ cause }) => isPortInUse(cause),
+        times: RELAY_BIND_RETRY_COUNT,
+        schedule: Schedule.spaced(RELAY_BIND_RETRY_DELAY),
+    }), Effect.catchTag('RelayBindFailed', ({ maybePort, cause }) => reportRelayBindFailed(maybePort, cause)));
+};
+// NOTE: A Vitest run can override its mode, but still carries Vitest plugins.
+// Starting a relay there can contend with the project's dev server.
+const isTestRun = (server) => server.config.mode === 'test' ||
+    server.config.plugins.some(plugin => plugin.name === 'vitest' || plugin.name.startsWith('vitest:'));
 // PROGRAM
 const main = (server, events, options) => Effect.gen(function* () {
     const state = yield* makeState;
@@ -320,8 +461,8 @@ const main = (server, events, options) => Effect.gen(function* () {
     // gives up on its boot-time model request in well under a second, so
     // sequencing the dispatch loop behind the bind would cost model
     // preservation whenever the port is contended.
-    if (options.devToolsMcpPort !== undefined) {
-        yield* Effect.forkScoped(startMcpRelay(options.devToolsMcpPort, enqueue));
+    if (options.devToolsMcpPort !== false && !isTestRun(server)) {
+        yield* Effect.forkScoped(startMcpRelay(server, options.devToolsMcpPort, enqueue));
     }
     yield* Stream.fromQueue(events).pipe(Stream.runForEach(event => dispatchEvent(server, state, event)));
 });
@@ -354,42 +495,38 @@ const withContainerId = (build, containerId) => {
         prerender: { containerId, ...prerender },
     };
 };
+const relayRegistryLayer = Layer.mergeAll(NodeFileSystem.layer, NodePath.layer, NodeCrypto.layer);
 export const foldkit = (options = {}) => {
-    const events = Effect.runSync(Queue.unbounded());
-    // NOTE: One plugin instance can serve more than one dev server, and on
-    // restart Vite builds the replacement, running `configureServer` again,
-    // before closing the server being replaced. Keying by resolved config keeps
-    // each server's shutdown pointed at its own fiber.
-    const mainFibers = new WeakMap();
+    // NOTE: During a Vite restart, old and new servers overlap. Separate queues
+    // and fibers keep their events and shutdowns attached to the right server.
+    const mainRuns = new WeakMap();
     const stopMain = (config) => Effect.suspend(() => {
-        const fiber = mainFibers.get(config);
-        mainFibers.delete(config);
-        if (fiber === undefined) {
+        const run = mainRuns.get(config);
+        mainRuns.delete(config);
+        if (run === undefined) {
             return Effect.void;
         }
         else {
-            return Fiber.interrupt(fiber);
+            return Fiber.interrupt(run.fiber);
         }
     });
     const reloadPlugin = {
         name: 'foldkit',
         apply: 'serve',
-        config: userConfig => ({
+        config: () => ({
             optimizeDeps: {
                 include: [...FORCE_INCLUDED_EFFECT_NAMESPACES],
             },
-            resolve: {
-                dedupe: resolveInstalledFoldkitPackages(userConfig.root ?? process.cwd()),
-            },
         }),
         configureServer: server => {
-            const fiber = Effect.runFork(Effect.scoped(main(server, events, options)));
-            mainFibers.set(server.config, fiber);
+            const events = Effect.runSync(Queue.unbounded());
+            // NOTE: The default ConfigProvider snapshots the environment. Create a
+            // fresh one so a restarted server sees current values.
+            const fiber = Effect.runFork(Effect.scoped(main(server, events, options)).pipe(Effect.provide(relayRegistryLayer), Effect.provideService(ConfigProvider.ConfigProvider, ConfigProvider.fromEnv())));
+            mainRuns.set(server.config, { events, fiber });
         },
-        // NOTE: Vite awaits `closeBundle` when the dev server closes, once per
-        // environment plugin container. Hanging shutdown off `server.httpServer`
-        // instead would never run in middleware mode, which is how Vitest and
-        // other embedders run Vite, and the relay would outlive the server.
+        // NOTE: Middleware mode has no HTTP server to close. Vite still calls
+        // `closeBundle`, so relay cleanup belongs here.
         closeBundle() {
             return Effect.runPromise(stopMain(this.environment.getTopLevelConfig()));
         },
@@ -398,12 +535,40 @@ export const foldkit = (options = {}) => {
                 return;
             }
             server.ws.send({ type: 'full-reload' });
-            Queue.offerUnsafe(events, Event.HotUpdateFired());
+            const run = mainRuns.get(server.config);
+            if (run !== undefined) {
+                Queue.offerUnsafe(run.events, Event.HotUpdateFired());
+            }
             return [];
         },
     };
+    const resolutionPlugin = {
+        name: 'foldkit:resolution',
+        config: userConfig => {
+            const singletonPackages = resolveInstalledFoldkitPackages(userConfig.root ?? process.cwd());
+            return {
+                optimizeDeps: {
+                    exclude: ['foldkit'],
+                },
+                resolve: {
+                    dedupe: singletonPackages,
+                },
+                ssr: {
+                    noExternal: singletonPackages,
+                },
+                environments: {
+                    ssr: {
+                        resolve: {
+                            noExternal: singletonPackages,
+                        },
+                    },
+                },
+            };
+        },
+    };
     const shared = [
-        foldkitBuildToken(options.buildId),
+        resolutionPlugin,
+        ...foldkitBuildToken(options.buildId),
         foldkitViewIdentity(),
         devToolsOverlayPlugin(),
         reloadPlugin,

package/dist/relayRegistry.d.ts

@@ -0,0 +1,17 @@
+import { Crypto, Effect, FileSystem, Option, Path, type PlatformError } from 'effect';
+import { RelayRecord } from 'foldkit/devtools-protocol';
+export type RelayPublisherServices = FileSystem.FileSystem | Path.Path | Crypto.Crypto;
+declare const RelayRegistryDirectoryRefused_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "RelayRegistryDirectoryRefused";
+} & Readonly<A>;
+export declare class RelayRegistryDirectoryRefused extends RelayRegistryDirectoryRefused_base<{
+    readonly directory: string;
+    readonly reason: string;
+}> {
+}
+export declare const relayRegistryDirectoryRefusal: (info: FileSystem.File.Info, maybeCurrentUid: Option.Option<number>) => Option.Option<string>;
+export declare const publishRelayRecord: (record: RelayRecord) => Effect.Effect<void, PlatformError.PlatformError | RelayRegistryDirectoryRefused, RelayPublisherServices>;
+export declare const readRelayRecord: (root: string) => Effect.Effect<Option.Option<RelayRecord>, never, RelayPublisherServices>;
+export declare const retireRelayRecord: (root: string, id: string) => Effect.Effect<void, never, RelayPublisherServices>;
+export {};
+//# sourceMappingURL=relayRegistry.d.ts.map

package/dist/relayRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relayRegistry.d.ts","sourceRoot":"","sources":["../src/relayRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,MAAM,EAEN,MAAM,EAEN,UAAU,EACV,MAAM,EACN,IAAI,EACJ,KAAK,aAAa,EAEnB,MAAM,QAAQ,CAAA;AACf,OAAO,EAGL,WAAW,EACZ,MAAM,2BAA2B,CAAA;AAYlC,MAAM,MAAM,sBAAsB,GAC9B,UAAU,CAAC,UAAU,GACrB,IAAI,CAAC,IAAI,GACT,MAAM,CAAC,MAAM,CAAA;;;;AAEjB,qBAAa,6BAA8B,SAAQ,mCAEjD;IACA,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB,CAAC;CAAG;AA0CL,eAAO,MAAM,6BAA6B,SAClC,UAAU,CAAC,IAAI,CAAC,IAAI,mBACT,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KACrC,MAAM,CAAC,MAAM,CAAC,MAAM,CAkBnB,CAAA;AAiCJ,eAAO,MAAM,kBAAkB,WACrB,WAAW,KAClB,MAAM,CAAC,MAAM,CACd,IAAI,EACJ,aAAa,CAAC,aAAa,GAAG,6BAA6B,EAC3D,sBAAsB,CAapB,CAAA;AAWJ,eAAO,MAAM,eAAe,SACpB,MAAM,KACX,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,KAAK,EAAE,sBAAsB,CAChB,CAAA;AAE1D,eAAO,MAAM,iBAAiB,SACtB,MAAM,MACR,MAAM,KACT,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,sBAAsB,CAkChD,CAAA"}

package/dist/relayRegistry.js

@@ -0,0 +1,101 @@
+import { Config, Crypto, Data, Effect, Exit, FileSystem, Option, Path, Schema, } from 'effect';
+import { RELAY_REGISTRY_DIRECTORY_NAME, RELAY_REGISTRY_DIRECTORY_VARIABLE, RelayRecord, } from 'foldkit/devtools-protocol';
+import { tmpdir } from 'node:os';
+const RUNTIME_DIRECTORY_VARIABLE = 'XDG_RUNTIME_DIR';
+const RECORD_FILE_EXTENSION = '.json';
+const REGISTRY_DIRECTORY_MODE = 0o700;
+const RECORD_FILE_MODE = 0o600;
+const PERMISSIONS_BEYOND_OWNER = 0o077;
+const PENDING_RECORD_SUFFIX = '.pending';
+const RETIRING_RECORD_SUFFIX = '.retiring';
+export class RelayRegistryDirectoryRefused extends Data.TaggedError('RelayRegistryDirectoryRefused') {
+}
+const decodeRelayRecord = Schema.decodeUnknownOption(Schema.fromJsonString(RelayRecord));
+const encodeRelayRecord = Schema.encodeUnknownSync(Schema.fromJsonString(RelayRecord));
+const relayRegistryDirectory = Effect.gen(function* () {
+    const path = yield* Path.Path;
+    const maybeConfigured = yield* Config.option(Config.String(RELAY_REGISTRY_DIRECTORY_VARIABLE));
+    const maybeRuntimeDirectory = yield* Config.option(Config.String(RUNTIME_DIRECTORY_VARIABLE));
+    return Option.getOrElse(maybeConfigured, () => path.join(Option.getOrElse(maybeRuntimeDirectory, tmpdir), RELAY_REGISTRY_DIRECTORY_NAME));
+}).pipe(Effect.orDie);
+const relayRecordPath = (root) => Effect.gen(function* () {
+    const path = yield* Path.Path;
+    const crypto = yield* Crypto.Crypto;
+    const directory = yield* relayRegistryDirectory;
+    const digest = yield* crypto
+        .digest('SHA-1', new TextEncoder().encode(root))
+        .pipe(Effect.orDie);
+    return path.join(directory, `${Buffer.from(digest).toString('hex')}${RECORD_FILE_EXTENSION}`);
+});
+export const relayRegistryDirectoryRefusal = (info, maybeCurrentUid) => Option.match(maybeCurrentUid, {
+    onNone: () => Option.some('has ownership that cannot be verified'),
+    onSome: currentUid => {
+        if (Option.isNone(info.uid)) {
+            return Option.some('has ownership that cannot be verified');
+        }
+        if (info.uid.value !== currentUid) {
+            return Option.some('is owned by another user');
+        }
+        if ((info.mode & PERMISSIONS_BEYOND_OWNER) !== 0) {
+            return Option.some('is readable or writable by other users');
+        }
+        return Option.none();
+    },
+});
+const maybeProcessUid = Option.map(Option.fromNullishOr(process.getuid), getuid => getuid());
+const ensurePrivateRegistryDirectory = (directory) => Effect.gen(function* () {
+    const fileSystem = yield* FileSystem.FileSystem;
+    yield* fileSystem.makeDirectory(directory, {
+        recursive: true,
+        mode: REGISTRY_DIRECTORY_MODE,
+    });
+    const info = yield* fileSystem.stat(directory);
+    const maybeRefusal = relayRegistryDirectoryRefusal(info, maybeProcessUid);
+    if (Option.isSome(maybeRefusal)) {
+        return yield* Effect.fail(new RelayRegistryDirectoryRefused({
+            directory,
+            reason: maybeRefusal.value,
+        }));
+    }
+});
+export const publishRelayRecord = (record) => Effect.gen(function* () {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const directory = yield* relayRegistryDirectory;
+    yield* ensurePrivateRegistryDirectory(directory);
+    const recordPath = yield* relayRecordPath(record.root);
+    const pendingPath = `${recordPath}.${record.id}${PENDING_RECORD_SUFFIX}`;
+    yield* fileSystem.writeFileString(pendingPath, encodeRelayRecord(record), {
+        mode: RECORD_FILE_MODE,
+    });
+    yield* fileSystem.rename(pendingPath, recordPath);
+});
+const readRelayRecordAt = (recordPath) => Effect.gen(function* () {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const raw = yield* fileSystem.readFileString(recordPath);
+    return decodeRelayRecord(raw);
+}).pipe(Effect.orElseSucceed(() => Option.none()));
+export const readRelayRecord = (root) => Effect.flatMap(relayRecordPath(root), readRelayRecordAt);
+export const retireRelayRecord = (root, id) => Effect.gen(function* () {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const recordPath = yield* relayRecordPath(root);
+    const retiringPath = `${recordPath}.${id}${RETIRING_RECORD_SUFFIX}`;
+    const maybeRecord = yield* readRelayRecordAt(recordPath);
+    const isPublishedByRelay = Option.exists(maybeRecord, record => record.id === id);
+    if (!isPublishedByRelay) {
+        return;
+    }
+    // NOTE: A replacement may publish between the first read and rename. A
+    // hard link restores its record only if no newer record occupies the path.
+    const renameResult = yield* fileSystem
+        .rename(recordPath, retiringPath)
+        .pipe(Effect.exit);
+    if (Exit.isFailure(renameResult)) {
+        return;
+    }
+    const maybeRetiringRecord = yield* readRelayRecordAt(retiringPath);
+    const isReplacement = Option.exists(maybeRetiringRecord, record => record.id !== id);
+    if (isReplacement) {
+        yield* fileSystem.link(retiringPath, recordPath).pipe(Effect.ignore);
+    }
+    yield* fileSystem.remove(retiringPath, { force: true }).pipe(Effect.ignore);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foldkit/vite-plugin",
-  "version": "0.24.0",
+  "version": "0.25.0-canary.9f851d747bdd",
   "description": "Vite plugin for Foldkit with state-preserving live reload",
   "type": "module",
   "main": "./dist/index.js",
@@ -16,25 +16,28 @@
     "dist"
   ],
   "peerDependencies": {
-    "effect": "4.0.0-rc.116",
-    "foldkit": ">=0.159.0",
+    "effect": "4.0.0",
+    "foldkit": "0.164.0-canary.9f851d747bdd",
     "vite": "^8.0.0"
   },
   "dependencies": {
-    "magic-string": "^1.2.3",
+    "@effect/platform-node": "4.0.0",
+    "@effect/platform-node-shared": "4.0.0",
+    "magic-string": "^1.4.2",
     "ws": "^8.21.3"
   },
   "devDependencies": {
-    "@types/node": "^26.4.0",
+    "@types/node": "26.4.0",
     "@types/ws": "^8.18.1",
-    "effect": "4.0.0-rc.116",
-    "happy-dom": "^20.11.13",
+    "@vitejs/plugin-basic-ssl": "^2.3.0",
+    "effect": "4.0.0",
+    "happy-dom": "^20.14.5",
     "rimraf": "^6.1.3",
     "typescript": "^7.0.2",
-    "vite": "^8.2.2",
+    "vite": "^8.3.1",
     "vite-host": "npm:vite@8.2.1",
     "vitest": "^4.1.11",
-    "foldkit": "0.163.0"
+    "foldkit": "0.164.0-canary.9f851d747bdd"
   },
   "keywords": [
     "vite",