@nuxt/vite-builder-nightly 4.3.0-29465977.c4f46c64 → 4.3.0-29466372.7f503428

package/dist/vite-node.mjs

@@ -1,16 +1,17 @@
-import process from 'node:process';
-import net from 'node:net';
-import { Buffer } from 'node:buffer';
-import { isTest } from 'std-env';
+import process from "node:process";
+import net from "node:net";
+import { Buffer } from "node:buffer";
+import { isTest } from "std-env";
 
+//#region src/vite-node.ts
 function getViteNodeOptionsEnvVar() {
-  const envVar = process.env.NUXT_VITE_NODE_OPTIONS;
-  try {
-    return JSON.parse(envVar || "{}");
-  } catch (e) {
-    console.error("vite-node-shared: Failed to parse NUXT_VITE_NODE_OPTIONS environment variable.", e);
-    return {};
-  }
+	const envVar = process.env.NUXT_VITE_NODE_OPTIONS;
+	try {
+		return JSON.parse(envVar || "{}");
+	} catch (e) {
+		console.error("vite-node-shared: Failed to parse NUXT_VITE_NODE_OPTIONS environment variable.", e);
+		return {};
+	}
 }
 const viteNodeOptions = getViteNodeOptionsEnvVar();
 const pendingRequests = /* @__PURE__ */ new Map();
@@ -21,237 +22,219 @@ const MAX_RETRY_ATTEMPTS = viteNodeOptions.maxRetryAttempts ?? 5;
 const BASE_RETRY_DELAY_MS = viteNodeOptions.baseRetryDelay ?? 100;
 const MAX_RETRY_DELAY_MS = viteNodeOptions.maxRetryDelay ?? 2e3;
 const REQUEST_TIMEOUT_MS = viteNodeOptions.requestTimeout ?? 6e4;
+/**
+* Calculates exponential backoff delay with jitter.
+* @param attempt - The current attempt number (0-based).
+* @returns Delay in milliseconds.
+*/
 function calculateRetryDelay(attempt) {
-  const exponentialDelay = BASE_RETRY_DELAY_MS * Math.pow(2, attempt);
-  const jitter = Math.random() * 0.1 * exponentialDelay;
-  return Math.min(exponentialDelay + jitter, MAX_RETRY_DELAY_MS);
+	const exponentialDelay = BASE_RETRY_DELAY_MS * Math.pow(2, attempt);
+	const jitter = Math.random() * .1 * exponentialDelay;
+	return Math.min(exponentialDelay + jitter, MAX_RETRY_DELAY_MS);
 }
