@qzsy/vinext 0.1.7

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-bfcache-identity.d.ts

@@ -0,0 +1,36 @@
+import { AppElements, AppElementsWire } from "./app-elements-wire.js";
+import { BfcacheIdMap } from "./app-history-state.js";
+
+//#region src/server/app-bfcache-identity.d.ts
+type BfcacheStateKeyMap = Readonly<Record<string, string>>;
+type InitialBfcacheMaps = Readonly<{
+  bfcacheIds: BfcacheIdMap;
+  stateKeys: BfcacheStateKeyMap;
+}>;
+type AppElementsMetadata = ReturnType<typeof AppElementsWire.readMetadata>;
+declare function createInitialBfcacheIdMap(elements: AppElements): BfcacheIdMap;
+declare function createBfcacheSegmentStateKeyMap(options: {
+  elements: AppElements;
+  pathname: string;
+}): BfcacheStateKeyMap;
+declare function createInitialBfcacheMaps(options: {
+  elements: AppElements;
+  metadata: AppElementsMetadata;
+  pathname: string;
+}): InitialBfcacheMaps;
+declare function createNextBfcacheIdMap(options: {
+  current: BfcacheIdMap;
+  currentElements: AppElements;
+  currentPathname: string;
+  elements: AppElements;
+  nextPathname: string;
+  restored?: BfcacheIdMap | null;
+  reuseCurrent?: boolean;
+}): BfcacheIdMap;
+declare function preserveBfcacheIdsForMergedElements(options: {
+  elements: AppElements;
+  next: BfcacheIdMap;
+  previous: BfcacheIdMap;
+}): BfcacheIdMap;
+//#endregion
+export { BfcacheStateKeyMap, InitialBfcacheMaps, createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createInitialBfcacheMaps, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements };

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

