vinext 0.0.54 → 0.1.0

package/dist/routing/pages-router.js

@@ -161,5 +161,3 @@ async function scanApiRoutes(pagesDir, matcher) {
 }
 //#endregion
 export { apiRouter, invalidateRouteCache, matchRoute, pagesRouter, patternToNextFormat };
-
-//# sourceMappingURL=pages-router.js.map

package/dist/routing/route-matching.d.ts

@@ -24,5 +24,4 @@ declare function matchRouteWithTrie<R extends {
   params: Record<string, string | string[]>;
 } | null;
 //#endregion
-export { createRouteTrieCache, matchRouteWithTrie };
-//# sourceMappingURL=route-matching.d.ts.map
+export { createRouteTrieCache, matchRouteWithTrie };

package/dist/routing/route-matching.js

@@ -40,5 +40,3 @@ function matchRouteWithTrie(url, routes, cache) {
 }
 //#endregion
 export { createRouteTrieCache, matchRouteWithTrie };
-
-//# sourceMappingURL=route-matching.js.map

package/dist/routing/route-pattern.d.ts

@@ -60,5 +60,4 @@ declare function normalizeStaticPathname(pathname: string): string;
  */
 declare function normalizeStaticPathsEntry(entry: StaticPathsEntry, routePattern: string): NormalizedStaticPathsEntry;
 //#endregion
-export { RoutePatternParams, StaticPathsEntry, fillRoutePatternSegments, matchRoutePattern, matchRoutePatternPrefix, normalizeStaticPathname, normalizeStaticPathsEntry, routePattern, routePatternParts };
-//# sourceMappingURL=route-pattern.d.ts.map
+export { RoutePatternParams, StaticPathsEntry, fillRoutePatternSegments, matchRoutePattern, matchRoutePatternPrefix, normalizeStaticPathname, normalizeStaticPathsEntry, routePattern, routePatternParts };

package/dist/routing/route-pattern.js

@@ -148,5 +148,3 @@ function normalizeStaticPathsEntry(entry, routePattern) {
 }
 //#endregion
 export { fillRoutePatternSegments, matchRoutePattern, matchRoutePatternPrefix, normalizeStaticPathname, normalizeStaticPathsEntry, routePattern, routePatternParts };
-
-//# sourceMappingURL=route-pattern.js.map

package/dist/routing/route-trie.d.ts

@@ -64,5 +64,4 @@ declare function trieMatch<R>(root: TrieNode<R>, urlParts: string[]): {
   params: Record<string, string | string[]>;
 } | null;
 //#endregion
-export { TrieNode, buildRouteTrie, trieMatch };
-//# sourceMappingURL=route-trie.d.ts.map
+export { TrieNode, buildRouteTrie, trieMatch };

package/dist/routing/route-trie.js

@@ -141,5 +141,3 @@ function match(node, urlParts, index, entries) {
 }
 //#endregion
 export { buildRouteTrie, trieMatch };
-
-//# sourceMappingURL=route-trie.js.map

package/dist/routing/route-validation.d.ts

@@ -7,5 +7,4 @@
 declare function patternToNextFormat(pattern: string): string;
 declare function validateRoutePatterns(patterns: readonly string[]): void;
 //#endregion
-export { patternToNextFormat, validateRoutePatterns };
-//# sourceMappingURL=route-validation.d.ts.map
+export { patternToNextFormat, validateRoutePatterns };

package/dist/routing/route-validation.js

@@ -99,5 +99,3 @@ function validateRoutePatterns(patterns) {
 }
 //#endregion
 export { patternToNextFormat, validateRoutePatterns };
-
-//# sourceMappingURL=route-validation.js.map

package/dist/routing/utils.d.ts

@@ -41,6 +41,48 @@ declare function buildParams(entries: Array<[string, string | string[]]>): Recor
  * strict normalization layer rejects them at the request boundary).
  */
 declare function decodeMatchedParams(params: Record<string, string | string[]>): void;