+/**
+* Establishes or returns an existing IPC socket connection with retry logic.
+* @returns A promise that resolves with the connected socket.
+*/
 function connectSocket() {
-  if (clientSocket && !clientSocket.destroyed) {
-    return Promise.resolve(clientSocket);
-  }
-  if (currentConnectPromise) {
-    return currentConnectPromise;
-  }
-  const thisPromise = new Promise((resolve, reject) => {
-    if (!viteNodeOptions.socketPath) {
-      console.error("vite-node-shared: NUXT_VITE_NODE_OPTIONS.socketPath is not defined.");
-      return reject(new Error("Vite Node IPC socket path not configured."));
-    }
-    const attemptConnection = (attempt = 0) => {
-      const socket = net.createConnection(viteNodeOptions.socketPath);
-      const INITIAL_BUFFER_SIZE = 64 * 1024;
-      const MAX_BUFFER_SIZE = 1024 * 1024 * 1024;
-      let buffer = Buffer.alloc(INITIAL_BUFFER_SIZE);
-      let writeOffset = 0;
-      let readOffset = 0;
-      socket.setNoDelay(true);
-      socket.setKeepAlive(true, 3e4);
-      const cleanup = () => {
-        socket.off("connect", onConnect);
-        socket.off("data", onData);
-        socket.off("error", onError);
-        socket.off("close", onClose);
-      };
-      const resetBuffer = () => {
-        writeOffset = 0;
-        readOffset = 0;
-      };
-      const compactBuffer = () => {
-        if (readOffset > 0) {
-          const remainingData = writeOffset - readOffset;
-          if (remainingData > 0) {
-            buffer.copy(buffer, 0, readOffset, writeOffset);
-          }
-          writeOffset = remainingData;
-          readOffset = 0;
-        }
-      };
-      const ensureBufferCapacity = (additionalBytes) => {
-        const requiredSize = writeOffset + additionalBytes;
-        if (requiredSize > MAX_BUFFER_SIZE) {
-          throw new Error(`Buffer size limit exceeded: ${requiredSize} > ${MAX_BUFFER_SIZE}`);
-        }
-        if (requiredSize > buffer.length) {
-          compactBuffer();
-          if (writeOffset + additionalBytes > buffer.length) {
-            const newSize = Math.min(
-              Math.max(buffer.length * 2, requiredSize),
-              MAX_BUFFER_SIZE
-            );
-            const newBuffer = Buffer.alloc(newSize);
-            buffer.copy(newBuffer, 0, 0, writeOffset);
-            buffer = newBuffer;
-          }
-        }
-      };
-      const onConnect = () => {
-        clientSocket = socket;
-        resolve(socket);
-      };
-      const onData = (data) => {
-        try {
-          ensureBufferCapacity(data.length);
-          data.copy(buffer, writeOffset);
-          writeOffset += data.length;
-          while (writeOffset - readOffset >= 4) {
-            const messageLength = buffer.readUInt32BE(readOffset);
-            if (writeOffset - readOffset < 4 + messageLength) {
-              return;
-            }
-            const message = buffer.subarray(readOffset + 4, readOffset + 4 + messageLength).toString("utf-8");
-            readOffset += 4 + messageLength;
-            try {
-              const response = JSON.parse(message);
-              const requestHandlers = pendingRequests.get(response.id);
-              if (requestHandlers) {
-                const { resolve: resolveRequest, reject: rejectRequest } = requestHandlers;
-                if (response.type === "error") {
-                  const err = new Error(response.error.message);
-                  err.stack = response.error.stack;
-                  err.data = response.error.data;
-                  err.statusCode = err.status = response.error.status || response.error.statusCode;
-                  rejectRequest(err);
-                } else {
-                  resolveRequest(response.data);
-                }
-                pendingRequests.delete(response.id);
-              }
-            } catch (parseError) {
-              console.warn("vite-node-shared: Failed to parse IPC response:", parseError);
-            }
-          }
-          if (readOffset > buffer.length / 2) {
-            compactBuffer();
-          }
-        } catch (error) {
-          socket.destroy(error instanceof Error ? error : new Error("Buffer management error"));
-        }
-      };
-      const onError = (err) => {
-        cleanup();
-        resetBuffer();
-        if (attempt < MAX_RETRY_ATTEMPTS) {
-          const delay = calculateRetryDelay(attempt);
-          setTimeout(() => attemptConnection(attempt + 1), delay);
-        } else {
-          if (currentConnectPromise === thisPromise) {
-            reject(err);
-          }
-          for (const { reject: rejectRequest } of pendingRequests.values()) {
-            rejectRequest(err);
-          }
-          pendingRequests.clear();
-          if (clientSocket === socket) {
-            clientSocket = void 0;
-          }
-          if (currentConnectPromise === thisPromise) {
-            currentConnectPromise = void 0;
-          }
-        }
-      };
-      const onClose = () => {
-        cleanup();
-        resetBuffer();
-        for (const { reject: rejectRequest } of pendingRequests.values()) {
-          rejectRequest(new Error("IPC connection closed"));
-        }
-        pendingRequests.clear();
-        if (clientSocket === socket) {
-          clientSocket = void 0;
-        }
-        if (currentConnectPromise === thisPromise) {
-          currentConnectPromise = void 0;
-        }
-      };
-      socket.on("connect", onConnect);
-      socket.on("data", onData);
-      socket.on("error", onError);
-      socket.on("close", onClose);
-    };
-    attemptConnection();
-  });
-  currentConnectPromise = thisPromise;
-  return currentConnectPromise;
+	if (clientSocket && !clientSocket.destroyed) return Promise.resolve(clientSocket);
+	if (currentConnectPromise) return currentConnectPromise;
+	const thisPromise = new Promise((resolve, reject) => {
+		if (!viteNodeOptions.socketPath) {
+			console.error("vite-node-shared: NUXT_VITE_NODE_OPTIONS.socketPath is not defined.");
+			return reject(/* @__PURE__ */ new Error("Vite Node IPC socket path not configured."));
+		}
+		const attemptConnection = (attempt = 0) => {
+			const socket = net.createConnection(viteNodeOptions.socketPath);
+			const INITIAL_BUFFER_SIZE = 64 * 1024;
+			const MAX_BUFFER_SIZE = 1024 * 1024 * 1024;
+			let buffer = Buffer.alloc(INITIAL_BUFFER_SIZE);
+			let writeOffset = 0;
+			let readOffset = 0;
+			socket.setNoDelay(true);
+			socket.setKeepAlive(true, 3e4);
+			const cleanup = () => {
+				socket.off("connect", onConnect);
+				socket.off("data", onData);
+				socket.off("error", onError);
+				socket.off("close", onClose);
+			};
+			const resetBuffer = () => {
+				writeOffset = 0;
+				readOffset = 0;
+			};
+			const compactBuffer = () => {
+				if (readOffset > 0) {
+					const remainingData = writeOffset - readOffset;
+					if (remainingData > 0) buffer.copy(buffer, 0, readOffset, writeOffset);
+					writeOffset = remainingData;
+					readOffset = 0;
+				}
+			};
+			const ensureBufferCapacity = (additionalBytes) => {
+				const requiredSize = writeOffset + additionalBytes;
+				if (requiredSize > MAX_BUFFER_SIZE) throw new Error(`Buffer size limit exceeded: ${requiredSize} > ${MAX_BUFFER_SIZE}`);
+				if (requiredSize > buffer.length) {
+					compactBuffer();
+					if (writeOffset + additionalBytes > buffer.length) {
+						const newSize = Math.min(Math.max(buffer.length * 2, requiredSize), MAX_BUFFER_SIZE);
+						const newBuffer = Buffer.alloc(newSize);
+						buffer.copy(newBuffer, 0, 0, writeOffset);
+						buffer = newBuffer;
+					}
+				}
+			};
+			const onConnect = () => {
+				clientSocket = socket;
+				resolve(socket);
+			};
+			const onData = (data) => {
+				try {
+					ensureBufferCapacity(data.length);
+					data.copy(buffer, writeOffset);
+					writeOffset += data.length;
+					while (writeOffset - readOffset >= 4) {
+						const messageLength = buffer.readUInt32BE(readOffset);
+						if (writeOffset - readOffset < 4 + messageLength) return;
+						const message = buffer.subarray(readOffset + 4, readOffset + 4 + messageLength).toString("utf-8");
+						readOffset += 4 + messageLength;
+						try {
+							const response = JSON.parse(message);
+							const requestHandlers = pendingRequests.get(response.id);
+							if (requestHandlers) {
+								const { resolve: resolveRequest, reject: rejectRequest } = requestHandlers;
+								if (response.type === "error") {
+									const err = new Error(response.error.message);
+									err.stack = response.error.stack;
+									err.data = response.error.data;
+									err.statusCode = err.status = response.error.status || response.error.statusCode;
+									rejectRequest(err);
+								} else resolveRequest(response.data);
+								pendingRequests.delete(response.id);
+							}
+						} catch (parseError) {
+							console.warn("vite-node-shared: Failed to parse IPC response:", parseError);
+						}
+					}
+					if (readOffset > buffer.length / 2) compactBuffer();
+				} catch (error) {
+					socket.destroy(error instanceof Error ? error : /* @__PURE__ */ new Error("Buffer management error"));
+				}
+			};
+			const onError = (err) => {
+				cleanup();
+				resetBuffer();
+				if (attempt < MAX_RETRY_ATTEMPTS) {
+					const delay = calculateRetryDelay(attempt);
+					setTimeout(() => attemptConnection(attempt + 1), delay);
+				} else {
+					if (currentConnectPromise === thisPromise) reject(err);
+					for (const { reject: rejectRequest } of pendingRequests.values()) rejectRequest(err);
+					pendingRequests.clear();
+					if (clientSocket === socket) clientSocket = void 0;
+					if (currentConnectPromise === thisPromise) currentConnectPromise = void 0;
+				}
+			};
+			const onClose = () => {
+				cleanup();
+				resetBuffer();
+				for (const { reject: rejectRequest } of pendingRequests.values()) rejectRequest(/* @__PURE__ */ new Error("IPC connection closed"));
+				pendingRequests.clear();
+				if (clientSocket === socket) clientSocket = void 0;
+				if (currentConnectPromise === thisPromise) currentConnectPromise = void 0;
+			};
+			socket.on("connect", onConnect);
+			socket.on("data", onData);
+			socket.on("error", onError);
+			socket.on("close", onClose);
+		};
+		attemptConnection();
+	});
+	currentConnectPromise = thisPromise;
+	return currentConnectPromise;
 }