@@ -0,0 +1,156 @@
+import { countConsumedPathnameSegments, isInvisibleSegment, normalizePathnameForRouteMatch, splitPathSegments } from "../routing/utils.js";
+import { normalizePath } from "./normalize-path.js";
+import { AppElementsWire } from "./app-elements-wire.js";
+import "./app-elements.js";
+import "./app-bfcache-id.js";
+//#region src/server/app-bfcache-identity.ts
+let nextBfcacheId = 0;
+function rememberBfcacheId(value) {
+	const match = /^_b_(\d+)_$/.exec(value);
+	if (!match) return;
+	nextBfcacheId = Math.max(nextBfcacheId, Number(match[1]));
+}
+function mintBfcacheId() {
+	nextBfcacheId += 1;
+	return `_b_${nextBfcacheId}_`;
+}
+function getVisibleTreePathSegments(treePath) {
+	return splitPathSegments(treePath).filter((segment) => !isInvisibleSegment(segment));
+}
+function getTreePathIdentityPrefix(pathname, treePath) {
+	const pathnameSegments = splitPathSegments(pathname);
+	const consumedPathnameSegments = countConsumedPathnameSegments(getVisibleTreePathSegments(treePath), pathnameSegments.length);
+	if (consumedPathnameSegments === 0) return "/";
+	return `/${pathnameSegments.slice(0, consumedPathnameSegments).join("/")}`;
+}
+function indexAppElementsMetadata(metadata) {
+	const slotBindingsBySlotId = /* @__PURE__ */ new Map();
+	for (const binding of metadata.slotBindings) slotBindingsBySlotId.set(binding.slotId, binding);
+	return {
+		metadata,
+		slotBindingsBySlotId
+	};
+}
+function readAppElementsMetadata(elements) {
+	let metadata;
+	try {
+		metadata = AppElementsWire.readMetadata(elements);
+	} catch {
+		return null;
+	}
+	return indexAppElementsMetadata(metadata);
+}
+function parseBfcacheSegmentKey(id) {
+	const parsed = AppElementsWire.parseElementKey(id);
+	return parsed !== null && parsed.kind !== "route" ? parsed : null;
+}
+function createActiveSlotIdentity(id, parsed) {
+	const activeSlotBinding = parsed?.slotBindingsBySlotId.get(id);
+	if (activeSlotBinding?.activeRouteId != null) return `${id}@${activeSlotBinding.activeRouteId}`;
+	const interception = parsed?.metadata.interception;
+	if (interception?.slotId !== id) return null;
+	return `${id}@${interception.targetRouteId}`;
+}
+/**
+* Derive BFCache identity from AppElements wire keys. Keep wire-key parsing
+* contained here until vinext has a route-manifest authority equivalent to
+* Next.js CacheNode or segment-cache state.
+*/
+function createBfcacheSegmentIdentity(id, parsed, options) {
+	if (parsed.kind === "page") return `${id}@${options.pathname}`;
+	if (parsed.kind === "slot") {
+		const activeSlotIdentity = createActiveSlotIdentity(id, options.metadata);
+		if (activeSlotIdentity !== null) return activeSlotIdentity;
+		return `${id}@${getTreePathIdentityPrefix(options.pathname, parsed.treePath)}`;
+	}
+	if (parsed.kind === "layout" || parsed.kind === "template") return `${id}@${getTreePathIdentityPrefix(options.pathname, parsed.treePath)}`;
+	return null;
+}
+function collectBfcacheSegmentIdCandidates(elements, metadata = readAppElementsMetadata(elements)) {
+	const ids = new Set(Object.keys(elements));
+	for (const layoutId of metadata?.metadata.layoutIds ?? []) ids.add(layoutId);
+	return ids;
+}
+function createInitialBfcacheIdMap(elements) {
+	const bfcacheIds = {};
+	for (const id of collectBfcacheSegmentIdCandidates(elements)) if (parseBfcacheSegmentKey(id) !== null) bfcacheIds[id] = "0";
+	return bfcacheIds;
+}
+function normalizeBfcachePathname(pathname) {
+	const normalized = normalizePath(normalizePathnameForRouteMatch(pathname));
+	return normalized.length > 1 ? normalized.replace(/\/$/, "") : normalized;
+}
+function createBfcacheSegmentStateKeyMap(options) {
+	const metadata = readAppElementsMetadata(options.elements);
+	const normalizedPathname = normalizeBfcachePathname(options.pathname);
+	const stateKeys = {};
+	for (const id of collectBfcacheSegmentIdCandidates(options.elements, metadata)) {
+		const parsed = parseBfcacheSegmentKey(id);
+		if (parsed === null) continue;
+		const stateKey = createBfcacheSegmentIdentity(id, parsed, {
+			metadata,
+			pathname: normalizedPathname
+		});
+		if (stateKey !== null) stateKeys[id] = stateKey;
+	}
+	return stateKeys;
+}
+function createInitialBfcacheMaps(options) {
+	const metadata = indexAppElementsMetadata(options.metadata);
+	const ids = collectBfcacheSegmentIdCandidates(options.elements, metadata);
+	const normalizedPathname = normalizeBfcachePathname(options.pathname);
+	const bfcacheIds = {};
+	const stateKeys = {};
+	for (const id of ids) {
+		const parsed = parseBfcacheSegmentKey(id);
+		if (parsed === null) continue;
+		bfcacheIds[id] = "0";
+		const stateKey = createBfcacheSegmentIdentity(id, parsed, {
+			metadata,
+			pathname: normalizedPathname
+		});
+		if (stateKey !== null) stateKeys[id] = stateKey;
+	}
+	return {
+		bfcacheIds,
+		stateKeys
+	};
+}
+function createNextBfcacheIdMap(options) {
+	const current = options.reuseCurrent === false ? {} : options.current;
+	for (const value of Object.values(current)) rememberBfcacheId(value);
+	for (const value of Object.values(options.restored ?? {})) rememberBfcacheId(value);
+	const currentMetadata = readAppElementsMetadata(options.currentElements);
+	const nextMetadata = readAppElementsMetadata(options.elements);
+	const currentPathname = normalizeBfcachePathname(options.currentPathname);
+	const nextPathname = normalizeBfcachePathname(options.nextPathname);
+	const ids = {};
+	for (const id of collectBfcacheSegmentIdCandidates(options.elements, nextMetadata)) {
+		const parsed = parseBfcacheSegmentKey(id);
+		if (parsed === null) continue;
+		const currentValue = createBfcacheSegmentIdentity(id, parsed, {
+			metadata: currentMetadata,
+			pathname: currentPathname
+		}) === createBfcacheSegmentIdentity(id, parsed, {
+			metadata: nextMetadata,
+			pathname: nextPathname
+		}) ? current[id] : void 0;
+		const value = options.restored?.[id] ?? currentValue ?? mintBfcacheId();
+		ids[id] = value;
+		rememberBfcacheId(value);
+	}
+	return ids;
+}
+function preserveBfcacheIdsForMergedElements(options) {
+	const ids = {};
+	for (const id of collectBfcacheSegmentIdCandidates(options.elements)) {
+		if (parseBfcacheSegmentKey(id) === null) continue;
+		const value = options.next[id] ?? options.previous[id];
+		if (value === void 0) continue;
+		ids[id] = value;
+		rememberBfcacheId(value);
+	}
+	return ids;
+}
+//#endregion
+export { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createInitialBfcacheMaps, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements };

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

