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

package/bin/houdini-react

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+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() {
+	if (MANUAL_BINARY_PATH && fs.existsSync(MANUAL_BINARY_PATH)) {
+		return MANUAL_BINARY_PATH;
+	}
+
+	const platformKey = PLATFORM_OVERRIDE || `${process.platform}-${process.arch}`;
+	const platformSpecificPackageName = BINARY_DISTRIBUTION_PACKAGES[platformKey];
+
+	if (!platformSpecificPackageName) {
+		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 {
+		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;
+
+		const pnpmMatch = __dirname.match(/(.+\/node_modules\/)\.pnpm\/[^/]+\/node_modules\//);
+		if (pnpmMatch) {
+			const pnpmDir = path.join(pnpmMatch[1], '.pnpm');
+			try {
+				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 {}
+		}
+
+		return path.join(__dirname, binaryName);
+	}
+}
+
+try {
+	execFileSync(getBinaryPath(), process.argv.slice(2), { stdio: 'inherit' });
+} catch (error) {
+	process.exit(error.status || 1);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "houdini-react",
-  "version": "2.0.0-next.3",
+  "version": "2.0.0-next.30",
   "description": "The React plugin for houdini",
   "keywords": [
     "typescript",
@@ -16,61 +16,85 @@
   },
   "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",
-    "scripts": "^1.0.0"
+    "@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": "^16.10.0",
-    "graphql-yoga": "^4.0.4",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
-    "react-streaming-compat": "^0.3.18",
-    "recast": "^0.23.1",
-    "rollup": "^4.39.0",
-    "use-deep-compare-effect": "^1.8.1",
-    "houdini": "^2.0.0-next.3"
+    "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.11",
+    "rollup": "^4.61.1",
+    "use-deep-compare-effect": "^1.8.1"
+  },
+  "peerDependencies": {
+    "graphql": ">=16"
   },
   "files": [
-    "build"
+    "bin",
+    "postInstall.js",
+    "runtime",
+    "server",
+    "vite"
   ],
   "exports": {
     "./package.json": "./package.json",
-    ".": {
-      "types": "./build/plugin/index.d.ts",
-      "import": "./build/plugin-esm/index.js",
-      "require": "./build/plugin-cjs/index.js"
-    },
     "./server": {
-      "types": "./build/server/index.d.ts",
-      "import": "./build/server-esm/index.js",
-      "require": "./build/server-cjs/index.js"
+      "types": "./server/index.d.ts",
+      "import": "./server/index.js"
+    },
+    "./server/*": {
+      "types": "./server/*.d.ts",
+      "import": "./server/*.js"
+    },
+    "./vite": {
+      "types": "./vite/index.d.ts",
+      "import": "./vite/index.js"
+    },
+    "./vite/*": {
+      "types": "./vite/*.d.ts",
+      "import": "./vite/*.js"
     }
   },
   "typesVersions": {
     "*": {
       "server": [
-        "build/server/index.d.ts"
+        "./server/index.d.ts"
+      ],
+      "vite": [
+        "./vite/index.d.ts"
       ]
     }
   },
-  "main": "./build/plugin-cjs/index.js",
-  "types": "./build/plugin/index.d.ts",
+  "optionalDependencies": {
+    "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"
+  },
   "scripts": {
-    "compile": "scripts build --plugin",
-    "typedefs": "scripts typedefs --plugin"
+    "compile": "scripts build-go",
+    "typedefs": "scripts typedefs --plugin --go-package",
+    "postinstall": "node postInstall.js"
+  },
+  "bin": {
+    "houdini-react": "bin/houdini-react"
   }
 }

package/postInstall.js

@@ -0,0 +1,360 @@
+const fs = require('fs')
+const path = require('path')
+const zlib = require('zlib')
+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.30'
+
+// Windows binaries end with .exe so we need to special case them.
+const binaryName = process.platform === 'win32' ? 'houdini-react.exe' : 'houdini-react'
+
+// Determine package name for this platform
+const platformSpecificPackageName = `houdini-react-${process.platform}-${process.arch}`
+
+// Compute the path we want to emit the fallback binary to
+const fallbackBinaryPath = path.join(__dirname, binaryName)
+
+// Manual binary path override support
+const MANUAL_BINARY_PATH = process.env.HOUDINI_BINARY_PATH || process.env.HOUDINI_REACT_BINARY_PATH
+
+// Package version for validation
+const packageJSON = require(path.join(__dirname, 'package.json'))
+const expectedVersion = packageJSON.version
+
+// Track if shim is still JavaScript
+let isShimJS = true
+
+function makeRequest(url) {
+	return new Promise((resolve, reject) => {
+		https
+			.get(url, (response) => {
+				if (response.statusCode >= 200 && response.statusCode < 300) {
+					const chunks = []
+					response.on('data', (chunk) => chunks.push(chunk))
+					response.on('end', () => {
+						resolve(Buffer.concat(chunks))
+					})
+				} else if (
+					response.statusCode >= 300 &&
+					response.statusCode < 400 &&
+					response.headers.location
+				) {
+					// Follow redirects
+					makeRequest(response.headers.location).then(resolve, reject)
+				} else {
+					reject(
+						new Error(
+							`npm responded with status code ${response.statusCode} when downloading the package!`
+						)
+					)
+				}
+			})
+			.on('error', (error) => {
+				reject(error)
+			})
+	})
+}
+
+function extractFileFromTarball(tarballBuffer, filepath) {
+	// Tar archives are organized in 512 byte blocks.
+	// Blocks can either be header blocks or data blocks.
+	// Header blocks contain file names of the archive in the first 100 bytes, terminated by a null byte.
+	// The size of a file is contained in bytes 124-135 of a header block and in octal format.
+	// The following blocks will be data blocks containing the file.
+	let offset = 0
+	while (offset < tarballBuffer.length) {
+		const header = tarballBuffer.subarray(offset, offset + 512)
+		offset += 512
+
+		const fileName = header.toString('utf-8', 0, 100).replace(/\0.*/g, '')
+		const fileSize = parseInt(header.toString('utf-8', 124, 136).replace(/\0.*/g, ''), 8)
+
+		if (fileName === filepath) {
+			return tarballBuffer.subarray(offset, offset + fileSize)
+		}
+
+		// Clamp offset to the uppoer multiple of 512
+		offset = (offset + fileSize + 511) & ~511
+	}
+}
+
+function installUsingNPM() {
+	// Erase "npm_config_global" so that "npm install --global" works.
+	// Otherwise this nested "npm install" will also be global, and the install
+	// will deadlock waiting for the global installation lock.
+	const env = { ...process.env, npm_config_global: undefined };
+
+	// Create a temporary directory with an empty package.json
+	const tempDir = path.join(__dirname, 'npm-install-temp');
+
+	try {
+		fs.mkdirSync(tempDir);
+		fs.writeFileSync(path.join(tempDir, 'package.json'), '{}');
+
+		// Run npm install in the temporary directory
+		child_process.execSync(
+			`npm install --loglevel=error --prefer-offline --no-audit --progress=false ${platformSpecificPackageName}@${BINARY_DISTRIBUTION_VERSION}`,
+			{ cwd: tempDir, stdio: 'pipe', env }
+		);
+
+		// Move the downloaded binary to the fallback location
+		const installedBinaryPath = path.join(tempDir, 'node_modules', platformSpecificPackageName, 'bin', binaryName);
+		fs.renameSync(installedBinaryPath, fallbackBinaryPath);
+
+		return true;
+	} catch (err) {
+		console.error(`[${packageJSON.name}] npm install fallback failed: ${err.message}`);
+		return false;
+	} finally {
+		// Clean up temporary directory
+		try {
+			removeRecursive(tempDir);
+		} catch {
+			// Ignore cleanup errors
+		}
+	}
+}
+
+function removeRecursive(dir) {
+	if (!fs.existsSync(dir)) return;
+
+	for (const entry of fs.readdirSync(dir)) {
+		const entryPath = path.join(dir, entry);
+		const stats = fs.lstatSync(entryPath);
+
+		if (stats.isDirectory()) {
+			removeRecursive(entryPath);
+		} else {
+			fs.unlinkSync(entryPath);
+		}
+	}
+
+	fs.rmdirSync(dir);
+}
+
+async function downloadBinaryFromNpm() {
+	// First try nested npm install (like esbuild does)
+	if (installUsingNPM()) {
+		console.log(`[${packageJSON.name}] Downloaded binary via npm install`);
+		return;
+	}
+
+	// Fallback to direct HTTP download
+	console.log(`[${packageJSON.name}] Trying direct download from npm registry...`);
+
+	// Download the tarball of the right binary distribution package
+	const tarballDownloadBuffer = await makeRequest(
+		`https://registry.npmjs.org/${platformSpecificPackageName}/-/${platformSpecificPackageName}-${BINARY_DISTRIBUTION_VERSION}.tgz`
+	)
+
+	const tarballBuffer = zlib.unzipSync(tarballDownloadBuffer)
+
+	// Extract binary from package and write to disk
+	fs.writeFileSync(
+		fallbackBinaryPath,
+		extractFileFromTarball(tarballBuffer, `package/bin/${binaryName}`),
+		{ mode: 0o755 } // Make binary file executable
+	)
+
+	console.log(`[${packageJSON.name}] Downloaded binary via direct download`);
+}
+
+function isPlatformSpecificPackageInstalled() {
+	try {
+		// Try to resolve the platform package itself
+		require.resolve(`${platformSpecificPackageName}/package.json`)
+		return true
+	} catch (e) {
+		// Also check if it exists as a sibling directory
+		const siblingPath = path.join(__dirname, '..', platformSpecificPackageName)
+		const siblingBinaryPath = path.join(siblingPath, 'bin', binaryName)
+		return fs.existsSync(siblingBinaryPath)
+	}
+}
+
+if (!platformSpecificPackageName) {
+	throw new Error('Platform not supported!')
+}
+
+// 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()) {
+		return
+	}
+
+	let binaryPath = null
+
+	try {
+		// Method 1: Use require.resolve to find the platform-specific package
+		const platformPackagePath = require.resolve(`${platformSpecificPackageName}/package.json`)
+		const platformPackageDir = path.dirname(platformPackagePath)
+		binaryPath = path.join(platformPackageDir, 'bin', binaryName)
+	} catch (error) {
+		// Method 2: Check if platform package is installed as a sibling directory
+		const siblingPath = path.join(__dirname, '..', platformSpecificPackageName)
+		binaryPath = path.join(siblingPath, 'bin', binaryName)
+
+		if (!fs.existsSync(binaryPath)) {
+			// Method 3: pnpm-specific structure
+			const pnpmMatch = __dirname.match(/(.+\/node_modules\/)\.pnpm\/([^\/]+)\/node_modules\//)
+			if (pnpmMatch) {
+				const [, nodeModulesRoot] = pnpmMatch
+				const pnpmDir = path.join(nodeModulesRoot, '.pnpm')
+
+				try {
+					const pnpmEntries = fs.readdirSync(pnpmDir)
+					// Look for the specific version that matches BINARY_DISTRIBUTION_VERSION
+					const expectedPnpmEntry = `${platformSpecificPackageName}@${BINARY_DISTRIBUTION_VERSION}`
+					const platformEntry = pnpmEntries.find(entry => entry === expectedPnpmEntry)
+
+					if (platformEntry) {
+						binaryPath = path.join(pnpmDir, platformEntry, 'node_modules', platformSpecificPackageName, 'bin', binaryName)
+					}
+				} catch (err) {
+					// Ignore errors
+				}
+			}
+		}
+	}
+
+	// If we found the binary, try to replace the shim with it
+	if (binaryPath && fs.existsSync(binaryPath)) {
+		// First validate the binary works correctly
+		if (!validateBinaryVersion(binaryPath)) {
+			console.error(`[${packageJSON.name}] Binary validation failed, keeping JavaScript shim`);
+			return;
+		}
+
+		const shimPath = path.join(__dirname, 'bin', packageJSON.name)
+		const tempPath = path.join(__dirname, 'bin', `${packageJSON.name}-temp`)
+
+		try {
+			// First create a hard link to avoid taking up additional disk space
+			fs.linkSync(binaryPath, tempPath)
+
+			// Then atomically replace the shim with the binary
+			fs.renameSync(tempPath, shimPath)
+
+			// Make sure it's executable
+			fs.chmodSync(shimPath, 0o755)
+
+			// Update state tracking
+			isShimJS = false
+
+			console.log(`[${packageJSON.name}] Binary optimization successful`);
+		} catch (err) {
+			console.error(`[${packageJSON.name}] Binary optimization failed: ${err.message}`);
+			// If optimization fails, clean up and continue with the shim
+			try {
+				fs.unlinkSync(tempPath)
+			} catch {}
+		}
+	}
+}
+
+function validateBinaryVersion(binaryPath) {
+	try {
+		// For our Go binaries, we just check if they execute without crashing
+		// We use -h flag which should work and exit cleanly
+		child_process.execFileSync(binaryPath, ['-h'], {
+			stdio: 'pipe',
+			timeout: 5000,
+			encoding: 'utf8'
+		});
+		return true;
+	} catch (err) {
+		// If the binary exits with code 0 or 2 (help), that's fine
+		if (err.status === 0 || err.status === 2) {
+			return true;
+		}
+		console.error(`[${packageJSON.name}] Binary validation failed: ${err.message}`);
+		return false;
+	}
+}
+
+function applyManualBinaryPathOverride(overridePath) {
+	console.log(`[${packageJSON.name}] Using manual binary path: ${overridePath}`);
+
+	const shimPath = path.join(__dirname, 'bin', packageJSON.name);
+	const shimContent = `#!/usr/bin/env node
+require('child_process').execFileSync(${JSON.stringify(overridePath)}, process.argv.slice(2), { stdio: 'inherit' });
+`;
+
+	try {
+		fs.writeFileSync(shimPath, shimContent, { mode: 0o755 });
+		isShimJS = true; // Keep as JS since it's a wrapper
+		return true;
+	} catch (err) {
+		console.error(`[${packageJSON.name}] Failed to apply manual binary override: ${err.message}`);
+		return false;
+	}
+}
+
+function isYarn() {
+	const { npm_config_user_agent } = process.env
+	if (npm_config_user_agent) {
+		return /\byarn\//.test(npm_config_user_agent)
+	}
+	return false
+}
+
+// Check for manual binary path override first
+if (MANUAL_BINARY_PATH) {
+	if (fs.existsSync(MANUAL_BINARY_PATH)) {
+		console.log(`[${packageJSON.name}] Using manual binary path override`);
+		if (applyManualBinaryPathOverride(MANUAL_BINARY_PATH)) {
+			process.exit(0);
+		}
+	} else {
+		console.warn(`[${packageJSON.name}] Ignoring invalid manual binary path: ${MANUAL_BINARY_PATH}`);
+	}
+}
+
+// Skip downloading the binary if it was already installed via optionalDependencies
+if (!isPlatformSpecificPackageInstalled()) {
+	console.log(`[${packageJSON.name}] Platform package not found, downloading binary...`);
+	downloadBinaryFromNpm().then(() => {
+		maybeOptimizePackage();
+
+		// Final validation
+		const shimPath = path.join(__dirname, 'bin', packageJSON.name);
+		if (isShimJS) {
+			// Validate the JavaScript shim can find and run the binary
+			if (!validateBinaryVersion(shimPath)) {
+				console.error(`[${packageJSON.name}] Installation may be incomplete`);
+			}
+		}
+	}).catch(err => {
+		console.error(`[${packageJSON.name}] Failed to download binary: ${err.message}`);
+		process.exit(1);
+	});
+} else {
+	console.log(`[${packageJSON.name}] Platform package found, optimizing...`);
+	maybeOptimizePackage();
+
+	// Final validation
+	const shimPath = path.join(__dirname, 'bin', packageJSON.name);
+	if (isShimJS) {
+		// Validate the JavaScript shim can find and run the binary
+		if (!validateBinaryVersion(shimPath)) {
+			console.error(`[${packageJSON.name}] Installation may be incomplete`);
+		}
+	} else {
+		// Binary was optimized, validate it directly
+		if (!validateBinaryVersion(shimPath)) {
+			console.error(`[${packageJSON.name}] Binary optimization may have failed`);
+		}
+	}
+}

package/runtime/client.ts

@@ -0,0 +1,5 @@
+import type { HoudiniClient } from '$houdini/runtime/client'
+
+// this file will be replaced by the code generation process
+
+export default (() => {}) as () => HoudiniClient

package/runtime/clientPlugin.ts

@@ -0,0 +1,17 @@
+import type { ClientPlugin } from 'houdini/runtime/client'
+
+const plugin: () => ClientPlugin = () => () => {
+	return {
+		start(ctx, { next }) {
+			next({
+				...ctx,
+				cacheParams: {
+					...ctx.cacheParams,
+					serverSideFallback: false,
+				},
+			})
+		},
+	}
+}
+
+export default plugin