+/**
+* Sends a request over the IPC socket with automatic reconnection.
+*/
 async function sendRequest(type, payload) {
-  const requestId = requestIdCounter++;
-  let lastError;
-  for (let requestAttempt = 0; requestAttempt <= MAX_RETRY_ATTEMPTS; requestAttempt++) {
-    try {
-      const socket = await connectSocket();
-      return new Promise((resolve, reject) => {
-        const timeoutId = setTimeout(() => {
-          pendingRequests.delete(requestId);
-          reject(new Error(`Request timeout after ${REQUEST_TIMEOUT_MS}ms for type: ${type}`));
-        }, REQUEST_TIMEOUT_MS);
-        pendingRequests.set(requestId, {
-          resolve: (value) => {
-            clearTimeout(timeoutId);
-            resolve(value);
-          },
-          reject: (reason) => {
-            clearTimeout(timeoutId);
-            reject(reason);
-          }
-        });
-        const message = JSON.stringify({ id: requestId, type, payload });
-        const messageBuffer = Buffer.from(message, "utf-8");
-        const messageLength = messageBuffer.length;
-        const fullMessage = Buffer.alloc(4 + messageLength);
-        fullMessage.writeUInt32BE(messageLength, 0);
-        messageBuffer.copy(fullMessage, 4);
-        try {
-          socket.write(fullMessage);
-        } catch (error) {
-          clearTimeout(timeoutId);
-          pendingRequests.delete(requestId);
-          reject(error);
-        }
-      });
-    } catch (error) {
-      lastError = error;
-      if (requestAttempt < MAX_RETRY_ATTEMPTS) {
-        const delay = calculateRetryDelay(requestAttempt);
-        await new Promise((resolve) => setTimeout(resolve, delay));
-        if (clientSocket) {
-          clientSocket.destroy();
-          clientSocket = void 0;
-        }
-        currentConnectPromise = void 0;
-      }
-    }
-  }
-  throw lastError || new Error("Request failed after all retry attempts");
+	const requestId = requestIdCounter++;
+	let lastError;
+	for (let requestAttempt = 0; requestAttempt <= MAX_RETRY_ATTEMPTS; requestAttempt++) try {
+		const socket = await connectSocket();
+		return new Promise((resolve, reject) => {
+			const timeoutId = setTimeout(() => {
+				pendingRequests.delete(requestId);
+				reject(/* @__PURE__ */ new Error(`Request timeout after ${REQUEST_TIMEOUT_MS}ms for type: ${type}`));
+			}, REQUEST_TIMEOUT_MS);
+			pendingRequests.set(requestId, {
+				resolve: (value) => {
+					clearTimeout(timeoutId);
+					resolve(value);
+				},
+				reject: (reason) => {
+					clearTimeout(timeoutId);
+					reject(reason);
+				}
+			});
+			const message = JSON.stringify({
+				id: requestId,
+				type,
+				payload
+			});
+			const messageBuffer = Buffer.from(message, "utf-8");
+			const messageLength = messageBuffer.length;
+			const fullMessage = Buffer.alloc(4 + messageLength);
+			fullMessage.writeUInt32BE(messageLength, 0);
+			messageBuffer.copy(fullMessage, 4);
+			try {
+				socket.write(fullMessage);
+			} catch (error) {
+				clearTimeout(timeoutId);
+				pendingRequests.delete(requestId);
+				reject(error);
+			}
+		});
+	} catch (error) {
+		lastError = error;
+		if (requestAttempt < MAX_RETRY_ATTEMPTS) {
+			const delay = calculateRetryDelay(requestAttempt);
+			await new Promise((resolve) => setTimeout(resolve, delay));
+			if (clientSocket) {
+				clientSocket.destroy();
+				clientSocket = void 0;
+			}
+			currentConnectPromise = void 0;
+		}
+	}
+	throw lastError || /* @__PURE__ */ new Error("Request failed after all retry attempts");
 }
 const viteNodeFetch = {
-  getManifest() {
-    return sendRequest("manifest", void 0);
-  },
-  getInvalidates() {
-    return sendRequest("invalidates", void 0);
-  },
-  resolveId(id, importer) {
-    return sendRequest("resolve", { id, importer });
-  },
-  fetchModule(moduleId) {
-    return sendRequest("module", { moduleId });
-  },
-  ensureConnected() {
-    return connectSocket();
-  }
+	getManifest() {
+		return sendRequest("manifest", void 0);
+	},
+	getInvalidates() {
+		return sendRequest("invalidates", void 0);
+	},
+	resolveId(id, importer) {
+		return sendRequest("resolve", {
+			id,
+			importer
+		});
+	},
+	fetchModule(moduleId) {
+		return sendRequest("module", { moduleId });
+	},
+	ensureConnected() {
+		return connectSocket();
+	}
 };
 let preConnectAttempted = false;
 function preConnect() {
-  if (preConnectAttempted || !viteNodeOptions.socketPath) {
-    return;
-  }
-  preConnectAttempted = true;
-  return connectSocket().catch(() => {
-  });
-}
-if (typeof process !== "undefined" && !isTest) {
-  setTimeout(preConnect, 100);
+	if (preConnectAttempted || !viteNodeOptions.socketPath) return;
+	preConnectAttempted = true;
+	return connectSocket().catch(() => {});
 }
