@qzsy/vinext 0.1.12 → 0.1.80

package/dist/cli.js

@@ -2,14 +2,19 @@
 import { detectPackageManager, ensureViteConfigCompatibility, hasAppDir, hasViteConfig } from "./utils/project.js";
 import { formatReport, runCheck } from "./check.js";
 import { parseArgs } from "./cli-args.js";
+import { createDevServerConfigPlugin, normalizeDevServerHostname } from "./cli-dev-config.js";
+import { normalizePathSeparators } from "./utils/path.js";
 import { PHASE_PRODUCTION_BUILD } from "./shims/constants.js";
 import { createRscCompatibilityId, loadNextConfig, resolveNextConfig } from "./config/next-config.js";
 import { generateRouteTypes } from "./typegen.js";
-import { getReactUpgradeDeps, init } from "./init.js";
+import { clearPagesClientAssetsBuildMetadata } from "./build/pages-client-assets-module.js";
+import vinext from "./index.js";
 import { runPrerender } from "./build/run-prerender.js";
 import { loadDotenv } from "./config/dotenv.js";
 import { deploy, parseDeployArgs } from "./deploy.js";
-import vinext from "./index.js";
+import { getReactUpgradeDeps } from "./utils/react-version.js";
+import { init } from "./init.js";
+import { INIT_PLATFORMS, resolveInitPlatform } from "./init-platform.js";
 import { resolveVinextPackageRoot } from "./utils/vinext-root.js";
 import { emitStandaloneOutput } from "./build/standalone.js";
 import { cleanBuildOutput } from "./build/clean-output.js";
@@ -179,20 +184,20 @@ async function dev() {
 	});
 	applyViteConfigCompatibility(process.cwd());
 	const vite = await loadVite();
