houdini-react 2.0.0-next.29 → 2.0.0-next.30

package/bin/houdini-react

@@ -1,88 +1,173 @@
 #!/usr/bin/env node
 
-// Simple shim that can be replaced with the actual binary for optimal performance
-// This follows esbuild's approach: the postInstall script will replace this entire file
-// with the native binary when possible, eliminating Node.js startup overhead
-
 const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
 
-// Manual binary path override support
-const MANUAL_BINARY_PATH = process.env.HOUDINI_BINARY_PATH || process.env.HOUDINI_REACT_BINARY_PATH;
+const binaryName = process.platform === 'win32' ? 'houdini-react.exe' : 'houdini-react';
+
+const BINARY_DISTRIBUTION_PACKAGES = {
+	'linux-x64':   'houdini-react-linux-x64',
+	'linux-arm64': 'houdini-react-linux-arm64',
+	'win32-x64':   'houdini-react-win32-x64',
+	'win32-arm64': 'houdini-react-win32-arm64',
+	'darwin-x64':  'houdini-react-darwin-x64',
+	'darwin-arm64':'houdini-react-darwin-arm64',
+};
+
+const PLATFORM_OVERRIDE = process.env.HOUDINI_PLATFORM;
+const MANUAL_BINARY_PATH = process.env.HOUDINI_REACT_BINARY_PATH || process.env.HOUDINI_BINARY_PATH;
+
+// --- WASM path ---
+if (PLATFORM_OVERRIDE === 'wasm') {
+	const wasmPackage = 'houdini-react-wasm';
+	const wasmBinaryName = 'houdini-react.wasm';
+	let wasmBin = null;
+
+	try {
+		const pkgPath = require.resolve(`${wasmPackage}/package.json`);
+		wasmBin = path.join(path.dirname(pkgPath), 'bin', wasmBinaryName);
+	} catch {
+		const sibling = path.join(__dirname, '..', wasmPackage, 'bin', wasmBinaryName);
+		if (fs.existsSync(sibling)) wasmBin = sibling;
+	}
+
+	if (!wasmBin || !fs.existsSync(wasmBin)) {
+		process.stderr.write(`[houdini-react] WASM package not installed. Try: npm install ${wasmPackage}\n`);
+		process.exit(1);
+	}
+
+	// In WebContainers, fs.readSync on a pipe fd is not supported in any thread
+	// (the child gets EBADF). Instead:
+	//   Main thread  — async process.stdin.on('data') works fine (event loop)
+	//   Worker thread — Atomics.wait + receiveMessageOnPort provides real blocking
+	// A custom fd_read override feeds WASM stdin from the message channel so WASI
+	// never touches fd 0 directly.
+	const { Worker, isMainThread, workerData, MessageChannel, receiveMessageOnPort } = require('worker_threads');
+
+	if (isMainThread) {
+		const { port1: stdinMain, port2: stdinWorker } = new MessageChannel();
+		// Counter: main increments (Atomics.add) per message so rapid bursts
+		// (two frames in the same tick) produce two distinct wakeups.
+		const syncBuf = new Int32Array(new SharedArrayBuffer(4));
+
+		process.stdin.on('error', () => {});
+		process.stdin.on('data', data => {
+			stdinMain.postMessage(data);
+			Atomics.add(syncBuf, 0, 1);
+			Atomics.notify(syncBuf, 0);
+		});
+		process.stdin.on('end', () => {
+			stdinMain.postMessage(null); // EOF sentinel
+			Atomics.add(syncBuf, 0, 1);
+			Atomics.notify(syncBuf, 0);
+		});
+
+		const worker = new Worker(__filename, {
+			workerData: { wasmBin, args: process.argv.slice(2), stdinPort: stdinWorker, syncBuf },
+			transferList: [stdinWorker],
+		});
+		worker.on('exit', code => process.exit(code ?? 0));
+		return; // prevent fallthrough to native binary path
+	} else {
+		const { wasmBin: wb, args, stdinPort, syncBuf } = workerData;
+		const { WASI } = require('node:wasi');
+
+		const wasi = new WASI({
+			args: [wb, ...args],
+			env: process.env,
+			preopens: { '/': '/' },
+			version: 'preview1',
+		});
+
+		let wasmMem = null;
+		const importObj = wasi.getImportObject();
+		const realFdRead = importObj.wasi_snapshot_preview1.fd_read;
+
+		// Override fd_read for stdin (fd 0) only: block via Atomics until the main
+		// thread delivers a chunk, then copy it into WASM memory via iov buffers.
+		importObj.wasi_snapshot_preview1.fd_read = (fd, iovs, iovsLen, nread) => {
+			if (fd !== 0 || !wasmMem) return realFdRead(fd, iovs, iovsLen, nread);
 
+			while (Atomics.load(syncBuf, 0) === 0) {
+				Atomics.wait(syncBuf, 0, 0);
+			}
+			const msg = receiveMessageOnPort(stdinPort);
+			Atomics.sub(syncBuf, 0, 1);
+
+			const view = new DataView(wasmMem.buffer);
+			if (!msg || msg.message === null) {
+				view.setUint32(nread, 0, true); // EOF
+				return 0;
+			}
+
+			const chunk = msg.message;
+			const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+			let written = 0;
+			for (let i = 0; i < iovsLen; i++) {
+				const ptr = view.getUint32(iovs + i * 8, true);
+				const len = view.getUint32(iovs + i * 8 + 4, true);
+				const n = Math.min(len, buf.length - written);
+				if (n <= 0) break;
+				new Uint8Array(wasmMem.buffer, ptr, n).set(buf.subarray(written, written + n));
+				written += n;
+			}
+			view.setUint32(nread, written, true);
+			return 0;
+		};
+
+		const mod = new WebAssembly.Module(fs.readFileSync(wb));
+		const inst = new WebAssembly.Instance(mod, importObj);
+		wasmMem = inst.exports.memory;
+		wasi.start(inst);
+		process.exit(0);
+	}
+}
+
+// --- Native binary path ---
 function getBinaryPath() {
-	// Check for manual override first
 	if (MANUAL_BINARY_PATH && fs.existsSync(MANUAL_BINARY_PATH)) {
 		return MANUAL_BINARY_PATH;
 	}
 
-	// Platform-specific package lookup
-	const BINARY_DISTRIBUTION_PACKAGES = {
-		'linux-x64': 'houdini-react-linux-x64',
-		'linux-arm64': 'houdini-react-linux-arm64',
-		'win32-x64': 'houdini-react-win32-x64',
-		'win32-arm64': 'houdini-react-win32-arm64',
-		'darwin-x64': 'houdini-react-darwin-x64',
-		'darwin-arm64': 'houdini-react-darwin-arm64',
-	}
-
-	const binaryName = process.platform === 'win32' ? 'houdini-react.exe' : 'houdini-react'
-	const platformSpecificPackageName = BINARY_DISTRIBUTION_PACKAGES[`${process.platform}-${process.arch}`]
+	const platformKey = PLATFORM_OVERRIDE || `${process.platform}-${process.arch}`;
+	const platformSpecificPackageName = BINARY_DISTRIBUTION_PACKAGES[platformKey];
 
 	if (!platformSpecificPackageName) {
-		// Fallback to downloaded binary if platform not supported
-		return path.join(__dirname, binaryName)
+		if (PLATFORM_OVERRIDE) {
+			process.stderr.write(`[houdini-react] Unknown platform "${PLATFORM_OVERRIDE}". Valid values: ${Object.keys(BINARY_DISTRIBUTION_PACKAGES).join(', ')}, wasm\n`);
+			process.exit(1);
+		}
+		return path.join(__dirname, binaryName);
 	}
 
 	try {
-		// Method 1: Use require.resolve to find the platform-specific package
-		const platformPackagePath = require.resolve(`${platformSpecificPackageName}/package.json`)
-		const platformPackageDir = path.dirname(platformPackagePath)
-		return path.join(platformPackageDir, 'bin', binaryName)
-	} catch (error) {
-		// Method 2: Check sibling directory (npm structure)
-		const siblingPath = path.join(__dirname, '..', platformSpecificPackageName)
-		const siblingBinaryPath = path.join(siblingPath, 'bin', binaryName)
-
-		if (fs.existsSync(siblingBinaryPath)) {
-			return siblingBinaryPath
-		}
+		const platformPackagePath = require.resolve(`${platformSpecificPackageName}/package.json`);
+		return path.join(path.dirname(platformPackagePath), 'bin', binaryName);
+	} catch {
+		const siblingPath = path.join(__dirname, '..', platformSpecificPackageName, 'bin', binaryName);
+		if (fs.existsSync(siblingPath)) return siblingPath;
 
-		// Method 3: Check pnpm structure
-		const pnpmMatch = __dirname.match(/(.+\/node_modules\/)\.pnpm\/([^\/]+)\/node_modules\//)
+		const pnpmMatch = __dirname.match(/(.+\/node_modules\/)\.pnpm\/[^/]+\/node_modules\//);
 		if (pnpmMatch) {
-			const [, nodeModulesRoot] = pnpmMatch
-			const pnpmDir = path.join(nodeModulesRoot, '.pnpm')
-
+			const pnpmDir = path.join(pnpmMatch[1], '.pnpm');
 			try {
-				const pnpmEntries = fs.readdirSync(pnpmDir)
-				// Get the expected version from the main package
-				const packageJSON = require(path.join(__dirname, '..', 'package.json'))
-				const expectedVersion = packageJSON.version
-				const expectedPnpmEntry = `${platformSpecificPackageName}@${expectedVersion}`
-				const platformEntry = pnpmEntries.find(entry => entry === expectedPnpmEntry)
-
-				if (platformEntry) {
-					const pnpmBinaryPath = path.join(pnpmDir, platformEntry, 'node_modules', platformSpecificPackageName, 'bin', binaryName)
-					if (fs.existsSync(pnpmBinaryPath)) {
-						return pnpmBinaryPath
-					}
+				const packageJSON = require(path.join(__dirname, '..', 'package.json'));
+				const entry = `${platformSpecificPackageName}@${packageJSON.version}`;
+				const found = fs.readdirSync(pnpmDir).find(e => e === entry);
+				if (found) {
+					const p = path.join(pnpmDir, found, 'node_modules', platformSpecificPackageName, 'bin', binaryName);
+					if (fs.existsSync(p)) return p;
 				}
-			} catch (err) {
-				// Ignore pnpm detection errors
-			}
+			} catch {}
 		}
 
-		// Method 4: Fallback to downloaded binary in main package
-		return path.join(__dirname, binaryName)
+		return path.join(__dirname, binaryName);
 	}
 }
 
-// Execute the binary directly (this entire file may be replaced with the actual binary)
 try {
 	execFileSync(getBinaryPath(), process.argv.slice(2), { stdio: 'inherit' });
 } catch (error) {
-	// If execFileSync fails, exit with the same code
 	process.exit(error.status || 1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "houdini-react",
-  "version": "2.0.0-next.29",
+  "version": "2.0.0-next.30",
   "description": "The React plugin for houdini",
   "keywords": [
     "typescript",
@@ -16,29 +16,29 @@
   },
   "license": "MIT",
   "devDependencies": {
-    "@types/cookie-parser": "^1.4.3",
-    "@types/cookie-session": "^2.0.44",
-    "@types/cookies": "^0.7.7",
-    "@types/estraverse": "^5.1.2",
-    "@types/express": "^4.17.17",
-    "@types/react": "^19.0.7",
-    "@types/react-dom": "^19.0.3"
+    "@types/cookie-parser": "^1.4.10",
+    "@types/cookie-session": "^2.0.49",
+    "@types/cookies": "^0.9.2",
+    "@types/estraverse": "^5.1.7",
+    "@types/express": "^5.0.3",
+    "@types/react": "^19.2.16",
+    "@types/react-dom": "^19.2.3"
   },
   "dependencies": {
-    "@babel/parser": "^7.24.6",
-    "@babel/types": "^7.24.6",
-    "@whatwg-node/server": "^0.9.14",
-    "cookie-parser": "^1.4.6",
-    "cookie-session": "^2.0.0",
-    "cookies": "^0.8.0",
+    "@babel/parser": "^7.29.7",
+    "@babel/types": "^7.29.7",
+    "@whatwg-node/server": "^0.11.0",
+    "cookie-parser": "^1.4.7",
+    "cookie-session": "^2.1.1",
+    "cookies": "^0.9.1",
     "estraverse": "^5.3.0",
-    "express": "^4.18.2",
-    "graphql-yoga": "^4.0.4",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
+    "express": "^5.1.0",
+    "graphql-yoga": "^5.21.1",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
     "react-streaming": "^0.4.17",
-    "recast": "^0.23.1",
-    "rollup": "^4.28.1",
+    "recast": "^0.23.11",
+    "rollup": "^4.61.1",
     "use-deep-compare-effect": "^1.8.1"
   },
   "peerDependencies": {
@@ -81,17 +81,20 @@
     }
   },
   "optionalDependencies": {
-    "houdini-react-darwin-x64": "2.0.0-next.29",
-    "houdini-react-darwin-arm64": "2.0.0-next.29",
-    "houdini-react-linux-x64": "2.0.0-next.29",
-    "houdini-react-linux-arm64": "2.0.0-next.29",
-    "houdini-react-win32-x64": "2.0.0-next.29",
-    "houdini-react-win32-arm64": "2.0.0-next.29"
+    "houdini-react-darwin-x64": "2.0.0-next.30",
+    "houdini-react-darwin-arm64": "2.0.0-next.30",
+    "houdini-react-linux-x64": "2.0.0-next.30",
+    "houdini-react-linux-arm64": "2.0.0-next.30",
+    "houdini-react-win32-x64": "2.0.0-next.30",
+    "houdini-react-win32-arm64": "2.0.0-next.30",
+    "houdini-react-wasm": "2.0.0-next.30"
   },
-  "bin": "bin/houdini-react",
   "scripts": {
     "compile": "scripts build-go",
     "typedefs": "scripts typedefs --plugin --go-package",
     "postinstall": "node postInstall.js"
+  },
+  "bin": {
+    "houdini-react": "bin/houdini-react"
   }
 }

package/postInstall.js

@@ -5,7 +5,7 @@ const https = require('https')
 const child_process = require('child_process')
 
 // Adjust the version you want to install. You can also make this dynamic.
-const BINARY_DISTRIBUTION_VERSION = '2.0.0-next.29'
+const BINARY_DISTRIBUTION_VERSION = '2.0.0-next.30'
 
 // Windows binaries end with .exe so we need to special case them.
 const binaryName = process.platform === 'win32' ? 'houdini-react.exe' : 'houdini-react'
@@ -181,6 +181,13 @@ if (!platformSpecificPackageName) {
 // Replace the JavaScript shim with the actual binary for optimal performance (skip Node.js overhead)
 // This is inspired by esbuild's approach: https://github.com/evanw/esbuild/blob/main/lib/npm/node-install.ts
 function maybeOptimizePackage() {
+	// Allow callers to opt out of the optimization (e.g. when building a snapshot
+	// for an environment that can't run native binaries, like WebContainers).
+	if (process.env.HOUDINI_SKIP_SHIM_INSTALL) {
+		console.log(`[${packageJSON.name}] HOUDINI_SKIP_SHIM_INSTALL set, keeping JavaScript shim`)
+		return
+	}
+
 	// This optimization doesn't work on Windows because the binary must be called with .exe extension
 	// It also doesn't work with Yarn due to various compatibility issues
 	if (process.platform === 'win32' || isYarn()) {

package/runtime/hooks/useQueryHandle.ts

@@ -19,9 +19,12 @@ import { useIsMountedRef } from './useIsMounted.js'
 // When the Component unmounts, we need to remove the entry from the cache (so we can load again)
 
 const promiseCache = createLRUCache<QuerySuspenseUnit>()
-type QuerySuspenseUnit = {
+type QuerySuspenseUnit<
+	_Data extends GraphQLObject = GraphQLObject,
+	_Input extends GraphQLVariables = GraphQLVariables,
+> = {
 	resolve: () => void
-	resolved?: DocumentHandle<QueryArtifact, GraphQLObject, {}>
+	resolved?: DocumentHandle<QueryArtifact, _Data, _Input>
 	then: (val: any) => any
 }
 
@@ -106,7 +109,7 @@ export function useQueryHandle<
 		let resolve: () => void = () => {}
 		const loadPromise = new Promise<void>((r) => (resolve = r))
 
-		const suspenseUnit: QuerySuspenseUnit = {
+		const suspenseUnit: QuerySuspenseUnit<_Data, _Input> = {
 			// biome-ignore lint/suspicious/noThenProperty: suspense protocol requires a thenable
 			then: loadPromise.then.bind(loadPromise),
 			resolve,
@@ -114,7 +117,7 @@ export function useQueryHandle<
 			variables,
 		}
 
-		promiseCache.set(identifier, suspenseUnit)
+		promiseCache.set(identifier, suspenseUnit as QuerySuspenseUnit)
 
 		// the suspense unit gives react something to hold onto
 		// and it acts as a place for us to register a callback on
@@ -134,7 +137,7 @@ export function useQueryHandle<
 					data: value.data,
 					partia: value.partial,
 					artifact,
-				}
+				} as unknown as DocumentHandle<QueryArtifact, _Data, _Input>
 
 				suspenseUnit.resolve()
 			})

package/runtime/routing/Router.tsx

@@ -481,8 +481,8 @@ export function RouterContextProvider({
 	const [session, setSession] = React.useState<App.Session>(ssrSession)
 
 	// if we detect an event that contains a new session value
-	const handleNewSession = React.useCallback((event: CustomEvent<App.Session>) => {
-		setSession(event.detail)
+	const handleNewSession = React.useCallback((event: Event) => {
+		setSession((event as CustomEvent<App.Session>).detail)
 	}, [])
 
 	React.useEffect(() => {

package/vite/index.js

@@ -17,7 +17,7 @@ try {
   reactStreamingServerPath = path.join(pkgDir, "dist/server/index.node-and-web.js");
 } catch {
 }
-function vite_default(ctx) {
+function index_default(ctx) {
   let manifest;
   let viteEnv;
   let devServer = false;
@@ -73,7 +73,7 @@ function vite_default(ctx) {
       };
       if (env.command === "build" && ctx.adapter && ctx.adapter.includePaths) {
         const extra = typeof ctx.adapter.includePaths === "function" ? ctx.adapter.includePaths({ config: ctx.config }) : ctx.adapter.includePaths;
-        Object.assign(conf.build.rollupOptions.input, extra);
+        Object.assign(conf.build.rollupOptions.input ?? {}, extra);
       }
       for (const [id, page] of Object.entries(manifest.pages)) {
         ;
@@ -100,7 +100,9 @@ function vite_default(ctx) {
       }
       if (cfCache === null) {
         try {
-          cfCache = ctx.db.prepare("SELECT type, field, fragment FROM component_fields").all();
+          cfCache = ctx.db.all(
+            "SELECT type, field, fragment FROM component_fields"
+          );
         } catch {
           cfCache = [];
         }
@@ -213,7 +215,7 @@ mount_static_app(App, manifest)
             body: await getBody(req)
           } : void 0
         );
-        let documentPremable = `<script type="module" src="/@vite/client" async=""><\/script>`;
+        let documentPremable = `<script type="module" src="/@vite/client" async=""></script>`;
         try {
           const transformed = await server.transformIndexHtml(
             req.url,
@@ -280,5 +282,5 @@ function getBody(request) {
   });
 }
 export {
-  vite_default as default
+  index_default as default
 };

package/vite/transform.js

@@ -54,11 +54,9 @@ async function transform_file(page, cfRows) {
             Field(fieldNode) {
               const parentType = typeInfo.getParentType();
               const typeName = parentType?.name;
-              if (!typeName)
-                return;
+              if (!typeName) return;
               const fragmentName = cfMap[typeName]?.[fieldNode.name.value];
-              if (!fragmentName)
-                return;
+              if (!fragmentName) return;
               const entryPointPath = componentField_unit_path(
                 page.config,
                 fragmentName