+if (typeof process !== "undefined" && !isTest) setTimeout(preConnect, 100);
 
-export { viteNodeFetch, viteNodeOptions };
+//#endregion
+export { viteNodeFetch, viteNodeOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/vite-builder-nightly",
-  "version": "4.3.0-29465977.c4f46c64",
+  "version": "4.3.0-29466372.7f503428",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nuxt/nuxt.git",
@@ -10,12 +10,9 @@
   "homepage": "https://nuxt.com",
   "license": "MIT",
   "type": "module",
-  "types": "./dist/index.d.ts",
+  "types": "./dist/index.d.mts",
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs"
-    }
+    ".": "./dist/index.mjs"
   },
   "imports": {
     "#vite-node": "./dist/vite-node.mjs",
@@ -25,15 +22,15 @@
     "dist"
   ],
   "devDependencies": {
-    "@nuxt/schema": "npm:@nuxt/schema-nightly@4.3.0-29465977.c4f46c64",
+    "@nuxt/schema": "npm:@nuxt/schema-nightly@4.3.0-29466372.7f503428",
     "nitropack": "2.12.9",
+    "obuild": "0.4.14",
     "rolldown": "1.0.0-beta.58",
     "rollup": "4.55.1",
-    "unbuild": "3.6.1",
     "vue": "3.5.26"
   },
   "dependencies": {
-    "@nuxt/kit": "npm:@nuxt/kit-nightly@4.3.0-29465977.c4f46c64",
+    "@nuxt/kit": "npm:@nuxt/kit-nightly@4.3.0-29466372.7f503428",
     "@rollup/plugin-replace": "^6.0.3",
     "@vitejs/plugin-vue": "^6.0.3",
     "@vitejs/plugin-vue-jsx": "^5.1.3",
@@ -65,7 +62,7 @@
     "vue-bundle-renderer": "^2.2.0"
   },
   "peerDependencies": {
-    "nuxt": "npm:nuxt-nightly@4.3.0-29465977.c4f46c64",
+    "nuxt": "npm:nuxt-nightly@4.3.0-29466372.7f503428",
     "rolldown": "^1.0.0-beta.38",
     "vue": "^3.3.4"
   },