+/**
+ * Check whether a path segment is invisible in the URL (route groups, parallel
+ * slots, "."). Single source of truth shared by the route graph (Node) and
+ * browser-side bfcache identity logic. Lives in this browser-safe utils module
+ * so importing it does not drag node:path/node:fs into the client bundle.
+ */
+declare function isInvisibleSegment(segment: string): boolean;
+/** Split a pathname into its non-empty segments without decoding. */
+declare function splitPathSegments(pathname: string): string[];
+/**
+ * Catch-all filesystem segment, e.g. `[...slug]`. Browser-safe predicate shared
+ * with the route graph's segment parsing (dynamicParamNameFromSegment) so the
+ * bracket conventions live in one place. The length guard rejects empty names
+ * (`[...]`).
+ */
+declare function isCatchAllSegment(segment: string): boolean;
+/**
+ * Optional-catch-all filesystem segment, e.g. `[[...slug]]`. Unlike a catch-all,
+ * this matches zero or more URL segments.
+ */
+declare function isOptionalCatchAllSegment(segment: string): boolean;
+/**
+ * Count how many pathname segments a tree path's *visible* segments consume,
+ * given the total number of pathname segments available.
+ *
+ * This is the minimal pure slice of the canonical filesystem-segment →
+ * URL-segment mapping in `app-route-graph.ts` (`convertSegmentsToRouteParts`),
+ * extracted here so browser-side bfcache identity logic can share it without
+ * importing the Node-bound route graph module. `convertSegmentsToRouteParts`
+ * remains the source of truth for how each segment kind maps to a URL part.
+ *
+ * Each ordinary visible segment (static or `[x]`) consumes exactly one pathname
+ * segment. A catch-all (`[...x]`) is terminal and consumes every remaining
+ * pathname segment. An optional-catch-all (`[[...x]]`) is also terminal but may
+ * match zero segments, so it consumes only the remaining pathname segments
+ * (which is zero once preceding segments have already consumed the pathname) —
+ * never more than are actually present.
+ *
+ * @param visibleTreePathSegments URL-visible tree-path segments (callers must
+ *   pre-filter invisible segments via `isInvisibleSegment`).
+ * @param pathnameSegmentCount Total number of pathname segments available.
+ */
+declare function countConsumedPathnameSegments(visibleTreePathSegments: readonly string[], pathnameSegmentCount: number): number;
 //#endregion
-export { buildParams, compareRoutes, decodeMatchedParams, decodeRouteSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, splitPathnameForRouteMatch };
-//# sourceMappingURL=utils.d.ts.map
+export { buildParams, compareRoutes, countConsumedPathnameSegments, decodeMatchedParams, decodeRouteSegment, isCatchAllSegment, isInvisibleSegment, isOptionalCatchAllSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, splitPathSegments, splitPathnameForRouteMatch };

package/dist/routing/utils.js

@@ -125,7 +125,66 @@ function decodeMatchedParams(params) {
 		else params[key] = decodeMatchedParam(value);
 	}
 }