@@ -0,0 +1,64 @@
+import { ServerActionResultFacts } from "./navigation-planner.js";
+
+//#region src/server/app-browser-action-result.d.ts
+type AppBrowserServerActionResult<TRoot> = {
+  root?: TRoot;
+  returnValue?: {
+    ok: boolean;
+    data: unknown;
+  };
+};
+type ServerActionRevalidationKind = "dynamicOnly" | "none" | "staticAndDynamic";
+type ServerActionInitiationSnapshot<TRouterState> = {
+  href: string;
+  navigationId: number;
+  path: string;
+  routerState: TRouterState;
+};
+/**
+ * Structural discriminator: matches on `"returnValue"` or `"root"` keys.
+ * This is safe because {@link AppWireElements} keys are prefixed (`route:`,
+ * `slot:`, `__route`, etc.) and will never collide with these property names.
+ * If the wire format ever adds a `"root"` key, this guard must be updated.
+ */
+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;
+declare function normalizeServerActionThrownValue(data: unknown, responseStatus: number): unknown;
+declare function readInvalidServerActionResponseError(response: Pick<Response, "headers" | "status" | "text">, hasRedirectLocation: boolean): Promise<Error | null>;
+type ServerActionResultResponseFactsInput = {
+  actionRedirectHref: string | null;
+  actionRedirectType: string | null;
+  clientCompatibilityId: string | null;
+  contentTypeHeader: string | null;
+  compatibilityIdHeader: string | null;
+  currentHref: string;
+  origin: string;
+  responseUrl: string | null;
+};
+/**
+ * Converts raw browser response data into the narrow facts expected by the
+ * navigation planner. This is the single place where redirect-type
+ * normalisation and RSC content-type detection happen for server-action
+ * compatibility checks.
+ */
+declare function createServerActionResultFacts(input: ServerActionResultResponseFactsInput): ServerActionResultFacts;
+declare function shouldScheduleRefreshForDiscardedServerAction(revalidation: ServerActionRevalidationKind): boolean;
+declare function createServerActionInitiationSnapshot<TRouterState>(options: {
+  href: string;
+  navigationId: number;
+  origin?: string;
+  routerState: TRouterState;
+}): ServerActionInitiationSnapshot<TRouterState>;
+type DiscardedServerActionRefreshScheduler = {
+  markNavigationSettled(): void;
+  markNavigationStart(): void;
+  schedule(): void;
+};
+type DiscardedServerActionRefreshSchedulerOptions = {
+  queueTask?: (callback: () => void) => void;
+  runRefresh: () => void;
+};
+declare function createDiscardedServerActionRefreshScheduler(options: DiscardedServerActionRefreshSchedulerOptions): DiscardedServerActionRefreshScheduler;
+//#endregion
+export { AppBrowserServerActionResult, ServerActionResultResponseFactsInput, ServerActionRevalidationKind, createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction };

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