@@ -79,7 +76,7 @@
   },
   "_name": "@nuxt/vite-builder",
   "scripts": {
-    "build:stub": "unbuild --stub",
+    "build:stub": "obuild --stub",
     "test:attw": "attw --pack"
   }
 }

package/dist/index.d.ts

@@ -1,23 +0,0 @@
-import { ViteConfig } from 'nuxt/schema';
-import { EnvironmentOptions } from 'vite';
-import { NuxtBuilder } from '@nuxt/schema';
-
-declare const bundle: NuxtBuilder['bundle'];
-
-declare module 'nuxt/schema' {
-    interface ViteOptions extends ViteConfig {
-        $client?: EnvironmentOptions;
-        $server?: EnvironmentOptions;
-        viteNode?: {
-            maxRetryAttempts?: number;
-            /** in milliseconds */
-            baseRetryDelay?: number;
-            /** in milliseconds */
-            maxRetryDelay?: number;
-            /** in milliseconds */
-            requestTimeout?: number;
-        };
-    }
-}
-
-export { bundle };

package/dist/vite-node-entry.d.ts

@@ -1,5 +0,0 @@
-import { NuxtSSRContext } from 'nuxt/app';
-
-declare const _default: (ssrContext: NuxtSSRContext) => Promise<any>;
-
-export { _default as default };