+/**
+* Check whether a path segment is invisible in the URL (route groups, parallel
+* slots, "."). Single source of truth shared by the route graph (Node) and
+* browser-side bfcache identity logic. Lives in this browser-safe utils module
+* so importing it does not drag node:path/node:fs into the client bundle.
+*/
+function isInvisibleSegment(segment) {
+	if (segment === ".") return true;
+	if (segment.startsWith("(") && segment.endsWith(")")) return true;
+	if (segment.startsWith("@")) return true;
+	return false;
+}
+/** Split a pathname into its non-empty segments without decoding. */
+function splitPathSegments(pathname) {
+	return pathname.split("/").filter(Boolean);
+}
+/**
+* Catch-all filesystem segment, e.g. `[...slug]`. Browser-safe predicate shared
+* with the route graph's segment parsing (dynamicParamNameFromSegment) so the
+* bracket conventions live in one place. The length guard rejects empty names
+* (`[...]`).
+*/
+function isCatchAllSegment(segment) {
+	return segment.startsWith("[...") && segment.endsWith("]") && segment.length > 5;
+}
+/**
+* Optional-catch-all filesystem segment, e.g. `[[...slug]]`. Unlike a catch-all,
+* this matches zero or more URL segments.
+*/
+function isOptionalCatchAllSegment(segment) {
+	return segment.startsWith("[[...") && segment.endsWith("]]") && segment.length > 7;
+}
+/**
+* Count how many pathname segments a tree path's *visible* segments consume,
+* given the total number of pathname segments available.
+*
+* This is the minimal pure slice of the canonical filesystem-segment →
+* URL-segment mapping in `app-route-graph.ts` (`convertSegmentsToRouteParts`),
+* extracted here so browser-side bfcache identity logic can share it without
+* importing the Node-bound route graph module. `convertSegmentsToRouteParts`
+* remains the source of truth for how each segment kind maps to a URL part.
+*
+* Each ordinary visible segment (static or `[x]`) consumes exactly one pathname
+* segment. A catch-all (`[...x]`) is terminal and consumes every remaining
+* pathname segment. An optional-catch-all (`[[...x]]`) is also terminal but may
+* match zero segments, so it consumes only the remaining pathname segments
+* (which is zero once preceding segments have already consumed the pathname) —
+* never more than are actually present.
+*
+* @param visibleTreePathSegments URL-visible tree-path segments (callers must
+*   pre-filter invisible segments via `isInvisibleSegment`).
+* @param pathnameSegmentCount Total number of pathname segments available.
+*/
+function countConsumedPathnameSegments(visibleTreePathSegments, pathnameSegmentCount) {
+	let consumed = 0;
+	for (const segment of visibleTreePathSegments) {
+		if (isCatchAllSegment(segment) || isOptionalCatchAllSegment(segment)) return Math.max(consumed, pathnameSegmentCount);
+		consumed += 1;
+	}
+	return consumed;
+}
 //#endregion
-export { buildParams, compareRoutes, decodeMatchedParams, decodeRouteSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, splitPathnameForRouteMatch };
-
-//# sourceMappingURL=utils.js.map
+export { buildParams, compareRoutes, countConsumedPathnameSegments, decodeMatchedParams, decodeRouteSegment, isCatchAllSegment, isInvisibleSegment, isOptionalCatchAllSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, splitPathSegments, splitPathnameForRouteMatch };

package/dist/server/api-handler.d.ts

@@ -9,5 +9,4 @@ import { IncomingMessage, ServerResponse } from "node:http";
  */
 declare function handleApiRoute(runner: ModuleImporter, req: IncomingMessage, res: ServerResponse, url: string, apiRoutes: Route[]): Promise<boolean>;
 //#endregion
-export { handleApiRoute };
-//# sourceMappingURL=api-handler.d.ts.map
+export { handleApiRoute };

package/dist/server/api-handler.js

@@ -264,5 +264,3 @@ async function handleApiRoute(runner, req, res, url, apiRoutes) {
 }
 //#endregion
 export { handleApiRoute };
-
-//# sourceMappingURL=api-handler.js.map

package/dist/server/app-bfcache-id.d.ts

@@ -0,0 +1,5 @@
+//#region src/server/app-bfcache-id.d.ts
+declare const INITIAL_BFCACHE_ID = "0";
+declare const PUBLIC_INITIAL_BFCACHE_ID = "_b_0_";
+//#endregion
+export { INITIAL_BFCACHE_ID, PUBLIC_INITIAL_BFCACHE_ID };

package/dist/server/app-bfcache-id.js

@@ -0,0 +1,5 @@
+//#region src/server/app-bfcache-id.ts
+const INITIAL_BFCACHE_ID = "0";
+const PUBLIC_INITIAL_BFCACHE_ID = "_b_0_";
+//#endregion
+export { INITIAL_BFCACHE_ID, PUBLIC_INITIAL_BFCACHE_ID };

package/dist/server/app-browser-action-result.d.ts