@@ -0,0 +1,111 @@
+import { ACTION_REVALIDATED_HEADER } from "./headers.js";
+import { VINEXT_RSC_CONTENT_TYPE } 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;
+/**
+* Structural discriminator: matches on `"returnValue"` or `"root"` keys.
+* This is safe because {@link AppWireElements} keys are prefixed (`route:`,
+* `slot:`, `__route`, etc.) and will never collide with these property names.
+* If the wire format ever adds a `"root"` key, this guard must be updated.
+*/
+function isServerActionResult(value) {
+	return !!value && typeof value === "object" && ("returnValue" in value || "root" in value);
+}
+function shouldClearClientNavigationCachesForServerActionResult(result, revalidation = "none") {
+	if (revalidation !== "none") return true;
+	if (!isServerActionResult(result)) return true;
+	return result.root !== void 0;
+}
+function parseServerActionRevalidationHeader(headers) {
+	const value = headers.get(ACTION_REVALIDATED_HEADER);
+	if (!value) return "none";
+	let parsed;
+	try {
+		parsed = JSON.parse(value);
+	} catch {
+		return "none";
+	}
+	switch (parsed) {
+		case ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC: return "staticAndDynamic";
+		case ACTION_DID_REVALIDATE_DYNAMIC_ONLY: return "dynamicOnly";
+		default: return "none";
+	}
+}
+function createServerActionHttpFallbackError(status) {
+	if (status !== 401 && status !== 403 && status !== 404) 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.");
+}
+/**
+* Converts raw browser response data into the narrow facts expected by the
+* navigation planner. This is the single place where redirect-type
+* normalisation and RSC content-type detection happen for server-action
+* compatibility checks.
+*/
+function createServerActionResultFacts(input) {
+	return {
+		actionRedirectHref: input.actionRedirectHref,
+		actionRedirectType: input.actionRedirectType === "push" ? "push" : "replace",
+		clientCompatibilityId: input.clientCompatibilityId,
+		compatibilityIdHeader: input.compatibilityIdHeader,
+		currentHref: input.currentHref,
+		isRscContentType: (input.contentTypeHeader ?? "").startsWith(VINEXT_RSC_CONTENT_TYPE),
+		origin: input.origin,
+		responseUrl: input.responseUrl
+	};
+}
+function shouldScheduleRefreshForDiscardedServerAction(revalidation) {
+	return revalidation !== "none";
+}
+function createServerActionInitiationSnapshot(options) {
+	const url = options.origin === void 0 ? new URL(options.href) : new URL(options.href, options.origin);
+	return {
+		href: url.href,
+		navigationId: options.navigationId,
+		path: url.pathname + url.search,
+		routerState: options.routerState
+	};
+}
+function createDiscardedServerActionRefreshScheduler(options) {
+	const queueTask = options.queueTask ?? queueMicrotask;
+	let activeNavigationCount = 0;
+	let flushQueued = false;
+	let refreshPending = false;
+	function flush() {
+		flushQueued = false;
+		if (!refreshPending || activeNavigationCount > 0) return;
+		refreshPending = false;
+		options.runRefresh();
+	}
+	function queueFlush() {
+		if (flushQueued) return;
+		flushQueued = true;
+		queueTask(flush);
+	}
+	return {
+		markNavigationSettled() {
+			if (activeNavigationCount > 0) activeNavigationCount -= 1;
+			queueFlush();
+		},
+		markNavigationStart() {
+			activeNavigationCount += 1;
+		},
+		schedule() {
+			refreshPending = true;
+			queueFlush();
+		}
+	};
+}
+//#endregion
+export { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, 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 };

package/dist/server/app-browser-entry.d.ts

@@ -0,0 +1 @@
+export { };