-	const port = parsed.port ?? 3e3;
-	const host = parsed.hostname ?? "localhost";
+	const initialPort = parsed.port ?? 3e3;
+	const initialHost = parsed.hostname ?? "localhost";
 	let lockfile;
 	const startedAt = Date.now();
 	if (process.env.VINEXT_NO_DEV_LOCK !== "1") {
 		const root = process.cwd();
-		const initialDisplayHost = host === "0.0.0.0" ? "localhost" : host;
+		const initialDisplayHost = initialHost === "0.0.0.0" ? "localhost" : initialHost;
 		const acquired = tryAcquireLockfile({
 			root,
 			info: {
 				pid: process.pid,
-				port,
-				hostname: host,
-				appUrl: `http://${initialDisplayHost}:${port}`,
+				port: initialPort,
+				hostname: initialHost,
+				appUrl: `http://${initialDisplayHost}:${initialPort}`,
 				startedAt,
 				cwd: root
 			}
@@ -208,13 +213,21 @@ async function dev() {
 		lockfile = acquired.lockfile;
 	}
 	console.log(`\n  vinext dev  (Vite ${getViteVersion()})\n`);
-	const config = buildViteConfig({ server: {
-		port,
-		host
-	} });
+	const config = buildViteConfig();
+	(config.plugins ??= []).push(createDevServerConfigPlugin(parsed));
 	let server;
 	try {
 		server = await vite.createServer(config);
+		const port = server.config.server.port ?? 3e3;
+		const host = normalizeDevServerHostname(server.config.server.host);
+		lockfile?.update({
+			pid: process.pid,
+			port,
+			hostname: host,
+			appUrl: `http://${host === "0.0.0.0" ? "localhost" : host}:${port}`,
+			startedAt,
+			cwd: process.cwd()
+		});
 		await server.listen();
 	} catch (err) {
 		lockfile?.release();
@@ -222,8 +235,10 @@ async function dev() {
 	}
 	server.printUrls();
 	if (lockfile) {
+		const configuredPort = server.config.server.port ?? 3e3;
+		const configuredHost = normalizeDevServerHostname(server.config.server.host);
 		const resolved = server.resolvedUrls?.local[0];
-		let actualPort = port;
+		let actualPort = configuredPort;
 		let appUrl;
 		if (resolved) {
 			appUrl = resolved.replace(/\/$/, "");
@@ -233,13 +248,13 @@ async function dev() {
 			} catch {}
 		} else {
 			const address = server.httpServer?.address();
-			actualPort = typeof address === "object" && address ? address.port : port;
-			appUrl = `http://${host === "0.0.0.0" ? "localhost" : host}:${actualPort}`;
+			actualPort = typeof address === "object" && address ? address.port : configuredPort;
+			appUrl = `http://${configuredHost === "0.0.0.0" ? "localhost" : configuredHost}:${actualPort}`;
 		}
 		lockfile.update({
 			pid: process.pid,
 			port: actualPort,
-			hostname: host,
+			hostname: configuredHost,
 			appUrl,
 			startedAt,
 			cwd: process.cwd()
@@ -260,7 +275,7 @@ async function buildApp() {
 	const withBuildBundlerOptions = (bundlerOptions) => viteMajorVersion >= 8 ? { rolldownOptions: bundlerOptions } : { rollupOptions: bundlerOptions };
 	console.log(`\n  vinext build  (Vite ${getViteVersion()})\n`);
 	const root = process.cwd();
-	const isApp = hasAppDir(process.cwd());
+	const isApp = hasAppDir(normalizePathSeparators(root));
 	const resolvedNextConfig = await resolveNextConfig(await loadNextConfig(root, PHASE_PRODUCTION_BUILD), root);
 	process.env.__VINEXT_SHARED_BUILD_ID = resolvedNextConfig.buildId;
 	process.env.__VINEXT_SHARED_RSC_COMPATIBILITY_ID = createRscCompatibilityId(resolvedNextConfig);
@@ -292,10 +307,13 @@ async function buildApp() {
 		outDir: distDir,
 		emptyOutDir: await loadBuildEmptyOutDir(vite, root)
 	});
-	const config = buildViteConfig({}, logger);
-	await (await vite.createBuilder(config)).buildApp();
-	if (isApp) {
-		if (hasPagesDir()) {
+	const isHybrid = isApp && hasPagesDir();
+	const pagesClientAssetsBuildSession = isHybrid ? randomBytes(16).toString("hex") : null;
+	if (pagesClientAssetsBuildSession) process.env.__VINEXT_PAGES_CLIENT_ASSETS_BUILD_SESSION = pagesClientAssetsBuildSession;
+	try {
+		const config = buildViteConfig({}, logger);
+		await (await vite.createBuilder(config)).buildApp();
+		if (isHybrid) {
 			console.log("  Building Pages Router server (hybrid)...");
 			const root = process.cwd();
 			let userTransformPlugins = [];
@@ -326,6 +344,11 @@ async function buildApp() {
 				}
 			});
 		}
+	} finally {
+		if (pagesClientAssetsBuildSession) {
+			clearPagesClientAssetsBuildMetadata(pagesClientAssetsBuildSession);
+			if (process.env.__VINEXT_PAGES_CLIENT_ASSETS_BUILD_SESSION === pagesClientAssetsBuildSession) delete process.env.__VINEXT_PAGES_CLIENT_ASSETS_BUILD_SESSION;
+		}
 	}
 	if (outputMode === "standalone") {
 		const standalone = emitStandaloneOutput({
@@ -346,14 +369,14 @@ async function buildApp() {
 		process.stdout.write("\x1B[0m");
 		console.log(`  ${label}`);
 		prerenderResult = await runPrerender({
-			root: process.cwd(),
+			root: normalizePathSeparators(process.cwd()),
 			concurrency: parsed.prerenderConcurrency
 		});
 	}
 	process.stdout.write("\x1B[0m");
 	const { printBuildReport } = await import("./build/report.js");
 	await printBuildReport({
-		root: process.cwd(),
+		root: normalizePathSeparators(process.cwd()),
 		pageExtensions: resolvedNextConfig.pageExtensions,
 		prerenderResult: prerenderResult ?? void 0
 	});
@@ -440,10 +463,9 @@ async function deployCommand() {
 }
 async function check() {
 	if (parseArgs(rawArgs).help) return printHelp("check");
-	const root = process.cwd();
 	console.log(`\n  vinext check\n`);
 	console.log("  Scanning project...\n");
-	const result = runCheck(root);
+	const result = runCheck(normalizePathSeparators(process.cwd()));
 	console.log(formatReport(result));
 }
 async function typegen() {
@@ -467,11 +489,15 @@ async function initCommand() {
 	const port = parsed.port ?? 3001;
 	const skipCheck = rawArgs.includes("--skip-check");
 	const force = rawArgs.includes("--force");
+	const platform = await resolveInitPlatform(rawArgs);
+	const platformOptions = await INIT_PLATFORMS[platform].options(rawArgs);
 	await init({
 		root: process.cwd(),
 		port,
 		skipCheck,
-		force
+		force,
+		platform,
+		cloudflare: platform === "cloudflare" ? platformOptions : void 0
 	});
 }
 function printHelp(cmd) {
@@ -568,7 +594,7 @@ function printHelp(cmd) {
     vinext deploy                              Build and deploy to production
     vinext deploy --preview                    Deploy to a preview URL
     vinext deploy --env staging                Deploy using wrangler env.staging
-    vinext deploy --dry-run                    See what files would be generated
+    vinext deploy --dry-run                    Validate setup without building or deploying
     vinext deploy --name my-app                Deploy with a custom Worker name
     vinext deploy --experimental-tpr           Enable TPR during deploy
     vinext deploy --experimental-tpr --tpr-coverage 95   Cover 95% of traffic
@@ -605,10 +631,20 @@ function printHelp(cmd) {
     -p, --port <port>    Dev server port for the vinext script (default: 3001)
     --skip-check         Skip the compatibility check step
     --force              Overwrite existing vite.config.ts
+    --platform <target>  Deployment target: cloudflare or node
+    --data-cache <type>  Cloudflare data cache: kv or none (default: kv)
+    --image-optimization <type>
+                         Cloudflare image optimization: cloudflare-images or none
     -h, --help           Show this help
 
   Examples:
-    vinext init                   Migrate with defaults
+    vinext init                   Prompt for a deployment platform
+    vinext init --platform=cloudflare  Configure Cloudflare Workers (default)
+    vinext init --platform=cloudflare --data-cache=kv
+                                Configure the default Cloudflare cache handlers
+    vinext init --platform=cloudflare --image-optimization=none
+                                Do not configure Cloudflare Images
+    vinext init --platform=node   Configure a Node deployment
     vinext init -p 4000           Use port 4000 for dev:vinext
     vinext init --force           Overwrite existing vite.config.ts
     vinext init --skip-check      Skip the compatibility report

package/dist/{server → client}/dev-error-overlay-store.d.ts

@@ -1,4 +1,4 @@
-//#region src/server/dev-error-overlay-store.d.ts
+//#region src/client/dev-error-overlay-store.d.ts
 type Source = "server" | "vite" | "uncaught" | "caught" | "window-error" | "unhandledrejection";
 type ReportedError = {
   id: number;

package/dist/{server → client}/dev-error-overlay-store.js

@@ -1,4 +1,4 @@
-//#region src/server/dev-error-overlay-store.ts
+//#region src/client/dev-error-overlay-store.ts
 const MAX_DEV_OVERLAY_ERRORS = 50;
 let snapshot = {
 	errors: [],

package/dist/{server → client}/dev-error-overlay.d.ts

@@ -1,6 +1,6 @@
 import { ReportedError, dismissOverlay } from "./dev-error-overlay-store.js";
 
-//#region src/server/dev-error-overlay.d.ts
+//#region src/client/dev-error-overlay.d.ts
 declare const DEV_ERROR_OVERLAY_HOST_ID = "__vinext_dev_error_overlay_root";
 declare const DEV_ERROR_OVERLAY_MOUNT_ID = "__vinext_dev_error_overlay_mount";
 declare function installDevErrorOverlay(): void;

package/dist/{server → client}/dev-error-overlay.js

@@ -1,11 +1,11 @@
 import { VINEXT_DEV_ERROR_RECOVERY_EVENT } from "../utils/dev-error-recovery-event.js";
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
-import { VINEXT_ORIGINAL_STACK_TRACE_ENDPOINT } from "./dev-stack-sourcemap-endpoint.js";
+import { VINEXT_ORIGINAL_STACK_TRACE_ENDPOINT } from "../utils/dev-stack-sourcemap-endpoint.js";
 import { dismissOverlay, expandOverlay, getOverlaySnapshot, minimizeOverlay, reportToOverlay, setOverlayIndex, subscribeOverlay, updateOverlayErrorStack } from "./dev-error-overlay-store.js";
 import { Fragment, useEffect, useMemo, useState, useSyncExternalStore } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 import { createRoot } from "react-dom/client";
-//#region src/server/dev-error-overlay.tsx
+//#region src/client/dev-error-overlay.tsx
 const DEV_ERROR_OVERLAY_HOST_ID = "__vinext_dev_error_overlay_root";
 const DEV_ERROR_OVERLAY_MOUNT_ID = "__vinext_dev_error_overlay_mount";
 const VITE_ERROR_HANDLER_DATA_KEY = "__vinext_vite_error_handler__";

package/dist/cloudflare/deploy-config.d.ts

@@ -0,0 +1,51 @@
+//#region src/cloudflare/deploy-config.d.ts
+declare function formatMissingCloudflarePluginError(options: {
+  isAppRouter: boolean;
+  configFile?: string;
+}): string;
+/**
+ * Check whether an existing vite.config file already imports and uses the
+ * Cloudflare Vite plugin. This is a heuristic text scan — it doesn't execute
+ * the config — so it may produce false negatives for unusual configurations.
+ *
+ * Returns true when the config both imports the package and invokes
+ * `cloudflare(...)` in the plugin list.
+ */
+declare function viteConfigHasCloudflarePlugin(root: string): boolean;
+/**
+ * Detect whether the Vite config assigns a CDN or data cache adapter — i.e. the
+ * `cdn` or `data` field of the `vinext({ cache })` option is given a value.
+ * This is a source-level check on those exact object fields, not a fuzzy scan
+ * for adapter names. Mirrors {@link viteConfigHasCloudflarePlugin}'s leniency:
+ * an unreadable or absent config is treated as configured so a deploy is never
+ * blocked on a false negative.
+ */
+declare function viteConfigHasCacheAdapter(root: string): boolean;
+declare function viteConfigHasImageAdapter(root: string): boolean;
+/**
+ * Detect whether an existing user-authored Worker entry wires up a cache
+ * backend imperatively via one of the `setCacheHandler` / `setDataCacheHandler`
+ * / `setCdnCacheAdapter` setters. These setters are deprecated in favour of the
+ * declarative `vinext({ cache })` option, but older apps that scaffolded a KV
+ * cache handler into their Worker entry must keep working — so a deploy should
+ * not be blocked when the Worker entry already configures a backend.
+ *
+ * This is a heuristic text scan (it doesn't execute the entry), mirroring
+ * {@link viteConfigHasCacheAdapter}'s leniency: an unreadable Worker entry is
+ * treated as configured so a deploy is never blocked on a false negative. A
+ * missing Worker entry returns false (nothing to inspect — defer to other
+ * checks).
+ */
+declare function workerEntryHasCacheHandler(root: string): boolean;
+/**
+ * Build the error thrown when an ISR/cached app is deployed without a cache
+ * adapter configured in the Vite config. Production deployments need a
+ * persistent cache backend; vinext no longer scaffolds one into the Worker
+ * entry, so it must be declared via `vinext({ cache })`.
+ */
+declare function formatMissingCacheAdapterError(options: {
+  configFile?: string;
+}): string;
+declare function formatImageOptimizationHint(): string;
+//#endregion
+export { formatImageOptimizationHint, formatMissingCacheAdapterError, formatMissingCloudflarePluginError, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, viteConfigHasImageAdapter, workerEntryHasCacheHandler };

package/dist/cloudflare/deploy-config.js

@@ -0,0 +1,153 @@
+import { findViteConfigPath } from "../utils/project.js";
+import { escapeRegExp } from "../utils/regex.js";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/cloudflare/deploy-config.ts
+function formatMissingCloudflarePluginError(options) {
+	const cfArg = options.isAppRouter ? "{\n      viteEnvironment: { name: \"rsc\", childEnvironments: [\"ssr\"] },\n    }" : "";
+	const configRef = options.configFile ? options.configFile : "your Vite config";
+	return `[vinext] Missing @cloudflare/vite-plugin in ${configRef}.\n\n  Cloudflare Workers builds require the cloudflare() plugin.\n  Run \`vinext init --platform=cloudflare\` to update ${configRef}.\n\n  Expected plugin shape:\n\n    cloudflare(${cfArg})`;
+}
+/**
+* Check whether an existing vite.config file already imports and uses the
+* Cloudflare Vite plugin. This is a heuristic text scan — it doesn't execute
+* the config — so it may produce false negatives for unusual configurations.
+*
+* Returns true when the config both imports the package and invokes
+* `cloudflare(...)` in the plugin list.
+*/
+function viteConfigHasCloudflarePlugin(root) {
+	const configPath = findViteConfigPath(root);
+	if (!configPath) return false;
+	try {
+		const content = fs.readFileSync(configPath, "utf-8").replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+		const requireBinding = content.match(/(?:const|let|var)\s*{([^}]*)}\s*=\s*require\s*\(\s*["']@cloudflare\/vite-plugin["']\s*\)/)?.[1];
+		if (requireBinding) {
+			const requireMatch = requireBinding.match(/(?:^|,)\s*cloudflare\s*(?::\s*([A-Za-z_$][\w$]*))?\s*(?:,|$)/);
+			if (requireMatch) {
+				const binding = requireMatch[1] ?? "cloudflare";
+				return new RegExp(`\\b${escapeRegExp(binding)}\\s*\\(`).test(content);
+			}
+		}
+		const namedImports = content.match(/import\s*{([^}]*)}\s*from\s*["']@cloudflare\/vite-plugin["']/)?.[1];
+		if (!namedImports) return false;
+		const importMatch = namedImports.match(/(?:^|,)\s*cloudflare\s*(?:as\s+([A-Za-z_$][\w$]*))?\s*(?:,|$)/);
+		if (!importMatch) return false;
+		const binding = importMatch[1] ?? "cloudflare";
+		return new RegExp(`\\b${escapeRegExp(binding)}\\s*\\(`).test(content);
+	} catch {
+		return false;
+	}
+}
+/**
+* Extract the object-literal text of the `cache:` key (the `{ ... }` passed as
+* `vinext({ cache })`) from a Vite config source, via brace matching. Returns
+* null if there is no `cache:` object literal.
+*/
+function extractCacheBlock(content) {
+	const m = /\bcache\s*:\s*\{/.exec(content);
+	if (!m) return null;
+	const open = m.index + m[0].length - 1;
+	let depth = 0;
+	for (let i = open; i < content.length; i++) {
+		const ch = content[i];
+		if (ch === "{") depth++;
+		else if (ch === "}" && --depth === 0) return content.slice(open, i + 1);
+	}
+	return null;
+}
+/**
+* Whether a `cdn` / `data` field inside the cache object is assigned a real
+* value (not absent, `undefined`, or `null`). Reads the value up to the next
+* comma / closing brace / newline, which is enough to tell an assignment like
+* `data: kvDataAdapter()` from `data: undefined`.
+*/
+function cacheFieldAssigned(cacheBlock, field) {
+	const m = new RegExp(`\\b${field}\\s*:\\s*([^,}\\n]+)`).exec(cacheBlock);
+	if (!m) return false;
+	const value = m[1].trim();
+	return value.length > 0 && value !== "undefined" && value !== "null";
+}
+/**
+* Detect whether the Vite config assigns a CDN or data cache adapter — i.e. the
+* `cdn` or `data` field of the `vinext({ cache })` option is given a value.
+* This is a source-level check on those exact object fields, not a fuzzy scan
+* for adapter names. Mirrors {@link viteConfigHasCloudflarePlugin}'s leniency:
+* an unreadable or absent config is treated as configured so a deploy is never
+* blocked on a false negative.
+*/
+function viteConfigHasCacheAdapter(root) {
+	const configPath = findViteConfigPath(root);
+	if (!configPath) return true;
+	let content;
+	try {
+		content = fs.readFileSync(configPath, "utf-8");
+	} catch {
+		return true;
+	}
+	const block = extractCacheBlock(content);
+	if (!block) return false;
+	return cacheFieldAssigned(block, "cdn") || cacheFieldAssigned(block, "data");
+}
+function viteConfigHasImageAdapter(root) {
+	const configPath = findViteConfigPath(root);
+	if (!configPath) return true;
+	try {
+		const content = fs.readFileSync(configPath, "utf-8");
+		const match = /\bimages\s*:\s*\{/.exec(content);
+		if (!match) return false;
+		const open = match.index + match[0].length - 1;
+		let depth = 0;
+		for (let index = open; index < content.length; index++) if (content[index] === "{") depth++;
+		else if (content[index] === "}" && --depth === 0) {
+			const optimizer = /\boptimizer\s*:\s*([^,}\n]+)/.exec(content.slice(open, index + 1))?.[1];
+			return Boolean(optimizer && !/^(?:undefined|null)$/.test(optimizer.trim()));
+		}
+		return false;
+	} catch {
+		return true;
+	}
+}
+/**
+* Detect whether an existing user-authored Worker entry wires up a cache
+* backend imperatively via one of the `setCacheHandler` / `setDataCacheHandler`
+* / `setCdnCacheAdapter` setters. These setters are deprecated in favour of the
+* declarative `vinext({ cache })` option, but older apps that scaffolded a KV
+* cache handler into their Worker entry must keep working — so a deploy should
+* not be blocked when the Worker entry already configures a backend.
+*
+* This is a heuristic text scan (it doesn't execute the entry), mirroring
+* {@link viteConfigHasCacheAdapter}'s leniency: an unreadable Worker entry is
+* treated as configured so a deploy is never blocked on a false negative. A
+* missing Worker entry returns false (nothing to inspect — defer to other
+* checks).
+*/
+function workerEntryHasCacheHandler(root) {
+	const candidates = [path.join(root, "worker", "index.ts"), path.join(root, "worker", "index.js")];
+	for (const candidate of candidates) {
+		if (!fs.existsSync(candidate)) continue;
+		let content;
+		try {
+			content = fs.readFileSync(candidate, "utf-8");
+		} catch {
+			return true;
+		}
+		return /\b(?:setCacheHandler|setDataCacheHandler|setCdnCacheAdapter)\s*\(/.test(content);
+	}
+	return false;
+}
+/**
+* Build the error thrown when an ISR/cached app is deployed without a cache
+* adapter configured in the Vite config. Production deployments need a
+* persistent cache backend; vinext no longer scaffolds one into the Worker
+* entry, so it must be declared via `vinext({ cache })`.
+*/
+function formatMissingCacheAdapterError(options) {
+	const configRef = options.configFile ? options.configFile : "your Vite config";
+	return `[vinext] This app uses ISR / caching but no cache adapter is configured in ${configRef}.\n\n  Production deployments need a persistent cache backend. Declare one on the\n  vinext() plugin in ${configRef}:\n\n    import { kvDataAdapter } from "@vinext/cloudflare/cache/kv-data-adapter";\n\n    export default defineConfig({\n      plugins: [\n        vinext({\n          cache: {\n            data: kvDataAdapter(), // KV-backed data cache (binding: VINEXT_KV_CACHE)\n          },\n        }),\n        cloudflare(),\n      ],\n    });\n\n  The VINEXT_KV_CACHE namespace binding is added to wrangler.jsonc for you.\n  Create the namespace with:\n\n    npx wrangler kv namespace create VINEXT_KV_CACHE`;
+}
+function formatImageOptimizationHint() {
+	return "  [vinext] next/image is served unoptimized. To enable edge image\n  optimization via Cloudflare Images, run:\n\n    vinext init --platform=cloudflare --image-optimization=cloudflare-images\n\n  This adds the imagesOptimizer() option to your Vite config and the matching\n  IMAGES binding to your Wrangler config without replacing existing settings.";
+}
+//#endregion
+export { formatImageOptimizationHint, formatMissingCacheAdapterError, formatMissingCloudflarePluginError, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, viteConfigHasImageAdapter, workerEntryHasCacheHandler };

package/dist/cloudflare/index.d.ts

@@ -1,3 +1,3 @@
-import { KVCacheHandler } from "./src/cache/kv-data-adapter.runtime.js";
+import { KVCacheHandler } from "../packages/cloudflare/src/cache/kv-data-adapter.runtime.js";
 import { TPROptions, TPRResult, runTPR } from "./tpr.js";
 export { KVCacheHandler, type TPROptions, type TPRResult, runTPR };

package/dist/cloudflare/index.js

@@ -1,3 +1,3 @@
-import { KVCacheHandler } from "./src/cache/kv-data-adapter.runtime.js";
+import { KVCacheHandler } from "../packages/cloudflare/src/cache/kv-data-adapter.runtime.js";
 import { runTPR } from "./tpr.js";
 export { KVCacheHandler, runTPR };

package/dist/cloudflare/project.d.ts

@@ -0,0 +1,41 @@
+//#region src/cloudflare/project.d.ts
+type ProjectInfo = {
+  root: string;
+  isAppRouter: boolean;
+  isPagesRouter: boolean;
+  hasViteConfig: boolean;
+  hasWranglerConfig: boolean;
+  hasWorkerEntry: boolean;
+  hasCloudflarePlugin: boolean;
+  hasRscPlugin: boolean;
+  hasWrangler: boolean;
+  projectName: string; /** Pages that use `revalidate` (ISR) */
+  hasISR: boolean; /** package.json has "type": "module" */
+  hasTypeModule: boolean; /** .mdx files detected in app/ or pages/ */
+  hasMDX: boolean; /** CodeHike is a dependency */
+  hasCodeHike: boolean; /** Native Node modules that need stubbing for Workers */
+  nativeModulesToStub: string[];
+};
+/** Check whether a wrangler config file exists in the given directory. */
+declare function hasWranglerConfig(root: string): boolean;
+/**
+ * Detect the project structure (router, config, worker entry, package name).
+ *
+ * `root` is an OS-native filesystem path.
+ */
+declare function detectProject(root: string): ProjectInfo;
+type MissingDep = {
+  name: string;
+  version: string;
+};
+/**
+ * Check if a package is resolvable from a given root directory using
+ * Node's module resolution (createRequire). Handles hoisting, pnpm
+ * symlinks, monorepos, and Yarn PnP correctly.
+ */
+declare function isPackageResolvable(root: string, packageName: string): boolean;
+declare function getMissingDeps(info: ProjectInfo, /** Override for testing — defaults to `isPackageResolvable` */
+
+_isResolvable?: (root: string, pkg: string) => boolean): MissingDep[];
+//#endregion
+export { ProjectInfo, detectProject, getMissingDeps, hasWranglerConfig, isPackageResolvable };