@@ -22,21 +22,14 @@ type ServerActionInitiationSnapshot<TRouterState> = {
 declare function isServerActionResult<TRoot>(value: unknown): value is AppBrowserServerActionResult<TRoot>;
 declare function shouldClearClientNavigationCachesForServerActionResult<TRoot>(result: AppBrowserServerActionResult<TRoot> | TRoot, revalidation?: ServerActionRevalidationKind): boolean;
 declare function parseServerActionRevalidationHeader(headers: Pick<Headers, "get">): ServerActionRevalidationKind;
-type ServerActionRedirectLocation = {
-  href: string;
-  internal: boolean;
-};
-/**
- * Resolve a server-action redirect target against the URL that initiated the
- * action. Dot-relative redirects intentionally resolve as if the current route
- * pathname were a directory, matching Next.js' `assignLocation()` behavior:
- * `./subpage` from `/subdir` lands on `/subdir/subpage`, not `/subpage`.
- */
-declare function resolveServerActionRedirectLocation(options: {
-  currentHref: string;
-  location: string;
-  origin: string;
-}): ServerActionRedirectLocation;
+declare function normalizeServerActionThrownValue(data: unknown, responseStatus: number): unknown;
+declare function readInvalidServerActionResponseError(response: Pick<Response, "headers" | "status" | "text">, hasRedirectLocation: boolean): Promise<Error | null>;
+declare function shouldCheckRscCompatibilityForServerActionResponse(response: Pick<Response, "headers">): boolean;
+declare function resolveServerActionRedirectCompatibilityHardNavigationTarget(options: {
+  actionRedirectHref: string | null;
+  clientCompatibilityId: string | null | undefined;
+  response: Pick<Response, "headers">;
+}): string | null;
 declare function shouldScheduleRefreshForDiscardedServerAction(revalidation: ServerActionRevalidationKind): boolean;
 declare function createServerActionInitiationSnapshot<TRouterState>(options: {
   href: string;
@@ -55,5 +48,4 @@ type DiscardedServerActionRefreshSchedulerOptions = {
 };
 declare function createDiscardedServerActionRefreshScheduler(options: DiscardedServerActionRefreshSchedulerOptions): DiscardedServerActionRefreshScheduler;
 //#endregion
-export { AppBrowserServerActionResult, ServerActionRevalidationKind, createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, isServerActionResult, parseServerActionRevalidationHeader, resolveServerActionRedirectLocation, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction };
-//# sourceMappingURL=app-browser-action-result.d.ts.map
+export { AppBrowserServerActionResult, ServerActionRevalidationKind, createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, resolveServerActionRedirectCompatibilityHardNavigationTarget, shouldCheckRscCompatibilityForServerActionResponse, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction };

package/dist/server/app-browser-action-result.js

@@ -1,4 +1,5 @@
 import { ACTION_REVALIDATED_HEADER } from "./headers.js";
+import { VINEXT_RSC_CONTENT_TYPE, isRscCompatibilityIdCompatible } from "./app-rsc-cache-busting.js";
 //#region src/server/app-browser-action-result.ts
 const ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC = 1;
 const ACTION_DID_REVALIDATE_DYNAMIC_ONLY = 2;
@@ -31,19 +32,29 @@ function parseServerActionRevalidationHeader(headers) {
 		default: return "none";
 	}
 }
-/**
-* Resolve a server-action redirect target against the URL that initiated the
-* action. Dot-relative redirects intentionally resolve as if the current route
-* pathname were a directory, matching Next.js' `assignLocation()` behavior:
-* `./subpage` from `/subdir` lands on `/subdir/subpage`, not `/subpage`.
-*/
-function resolveServerActionRedirectLocation(options) {
-	const currentUrl = new URL(options.currentHref, options.origin);
-	const redirectUrl = options.location.startsWith(".") ? new URL(options.location, `${currentUrl.origin}${currentUrl.pathname.endsWith("/") ? currentUrl.pathname : `${currentUrl.pathname}/`}`) : new URL(options.location, currentUrl.href);
-	return {
-		href: redirectUrl.href,
-		internal: redirectUrl.origin === currentUrl.origin
-	};
+function createServerActionHttpFallbackError(status) {
+	if (status < 400 || status > 599) return null;
+	const digest = status === 404 ? "NEXT_HTTP_ERROR_FALLBACK;404" : `NEXT_HTTP_ERROR_FALLBACK;${status}`;
+	const error = /* @__PURE__ */ new Error(status === 404 ? "NEXT_NOT_FOUND" : `NEXT_HTTP_ERROR_FALLBACK;${status}`);
+	return Object.assign(error, { digest });
+}
+function normalizeServerActionThrownValue(data, responseStatus) {
+	return createServerActionHttpFallbackError(responseStatus) ?? data;
+}
+async function readInvalidServerActionResponseError(response, hasRedirectLocation) {
+	const contentType = response.headers.get("content-type") ?? "";
+	if (contentType.startsWith("text/x-component") || hasRedirectLocation) return null;
+	const message = response.status >= 400 && contentType.toLowerCase().startsWith("text/plain") ? await response.text() : "An unexpected response was received from the server.";
+	return new Error(message || "An unexpected response was received from the server.");
+}
+function shouldCheckRscCompatibilityForServerActionResponse(response) {
+	return (response.headers.get("content-type") ?? "").startsWith(VINEXT_RSC_CONTENT_TYPE);
+}
+function resolveServerActionRedirectCompatibilityHardNavigationTarget(options) {
+	if (!options.actionRedirectHref) return null;
+	if (!shouldCheckRscCompatibilityForServerActionResponse(options.response)) return null;
+	if (isRscCompatibilityIdCompatible(options.response.headers.get("X-Vinext-RSC-Compatibility-Id"), options.clientCompatibilityId)) return null;
+	return options.actionRedirectHref;
 }
 function shouldScheduleRefreshForDiscardedServerAction(revalidation) {
 	return revalidation !== "none";
@@ -88,6 +99,4 @@ function createDiscardedServerActionRefreshScheduler(options) {
 	};
 }
 //#endregion
-export { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, isServerActionResult, parseServerActionRevalidationHeader, resolveServerActionRedirectLocation, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction };
-
-//# sourceMappingURL=app-browser-action-result.js.map
+export { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, resolveServerActionRedirectCompatibilityHardNavigationTarget, shouldCheckRscCompatibilityForServerActionResponse, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction };

package/dist/server/app-browser-client-reuse-manifest.d.ts

@@ -0,0 +1,12 @@
+import { DEFAULT_CLIENT_REUSE_MANIFEST_LIMITS } from "./client-reuse-manifest.js";
+import { AppRouterState } from "./app-browser-state.js";
+
+//#region src/server/app-browser-client-reuse-manifest.d.ts
+type ClientReuseManifestLimits = typeof DEFAULT_CLIENT_REUSE_MANIFEST_LIMITS;
+type VisibleAppState = Pick<AppRouterState, "elements" | "visibleCommitVersion">;
+type CreateClientReuseManifestHeaderOptions = Readonly<{
+  limits?: ClientReuseManifestLimits;
+}>;
+declare function createClientReuseManifestHeaderFromVisibleAppState(state: VisibleAppState, options?: CreateClientReuseManifestHeaderOptions): string | null;
+//#endregion
+export { createClientReuseManifestHeaderFromVisibleAppState };

package/dist/server/app-browser-client-reuse-manifest.js

@@ -0,0 +1,101 @@
+import { AppElementsWire } from "./app-elements-wire.js";
+import "./app-elements.js";
+import { DEFAULT_CACHE_VARIANT_BUDGET, buildCacheVariantWithRouteBudget } from "./cache-proof.js";
+import { DEFAULT_CLIENT_REUSE_MANIFEST_LIMITS, countUtf8Bytes, serializeClientReuseManifest } from "./client-reuse-manifest.js";
+import { createStaticLayoutClientReuseArtifactCompatibility, createStaticLayoutClientReusePayloadHash, createStaticLayoutClientReuseRouteId } from "./static-layout-client-reuse-proof.js";
+//#region src/server/app-browser-client-reuse-manifest.ts
+function capClientReuseManifestProducerLimits(limits) {
+	return {
+		...limits,
+		maxEntryCount: Math.min(limits.maxEntryCount, 8)
+	};
+}
+function serializeBoundedClientReuseManifest(input) {
+	const entries = input.entries.slice(0, input.limits.maxEntryCount);
+	let low = 1;
+	let high = entries.length;
+	let best = null;
+	while (low <= high) {
+		const size = Math.floor((low + high) / 2);
+		const serialized = serializeClientReuseManifest({
+			entries: entries.slice(0, size),
+			replayWindow: {
+				validFromVisibleCommitVersion: input.visibleCommitVersion,
+				validUntilVisibleCommitVersion: input.visibleCommitVersion
+			},
+			visibleCommitVersion: input.visibleCommitVersion
+		});
+		if (countUtf8Bytes(serialized) <= input.limits.maxManifestBytes) {
+			best = serialized;
+			low = size + 1;
+		} else high = size - 1;
+	}
+	return best;
+}
+function hasRetainedElement(elements, elementId) {
+	return Object.hasOwn(elements, elementId);
+}
+function createStaticLayoutEntry(input) {
+	const routeId = createStaticLayoutClientReuseRouteId(input.layoutId);
+	const output = {
+		kind: "layout",
+		layoutId: input.layoutId,
+		rootBoundaryId: input.artifactCompatibility.rootBoundaryId,
+		routeId
+	};
+	const candidateVariant = buildCacheVariantWithRouteBudget({
+		budget: DEFAULT_CACHE_VARIANT_BUDGET,
+		dimensions: [],
+		output,
+		routeBudget: {
+			routeId: output.routeId,
+			variantCacheKeys: []
+		}
+	});
+	if (candidateVariant.kind !== "variant") return null;
+	const artifactCompatibility = createStaticLayoutClientReuseArtifactCompatibility({
+		artifactCompatibility: input.artifactCompatibility,
+		layoutId: input.layoutId,
+		rootBoundaryId: output.rootBoundaryId,
+		routeId: output.routeId,
+		variantCacheKey: candidateVariant.variant.cacheKey
+	});
+	return {
+		artifactCompatibility,
+		id: input.layoutId,
+		payloadHash: createStaticLayoutClientReusePayloadHash({
+			artifactCompatibility,
+			layoutId: input.layoutId,
+			rootBoundaryId: output.rootBoundaryId,
+			routeId: output.routeId,
+			variantCacheKey: candidateVariant.variant.cacheKey
+		}),
+		privacy: "public",
+		variantCacheKey: candidateVariant.variant.cacheKey
+	};
+}
+function createClientReuseManifestHeaderFromVisibleAppState(state, options = {}) {
+	const limits = capClientReuseManifestProducerLimits(options.limits ?? DEFAULT_CLIENT_REUSE_MANIFEST_LIMITS);
+	const metadata = AppElementsWire.readMetadata(state.elements);
+	const entries = [];
+	for (const layoutId of metadata.layoutIds) {
+		if (entries.length >= limits.maxEntryCount) break;
+		if (layoutId.length > limits.maxEntryIdLength) continue;
+		if (metadata.layoutFlags[layoutId] !== "s") continue;
+		if (!hasRetainedElement(state.elements, layoutId)) continue;
+		if (AppElementsWire.parseElementKey(layoutId)?.kind !== "layout") continue;
+		const entry = createStaticLayoutEntry({
+			artifactCompatibility: metadata.artifactCompatibility,
+			layoutId
+		});
+		if (entry) entries.push(entry);
+	}
+	if (entries.length === 0) return null;
+	return serializeBoundedClientReuseManifest({
+		entries,
+		limits,
+		visibleCommitVersion: state.visibleCommitVersion
+	});
+}
+//#endregion
+export { createClientReuseManifestHeaderFromVisibleAppState };