vinext 1.0.0-beta.8 → 1.0.0-beta.9

package/README.md

@@ -517,6 +517,7 @@ These are deployed to Cloudflare Workers and updated on every push to `main`:
 | Nextra Docs            | Nextra docs site (MDX, App Router)                                                                               | [nextra-docs-template.vinext.workers.dev](https://nextra-docs-template.vinext.workers.dev)       |
 | App Router (minimal)   | Minimal App Router on Workers                                                                                    | [app-router-cloudflare.vinext.workers.dev](https://app-router-cloudflare.vinext.workers.dev)     |
 | Pages Router (minimal) | Minimal Pages Router on Workers                                                                                  | [pages-router-cloudflare.vinext.workers.dev](https://pages-router-cloudflare.vinext.workers.dev) |
+| Static export          | [Hybrid App/Pages Router site](examples/static-export) served as assets only                                     | [static-export.vinext.workers.dev](https://static-export.vinext.workers.dev)                     |
 | RealWorld API          | REST API routes example                                                                                          | [realworld-api-rest.vinext.workers.dev](https://realworld-api-rest.vinext.workers.dev)           |
 | Benchmarks Dashboard   | Build performance tracking over time (D1-backed)                                                                 | [vinext.dev/benchmarks](https://vinext.dev/benchmarks)                                           |
 | App Router + Nitro     | App Router deployed via Nitro (multi-platform)                                                                   | [examples/app-router-nitro](examples/app-router-nitro)                                           |
@@ -709,11 +710,26 @@ The KV data adapter reads `env[binding]` at runtime, so add the matching KV name
 ```jsonc
 {
   "cache": { "enabled": true },
+  "version_metadata": { "binding": "CF_VERSION_METADATA" },
 }
 ```
 
+The version metadata binding is required for staged discovery and warming to
+verify the uploaded Worker version. Wrangler named environments do not inherit
+`version_metadata`, so repeat it inside each `env.<name>` used for warming.
+
+`vinext-cloudflare deploy --experimental-warm-cdn-cache` performs the two-stage
+upload and makes one final cache-fill request per admitted identity by default.
+Add `--warm-cdn-certify` only to opt into a second, header-only request that
+must prove every planned entry reusable before promotion.
+
 While the data adapter can store entries and serve HIT/STALE itself, the CDN adapter delegates serving to Cloudflare's edge: the origin renders fresh responses and tags them with `Cache-Tag`, and `revalidateTag()` / `revalidatePath()` purge the edge through `ctx.cache.purge({ tags })`. See [examples/workers-cache](examples/workers-cache) for both adapters wired up together.
 
+Keep Cloudflare's incoming cache key query-sensitive when using `cdnAdapter()`.
+The two-stage cacheability manifest authorizes exact pathname + query
+identities, and a Cache Rule that ignores or normalizes query strings can serve
+an edge HIT before the Worker has a chance to enforce that identity.
+
 Each builder returns a plain, serializable `{ adapter, options }` descriptor — **it never touches the Workers runtime**, so nothing throws at build or dev time when bindings aren't available. The actual adapter (and its `env` binding lookup) is instantiated lazily on the first request.
 
 Registration is wired into **every router and runtime** — App Router and Pages Router, on Cloudflare Workers as well as the Node.js server (`vinext start`) and dev. It self-guards (instantiated once per isolate) and is resilient: if an adapter can't initialize on a given runtime (e.g. a KV binding doesn't exist on the Node server), vinext logs a warning and falls back to the default handler instead of failing requests.

package/dist/build/prerender-paths.d.ts

@@ -1,13 +1,51 @@
 import { ResolvedNextConfig } from "../config/next-config.js";
+import { CdnCacheAdapterCapabilities } from "../cache/cache-adapters-virtual.js";
 import { VinextRouteRootConfig } from "../config/prerender.js";
 //#region src/build/prerender-paths.d.ts
+type PrerenderRoutePattern = {
+  kind: "app-page" | "app-route" | "pages-page";
+  pattern: string;
+  /** Closed-world safety facts for probe coordinator optimizations. */
+  cacheabilityProbe?: {
+    canPrunePattern: boolean;
+    /** HTML pathname shared by alternate representations of this route. */
+    concretePathname?: string;
+  };
+};
 type PrerenderPathManifest = {
+  /** App Page HTML paths after hybrid route ownership has been resolved. */
+  appPaths?: string[];
+  basePath?: string;
   buildId?: string;
+  /** Opaque per-build identity emitted by CDN adapter page responses. */
+  buildIdentity?: string;
+  deploymentId?: string;
+  /** Opaque per-build identity emitted by RSC responses. */
+  rscBuildId?: string;
+  responseVary?: CdnCacheAdapterCapabilities["responseVary"];
+  /** App Router paths discovered without rendering their page responses. */
+  rscPaths?: string[];
+  /** Statically eligible App Route Handler request paths. */
+  routeHandlerPaths?: string[];
+  /** App Router paths with an ordinary main-tree loading boundary. */
+  loadingShellPaths?: string[];
+  /** Pages Router paths selected by the existing HTML warm discovery pass. */
+  pagesPaths?: string[];
+  /** Pages Router JSON data identities corresponding to discovered static paths. */
+  pagesDataPaths?: string[];
+  /** Public paths omitted because configured routes can replace their page response. */
+  excludedWarmPaths?: string[];
+  /** Static dynamic-route patterns with no build-discovered concrete path. */
+  fallbackRoutePatterns?: PrerenderRoutePattern[];
+  /** Resolved route ownership for grouping cacheability probes without re-matching paths. */
+  routePatterns?: Record<string, PrerenderRoutePattern>;
   trailingSlash?: boolean;
   paths: string[];
 };
 declare const PRERENDER_PATH_DISCOVERY_ENV = "__VINEXT_PRERENDER_PATH_DISCOVERY";
 declare const PRERENDER_PATHS_MANIFEST = "vinext-prerender-paths.json";
+declare const DEFAULT_REMOTE_PATH_DISCOVERY_RETRY_DELAY_MS = 1000;
+declare const DEFAULT_REMOTE_PATH_DISCOVERY_PHASE_TIMEOUT_MS = 120000;
 type EmitPrerenderPathManifestOptions = {
   root: string;
   /** Fully resolved Next.js config. Loaded from disk when omitted. */
@@ -17,7 +55,18 @@ type EmitPrerenderPathManifestOptions = {
   routeRootConfig?: VinextRouteRootConfig | null;
   pagesBundlePath?: string;
   rscBundlePath?: string;
+  buildIdentity?: CdnCacheAdapterCapabilities["buildIdentity"];
+  responseVary?: CdnCacheAdapterCapabilities["responseVary"];
+  /** Execute dynamic path hooks against an already-uploaded Worker. */
+  pathDiscoveryTarget?: {
+    baseUrl: string;
+    headers?: HeadersInit;
+    /** Retry transient staged-version routing responses before failing discovery. */
+    phaseTimeoutMs?: number;
+    retries?: number;
+    retryDelayMs?: number;
+  };
 };
 declare function emitPrerenderPathManifest(options: EmitPrerenderPathManifestOptions): Promise<PrerenderPathManifest | null>;
 //#endregion
-export { PRERENDER_PATHS_MANIFEST, PRERENDER_PATH_DISCOVERY_ENV, PrerenderPathManifest, emitPrerenderPathManifest };
+export { DEFAULT_REMOTE_PATH_DISCOVERY_PHASE_TIMEOUT_MS, DEFAULT_REMOTE_PATH_DISCOVERY_RETRY_DELAY_MS, PRERENDER_PATHS_MANIFEST, PRERENDER_PATH_DISCOVERY_ENV, PrerenderPathManifest, PrerenderRoutePattern, emitPrerenderPathManifest };