package/dist/vite-node.d.ts

@@ -1,34 +0,0 @@
-import { Socket } from 'node:net';
-import { PluginContainer } from 'vite';
-import { FetchResult } from 'vite-node';
-import { Manifest } from 'vue-bundle-renderer';
-
-type ResolveIdResponse = Awaited<ReturnType<PluginContainer['resolveId']>>;
-interface ViteNodeFetch {
-    /**  Gets the client manifest. */
-    getManifest(): Promise<Manifest>;
-    /** Gets the list of invalidated files. */
-    getInvalidates(): Promise<string[]>;
-    /** Resolves a module ID. */
-    resolveId(id: string, importer?: string): Promise<ResolveIdResponse | null>;
-    /** Fetches a module. */
-    fetchModule(moduleId: string): Promise<FetchResult>;
-    /** Ensures the IPC socket is connected. */
-    ensureConnected(): Promise<Socket>;
-}
-type ViteNodeServerOptions = {
-    baseURL: string;
-    socketPath: string;
-    root: string;
-    entryPath: string;
-    base: string;
-    maxRetryAttempts?: number;
-    baseRetryDelay?: number;
-    maxRetryDelay?: number;
-    requestTimeout?: number;
-};
-
-declare const viteNodeOptions: ViteNodeServerOptions;
-declare const viteNodeFetch: ViteNodeFetch;
-
-export { viteNodeFetch, viteNodeOptions };