vinext 1.0.0-beta.8 → 1.0.0

package/dist/shims/script-nonce-context.d.ts

@@ -1,10 +1,12 @@
 import React from "react";
 //#region src/shims/script-nonce-context.d.ts
-declare const ScriptNonceContext: React.Context<string | undefined> | null;
-declare function ScriptNonceProvider(props: React.PropsWithChildren<{
+export declare const ScriptNonceContext: React.Context<string | undefined> | null;
+export declare const InitialStylesheetContext: React.Context<ReadonlySet<string> | undefined> | null;
+export declare function ScriptNonceProvider(props: React.PropsWithChildren<{
   nonce?: string;
+  initialStylesheetHrefs?: ReadonlySet<string>;
 }>): React.ReactElement;
-declare function withScriptNonce(element: React.ReactElement, nonce?: string): React.ReactElement;
-declare function useScriptNonce(): string | undefined;
-//#endregion
-export { ScriptNonceContext, ScriptNonceProvider, useScriptNonce, withScriptNonce };
+export declare function withScriptNonce(element: React.ReactElement, nonce?: string, initialStylesheetHrefs?: ReadonlySet<string>): React.ReactElement;
+export declare function useScriptNonce(): string | undefined;
+export declare function useInitialStylesheetHrefs(): ReadonlySet<string> | undefined;
+//#endregion

package/dist/shims/script-nonce-context.js

@@ -1,13 +1,18 @@
 import React from "react";
 //#region src/shims/script-nonce-context.tsx
 const ScriptNonceContext = typeof React.createContext === "function" ? React.createContext(void 0) : null;
+const InitialStylesheetContext = typeof React.createContext === "function" ? React.createContext(void 0) : null;
 function ScriptNonceProvider(props) {
-	if (!ScriptNonceContext) return React.createElement(React.Fragment, null, props.children);
-	return React.createElement(ScriptNonceContext.Provider, { value: props.nonce }, props.children);
+	let children = props.children;
+	if (InitialStylesheetContext) children = React.createElement(InitialStylesheetContext.Provider, { value: props.initialStylesheetHrefs }, children);
+	return ScriptNonceContext ? React.createElement(ScriptNonceContext.Provider, { value: props.nonce }, children) : React.createElement(React.Fragment, null, children);
 }
-function withScriptNonce(element, nonce) {
-	if (!nonce || !ScriptNonceContext) return element;
-	return React.createElement(ScriptNonceProvider, { nonce }, element);
+function withScriptNonce(element, nonce, initialStylesheetHrefs) {
+	if (!nonce && !initialStylesheetHrefs) return element;
+	return React.createElement(ScriptNonceProvider, {
+		nonce,
+		initialStylesheetHrefs
+	}, element);
 }
 function createScriptNonceHook(context) {
 	if (!context || typeof React.useContext !== "function") return function useScriptNonceFromContext() {};
@@ -16,8 +21,12 @@ function createScriptNonceHook(context) {
 	};
 }
 const useScriptNonceFromContext = createScriptNonceHook(ScriptNonceContext);
+const useInitialStylesheetsFromContext = InitialStylesheetContext ? () => React.useContext(InitialStylesheetContext) : () => void 0;
 function useScriptNonce() {
 	return useScriptNonceFromContext();
 }
+function useInitialStylesheetHrefs() {
+	return useInitialStylesheetsFromContext();
+}
 //#endregion
-export { ScriptNonceContext, ScriptNonceProvider, useScriptNonce, withScriptNonce };
+export { InitialStylesheetContext, ScriptNonceContext, ScriptNonceProvider, useInitialStylesheetHrefs, useScriptNonce, withScriptNonce };

package/dist/shims/script.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
 //#region src/shims/script.d.ts
-type ScriptProps = React.ScriptHTMLAttributes<HTMLScriptElement> & {
+export type ScriptProps = React.ScriptHTMLAttributes<HTMLScriptElement> & {
   /** Script source URL */
   src?: string;
   /** Loading strategy. Default: "afterInteractive" */
@@ -41,11 +41,11 @@ type ScriptProps = React.ScriptHTMLAttributes<HTMLScriptElement> & {
 /**
  * Load a script imperatively (outside of React).
  */
-declare function handleClientScriptLoad(props: ScriptProps): void;
+export declare function handleClientScriptLoad(props: ScriptProps): void;
 /**
  * Initialize multiple scripts at once (called during app bootstrap).
  */
-declare function initScriptLoader(scripts: ScriptProps[]): void;
+export declare function initScriptLoader(scripts: ScriptProps[]): void;
 declare function Script(props: ScriptProps): React.ReactElement | null;
 //#endregion
-export { ScriptProps, Script as default, handleClientScriptLoad, initScriptLoader };
+export { Script as default };

package/dist/shims/script.js

@@ -301,13 +301,15 @@ function Script(props) {
 				fireReadyWhenAlreadyLoaded: true
 			});
 		};
-		if (strategy === "lazyOnload") if (document.readyState === "complete") if (typeof requestIdleCallback === "function") requestIdleCallback(load);
-		else setTimeout(load, 1);
-		else window.addEventListener("load", () => {
-			if (typeof requestIdleCallback === "function") requestIdleCallback(load);
-			else setTimeout(load, 1);
-		});
-		else load();
+		if (strategy === "lazyOnload") {
+			if (document.readyState === "complete") {
+				if (typeof requestIdleCallback === "function") requestIdleCallback(load);
+				else setTimeout(load, 1);
+			} else window.addEventListener("load", () => {
+				if (typeof requestIdleCallback === "function") requestIdleCallback(load);
+				else setTimeout(load, 1);
+			});
+		} else load();
 	}, [
 		src,
 		id,

package/dist/shims/search-params-gate.d.ts

@@ -0,0 +1,35 @@
+//#region src/shims/search-params-gate.d.ts
+/**
+ * Per-request gate for SSR `useSearchParams()` in a cache-candidate render.
+ *
+ * A candidate render may be stored under a query-free key, so the query can
+ * only reach its output once the render is known to be uncacheable. Each call
+ * waits until the gate is decided, once per request:
+ *
+ * - `"real"`: the render used a dynamic API, so it won't be stored. Calls read
+ *   the real query, as in a Next.js dynamic render.
+ * - `"bailout"`: the render settled without one. Calls throw
+ *   `BailoutToCSRError`, so React client-renders the nearest Suspense boundary,
+ *   as in Next.js's static HTML.
+ */
+export type SearchParamsGateDecision = "real" | "bailout";
+export type SearchParamsGate = {
+  decision: SearchParamsGateDecision | null;
+  /**
+   * Resolves once the gate is decided. It carries React's thenable status
+   * fields, so `use()` reads a decided gate without suspending.
+   */
+  decided: Promise<void>;
+};
+export type SearchParamsGateController = {
+  gate: SearchParamsGate;
+  /** Decide `"real"` unless the gate is already decided. */
+  open(): void;
+  /** Decide `"bailout"` unless the gate is already decided. */
+  settle(): void;
+};
+export declare function createSearchParamsGate(options: {
+  /** Runs when the gate opens, so real values always mark the render dynamic. */
+  onOpen: () => void;
+}): SearchParamsGateController;
+//#endregion

package/dist/shims/search-params-gate.js

@@ -0,0 +1,32 @@
+//#region src/shims/search-params-gate.ts
+function createSearchParamsGate(options) {
+	let resolve;
+	const decided = new Promise((resolvePromise) => {
+		resolve = resolvePromise;
+	});
+	const thenable = decided;
+	thenable.status = "pending";
+	const gate = {
+		decision: null,
+		decided
+	};
+	const decide = (decision) => {
+		if (gate.decision !== null) return false;
+		gate.decision = decision;
+		thenable.status = "fulfilled";
+		thenable.value = void 0;
+		resolve();
+		return true;
+	};
+	return {
+		gate,
+		open() {
+			if (decide("real")) options.onOpen();
+		},
+		settle() {
+			decide("bailout");
+		}
+	};
+}
+//#endregion
+export { createSearchParamsGate };

package/dist/shims/server.d.ts

@@ -1,3 +1,4 @@
+import { UserAgent, userAgent, userAgentFromString } from "./user-agent.js";
 //#region src/shims/server.d.ts
 /**
  * next/server shim
@@ -10,8 +11,8 @@
  * rather than bug-for-bug parity with Next.js internals.
  */
 /** @deprecated Import ImageResponse from `next/og` instead. */
-declare function ImageResponse(): never;
-type RequestInit = globalThis.RequestInit & {
+export declare function ImageResponse(): never;
+export type RequestInit = globalThis.RequestInit & {
   nextConfig?: {
     basePath?: string;
     i18n?: {
@@ -29,7 +30,7 @@ type RequestInit = globalThis.RequestInit & {
   signal?: AbortSignal;
   duplex?: "half";
 };
-declare class NextRequest extends Request {
+export declare class NextRequest extends Request {
   private _nextUrl;
   private _url;
   private _cookies;
@@ -62,7 +63,7 @@ declare class NextRequest extends Request {
    */
   get buildId(): string | undefined;
 }
-declare class NextResponse<_Body = unknown> extends Response {
+export declare class NextResponse<_Body = unknown> extends Response {
   private _cookies;
   constructor(body?: BodyInit | null, init?: ResponseInit);
   get cookies(): ResponseCookies;
@@ -89,7 +90,7 @@ declare class NextResponse<_Body = unknown> extends Response {
    */
   static next(init?: MiddlewareResponseInit): NextResponse;
 }
-type NextURLConfig = {
+export type NextURLConfig = {
   basePath?: string;
   nextConfig?: {
     i18n?: {
@@ -110,7 +111,7 @@ type NextURLConfig = {
     trailingSlash?: boolean;
   };
 };
-declare class NextURL {
+export declare class NextURL {
   /** Internal URL stores the pathname WITHOUT basePath or locale prefix. */
   private _url;
   /**
@@ -201,7 +202,7 @@ type CookieEntry = {
   name: string;
   value: string;
 };
-declare class RequestCookies {
+export declare class RequestCookies {
   private _headers;
   private _parsed;
   constructor(headers: Headers);
@@ -217,9 +218,9 @@ declare class RequestCookies {
   private _syncHeader;
   [Symbol.iterator](): MapIterator<[string, CookieEntry]>;
 }
-declare function sealRequestHeaders(headers: Headers): Headers;
-declare function sealRequestCookies(cookies: RequestCookies): RequestCookies;
-declare class ResponseCookies {
+export declare function sealRequestHeaders(headers: Headers): Headers;
+export declare function sealRequestCookies(cookies: RequestCookies): RequestCookies;
+export declare class ResponseCookies {
   private _headers;
   /** Internal map keyed by cookie name — single source of truth. */
   private _parsed;
@@ -255,18 +256,18 @@ type CookieOptions = {
   priority?: "low" | "medium" | "high";
 };
 type ResponseCookieEntry = CookieEntry & CookieOptions;
-type MiddlewareResponseInit = {
+export type MiddlewareResponseInit = {
   request?: {
     headers?: Headers;
   };
 } & ResponseInit;
-type NextMiddlewareResult = NextResponse | Response | null | undefined | void;
-type NextMiddleware = (request: NextRequest, event: NextFetchEvent) => NextMiddlewareResult | Promise<NextMiddlewareResult>;
+export type NextMiddlewareResult = NextResponse | Response | null | undefined | void;
+export type NextMiddleware = (request: NextRequest, event: NextFetchEvent) => NextMiddlewareResult | Promise<NextMiddlewareResult>;
 /**
  * Minimal NextFetchEvent — extends FetchEvent where available,
  * otherwise provides the waitUntil pattern standalone.
  */
-declare class NextFetchEvent {
+export declare class NextFetchEvent {
   sourcePage: string;
   private _waitUntilPromises;
   constructor(params: {
@@ -285,39 +286,6 @@ declare class NextFetchEvent {
   /** Drain all waitUntil promises. Returns a single promise that settles when all are done. */
   drainWaitUntil(): Promise<PromiseSettledResult<unknown>[]>;
 }
-/**
- * Parse user agent string. Minimal implementation — for full UA parsing,
- * apps should use a dedicated library like `ua-parser-js`.
- */
-declare function userAgentFromString(ua: string | undefined): UserAgent;
-declare function userAgent({ headers }: {
-  headers: Headers;
-}): UserAgent;
-type UserAgent = {
-  isBot: boolean;
-  ua: string;
-  browser: {
-    name?: string;
-    version?: string;
-    major?: string;
-  };
-  device: {
-    model?: string;
-    type?: string;
-    vendor?: string;
-  };
-  engine: {
-    name?: string;
-    version?: string;
-  };
-  os: {
-    name?: string;
-    version?: string;
-  };
-  cpu: {
-    architecture?: string;
-  };
-};
 /**
  * after() — schedule work after the response is sent.
  *
@@ -328,18 +296,18 @@ type UserAgent = {
  * Throws when called inside a cached scope — request-specific
  * side-effects must not leak into cached results.
  */
-declare function after<T>(task: Promise<T> | (() => T | Promise<T>)): void;
+export declare function after<T>(task: Promise<T> | (() => T | Promise<T>)): void;
 /**
  * connection() — signals that the response requires a live connection
  * (not a static/cached response). Opts the page out of ISR caching
  * and sets Cache-Control: no-store on the response.
  */
-declare function connection(): Promise<void>;
+export declare function connection(): Promise<void>;
 /**
  * URLPattern re-export — used in middleware for route matching.
  * Available natively in Node 20+, Cloudflare Workers, Deno.
  * Falls back to urlpattern-polyfill if the global is not available.
  */
-declare const URLPattern: typeof globalThis.URLPattern;
+export declare const URLPattern: typeof globalThis.URLPattern;
 //#endregion
-export { ImageResponse, MiddlewareResponseInit, NextFetchEvent, NextMiddleware, NextMiddlewareResult, NextRequest, NextResponse, NextURL, NextURLConfig, RequestCookies, RequestInit, ResponseCookies, URLPattern, UserAgent, after, connection, sealRequestCookies, sealRequestHeaders, userAgent, userAgentFromString };
+export { type UserAgent, userAgent, userAgentFromString };

package/dist/shims/server.js

@@ -1,12 +1,13 @@
 import { bindRequestContextSnapshot, getRequestContext, isInsideUnifiedScope, queueAfterCallback, trackAfterPromise } from "./unified-request-context.js";
-import { hasBasePath, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
+import { MIDDLEWARE_SET_COOKIE_HEADER } from "../utils/protocol-headers.js";
+import { encodeMiddlewareRequestHeaders } from "../utils/middleware-request-headers.js";
 import { parseEdgeRequestCookieHeader } from "../utils/parse-cookie.js";
+import { hasBasePath, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
 import { getRequestExecutionContext } from "./request-context.js";
-import { MIDDLEWARE_SET_COOKIE_HEADER } from "../utils/protocol-headers.js";
 import { MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_REWRITE_HEADER } from "../server/headers.js";
-import { encodeMiddlewareRequestHeaders } from "../utils/middleware-request-headers.js";
 import { validateCookieAttributeValue, validateCookieName } from "./internal/cookie-serialize.js";
 import { assertSafeNavigationUrl } from "./url-safety.js";
+import { userAgent, userAgentFromString } from "./user-agent.js";
 //#region src/shims/server.ts
 /**
 * next/server shim
@@ -56,12 +57,16 @@ var NextRequest = class extends Request {
 		const { nextConfig: _nextConfig, ...requestInit } = init ?? {};
 		if (input instanceof Request) {
 			super(input, requestInit);
-			const cf = Reflect.get(input, "cf");
-			if (cf !== void 0) Object.defineProperty(this, "cf", {
-				value: cf,
-				enumerable: true,
-				configurable: true
-			});
+			const cfDescriptor = Reflect.getOwnPropertyDescriptor(input, "cf");
+			if (cfDescriptor) Object.defineProperty(this, "cf", cfDescriptor);
+			else {
+				const cf = Reflect.get(input, "cf");
+				if (cf !== void 0) Object.defineProperty(this, "cf", {
+					value: cf,
+					enumerable: true,
+					configurable: true
+				});
+			}
 		} else super(input, requestInit);
 		const url = typeof input === "string" ? new URL(input, "http://localhost") : input instanceof URL ? input : new URL(input.url, "http://localhost");
 		const i18n = _nextConfig?.i18n ? {
@@ -788,25 +793,6 @@ var NextFetchEvent = class {
 	}
 };
 /**
-* Parse user agent string. Minimal implementation — for full UA parsing,
-* apps should use a dedicated library like `ua-parser-js`.
-*/
-function userAgentFromString(ua) {
-	const input = ua ?? "";
-	return {
-		isBot: /bot|crawler|spider|crawling/i.test(input),
-		ua: input,
-		browser: {},
-		device: {},
-		engine: {},
-		os: {},
-		cpu: {}
-	};
-}
-function userAgent({ headers }) {
-	return userAgentFromString(headers.get("user-agent") ?? void 0);
-}
-/**
 * after() — schedule work after the response is sent.
 *
 * Uses the platform's `waitUntil` (via the per-request ExecutionContext) when

package/dist/shims/slot.d.ts

@@ -1,5 +1,6 @@
 import { AppElementValue, AppElements, UNMATCHED_SLOT } from "../server/app-elements-wire.js";
 import "../server/app-elements.js";
+import { ClientNavigationRenderSnapshot } from "./navigation.js";
 import * as React$1 from "react";
 //#region src/shims/slot.d.ts
 /**
@@ -7,11 +8,28 @@ import * as React$1 from "react";
  * hydration triggers "async Client Component" for native Promises that lack
  * React's internal .status property. Storing resolved values sidesteps this.
  */
-declare const ElementsContext: React$1.Context<Readonly<Record<string, AppElementValue>>>;
-declare const ChildrenContext: React$1.Context<React$1.ReactNode>;
-declare const ParallelSlotsContext: React$1.Context<Readonly<Record<string, React$1.ReactNode>> | null>;
-declare const BfcacheIdentityMapContext: React$1.Context<Readonly<Record<string, string>>>;
-type BfcacheSlotEntry = {
+export declare const ElementsContext: React$1.Context<Readonly<Record<string, AppElementValue>>>;
+export declare const ChildrenContext: React$1.Context<React$1.ReactNode>;
+export declare const ParallelSlotsContext: React$1.Context<Readonly<Record<string, React$1.ReactNode>> | null>;
+/**
+ * The query the server rendered a Slot's element with. Client pages read it
+ * (see `client-page-root.tsx`), so a page that first renders under a later
+ * navigation (a kept branch a refresh fetched from its own URL, or one still
+ * streaming when an intercepted navigation keeps it) reads its own response's
+ * query.
+ */
+export declare const RenderedSearchContext: React$1.Context<string | undefined>;
+/** Record the query the server rendered these elements with. */
+export declare function setAppElementsRenderedSearch(elements: AppElements, search: string): void;
+/**
+ * Bind a payload's elements to the snapshot of the navigation that delivers
+ * them, unless they already carry a query (a merged supplemental refresh, or
+ * an element an earlier payload delivered). Read at render time, so a query
+ * that arrives after the head (initial hydration) is still seen.
+ */
+export declare function bindAppElementsRenderedSearch(elements: AppElements, snapshot: Pick<ClientNavigationRenderSnapshot, "renderedSearch" | "search">): void;
+export declare const BfcacheIdentityMapContext: React$1.Context<Readonly<Record<string, string>>>;
+export type BfcacheSlotEntry = {
   content: React$1.ReactNode;
   elements?: AppElements;
   segmentId?: string;
@@ -24,8 +42,8 @@ type MergeElementsOptions = {
   preserveElementIds?: readonly string[];
   preservePreviousSlotIds?: readonly string[];
 };
-declare function updateBfcacheSlotEntryOrder(previousOrder: readonly string[], activeStateKey: string, maxEntries?: number): string[];
-declare function stageBfcacheSlotEntryForRender(committedSnapshots: ReadonlyMap<string, BfcacheSlotEntry>, committedOrder: readonly string[], activeEntry: BfcacheSlotEntry, maxEntries?: number): Readonly<{
+export declare function updateBfcacheSlotEntryOrder(previousOrder: readonly string[], activeStateKey: string, maxEntries?: number): string[];
+export declare function stageBfcacheSlotEntryForRender(committedSnapshots: ReadonlyMap<string, BfcacheSlotEntry>, committedOrder: readonly string[], activeEntry: BfcacheSlotEntry, maxEntries?: number): Readonly<{
   entries: BfcacheSlotEntry[];
   order: string[];
   snapshots: Map<string, BfcacheSlotEntry>;
@@ -36,22 +54,22 @@ declare function stageBfcacheSlotEntryForRender(committedSnapshots: ReadonlyMap<
  * retains each descendant segment independently. This boundary recreates that
  * ownership without requiring a separate wire entry for every nested segment.
  */
-declare function BfcacheSegmentBoundary({ children, id, stateKey }: {
+export declare function BfcacheSegmentBoundary({ children, id, stateKey }: {
   children: React$1.ReactNode;
   id: string;
   stateKey: string;
 }): React$1.JSX.Element;
-declare function getNonCacheComponentsSegmentKey(id: string, activeStateKey: string): string | undefined;
-declare function resolveBfcacheSegmentStateKey(id: string, identityMap: Readonly<Record<string, string>>, bfcacheIdMap: Readonly<Record<string, string>> | null): string | undefined;
-declare function mergeElements(prev: AppElements, next: AppElements, options?: MergeElementsOptions | boolean): AppElements;
-declare function Slot({ id, children, parallelSlots }: {
+export declare function getNonCacheComponentsSegmentKey(id: string, activeStateKey: string): string | undefined;
+export declare function resolveBfcacheSegmentStateKey(id: string, identityMap: Readonly<Record<string, string>>, bfcacheIdMap: Readonly<Record<string, string>> | null): string | undefined;
+export declare function mergeElements(prev: AppElements, next: AppElements, options?: MergeElementsOptions | boolean): AppElements;
+export declare function Slot({ id, children, parallelSlots }: {
   id: string;
   children?: React$1.ReactNode;
   parallelSlots?: Readonly<Record<string, React$1.ReactNode>>;
 }): React$1.JSX.Element | null;
-declare function Children(): React$1.ReactNode;
-declare function ParallelSlot({ name }: {
+export declare function Children(): React$1.ReactNode;
+export declare function ParallelSlot({ name }: {
   name: string;
 }): string | number | bigint | boolean | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | Iterable<React$1.ReactNode> | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | React$1.ReactPortal | null | undefined> | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
 //#endregion
-export { BfcacheIdentityMapContext, BfcacheSegmentBoundary, BfcacheSlotEntry, Children, ChildrenContext, ElementsContext, ParallelSlot, ParallelSlotsContext, Slot, UNMATCHED_SLOT, getNonCacheComponentsSegmentKey, mergeElements, resolveBfcacheSegmentStateKey, stageBfcacheSlotEntryForRender, updateBfcacheSlotEntryOrder };
+export { UNMATCHED_SLOT };

package/dist/shims/slot.js

@@ -19,6 +19,33 @@ const warnedTransportMetadataEntryIds = /* @__PURE__ */ new Set();
 const ElementsContext = React$1.createContext(EMPTY_ELEMENTS);
 const ChildrenContext = React$1.createContext(null);
 const ParallelSlotsContext = React$1.createContext(null);
+/**
+* The query the server rendered a Slot's element with. Client pages read it
+* (see `client-page-root.tsx`), so a page that first renders under a later
+* navigation (a kept branch a refresh fetched from its own URL, or one still
+* streaming when an intercepted navigation keeps it) reads its own response's
+* query.
+*/
+const RenderedSearchContext = React$1.createContext(void 0);
+const renderedSearchByElement = /* @__PURE__ */ new WeakMap();
+/** Record the query the server rendered these elements with. */
+function setAppElementsRenderedSearch(elements, search) {
+	for (const element of Object.values(elements)) if (typeof element === "object" && element !== null) renderedSearchByElement.set(element, search);
+}
+/**
+* Bind a payload's elements to the snapshot of the navigation that delivers
+* them, unless they already carry a query (a merged supplemental refresh, or
+* an element an earlier payload delivered). Read at render time, so a query
+* that arrives after the head (initial hydration) is still seen.
+*/
+function bindAppElementsRenderedSearch(elements, snapshot) {
+	for (const element of Object.values(elements)) if (typeof element === "object" && element !== null && !renderedSearchByElement.has(element)) renderedSearchByElement.set(element, snapshot);
+}
+function getElementRenderedSearch(element) {
+	if (typeof element !== "object" || element === null) return void 0;
+	const source = renderedSearchByElement.get(element);
+	return typeof source === "object" ? source.renderedSearch ?? source.search : source;
+}
 const BfcacheIdMapContext = getBfcacheIdMapContext();
 const BfcacheSegmentIdContext = getBfcacheSegmentIdContext();
 const EMPTY_BFCACHE_STATE_KEYS = Object.freeze({});
@@ -129,7 +156,8 @@ function BfcacheEntryProviders({ entry, fallbackElements, fallbackSegmentId, fal
 function useBfcacheSlotEntries(activeEntry) {
 	const snapshotsByStateKey = React$1.useRef(/* @__PURE__ */ new Map());
 	const [entryOrder, setEntryOrder] = React$1.useState(() => [activeEntry.stateKey]);
-	const staged = stageBfcacheSlotEntryForRender(snapshotsByStateKey.current, entryOrder, activeEntry);
+	const committedSnapshots = snapshotsByStateKey.current;
+	const staged = stageBfcacheSlotEntryForRender(committedSnapshots, entryOrder, activeEntry);
 	const nextOrder = staged.order;
 	const orderChanged = !haveSameBfcacheSlotEntryOrder(entryOrder, nextOrder);
 	React$1.useLayoutEffect(() => {
@@ -140,13 +168,14 @@ function useBfcacheSlotEntries(activeEntry) {
 	return staged.entries;
 }
 function BfcacheActivitySlotBoundary({ activeStateKey, content, elements, id, SegmentContext, stateKeyMap }) {
-	return /* @__PURE__ */ jsx(Fragment$1, { children: useBfcacheSlotEntries({
+	const renderEntries = useBfcacheSlotEntries({
 		content,
 		elements,
 		segmentId: id,
 		stateKey: activeStateKey,
 		stateKeyMap
-	}).map((entry) => /* @__PURE__ */ jsx(React$1.Activity, {
+	});
+	return /* @__PURE__ */ jsx(Fragment$1, { children: renderEntries.map((entry) => /* @__PURE__ */ jsx(React$1.Activity, {
 		mode: entry.stateKey === activeStateKey ? "visible" : "hidden",
 		children: /* @__PURE__ */ jsx(BfcacheEntryProviders, {
 			entry,
@@ -289,11 +318,14 @@ function Slot({ id, children, parallelSlots }) {
 	}
 	if (element === UNMATCHED_SLOT) notFound();
 	if (element === null) return null;
-	const content = /* @__PURE__ */ jsx(ParallelSlotsContext.Provider, {
-		value: parallelSlots ?? null,
-		children: /* @__PURE__ */ jsx(ChildrenContext.Provider, {
-			value: children ?? null,
-			children: element
+	const content = /* @__PURE__ */ jsx(RenderedSearchContext.Provider, {
+		value: getElementRenderedSearch(element),
+		children: /* @__PURE__ */ jsx(ParallelSlotsContext.Provider, {
+			value: parallelSlots ?? null,
+			children: /* @__PURE__ */ jsx(ChildrenContext.Provider, {
+				value: children ?? null,
+				children: element
+			})
 		})
 	});
 	return BfcacheIdMapContext && BfcacheSegmentIdContext ? /* @__PURE__ */ jsx(BfcacheSlotBoundary, {
@@ -308,4 +340,4 @@ function ParallelSlot({ name }) {
 	return React$1.useContext(ParallelSlotsContext)?.[name] ?? null;
 }
 //#endregion
-export { BfcacheIdentityMapContext, BfcacheSegmentBoundary, Children, ChildrenContext, ElementsContext, ParallelSlot, ParallelSlotsContext, Slot, UNMATCHED_SLOT, getNonCacheComponentsSegmentKey, mergeElements, resolveBfcacheSegmentStateKey, stageBfcacheSlotEntryForRender, updateBfcacheSlotEntryOrder };
+export { BfcacheIdentityMapContext, BfcacheSegmentBoundary, Children, ChildrenContext, ElementsContext, ParallelSlot, ParallelSlotsContext, RenderedSearchContext, Slot, UNMATCHED_SLOT, bindAppElementsRenderedSearch, getNonCacheComponentsSegmentKey, mergeElements, resolveBfcacheSegmentStateKey, setAppElementsRenderedSearch, stageBfcacheSlotEntryForRender, updateBfcacheSlotEntryOrder };

package/dist/shims/streamed-icons.d.ts

@@ -1,7 +1,6 @@
 //#region src/shims/streamed-icons.d.ts
-declare function reconcileStreamedIcons(metadataKey: string): void;
-declare function StreamedIconsInsertion({ metadataKey }: {
+export declare function reconcileStreamedIcons(metadataKey: string): void;
+export declare function StreamedIconsInsertion({ metadataKey }: {
   metadataKey: string;
 }): null;
-//#endregion
-export { StreamedIconsInsertion, reconcileStreamedIcons };
+//#endregion

package/dist/shims/thenable-params.d.ts

@@ -1,11 +1,9 @@
+import { WellKnownProperty } from "./internal/thenable-well-known-properties.js";
 //#region src/shims/thenable-params.d.ts
-declare const WELL_KNOWN_PROPERTIES: readonly ["hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toString", "valueOf", "toLocaleString", "then", "catch", "finally", "status", "value", "error", "displayName", "_debugInfo", "toJSON", "$$typeof", "__esModule", "@@iterator"];
-type WellKnownProperty = (typeof WELL_KNOWN_PROPERTIES)[number];
-type ThenableParams<T extends Record<string, unknown>> = Promise<T> & Omit<T, WellKnownProperty>;
-type ThenableParamsObserver = Readonly<{
+export type ThenableParams<T extends Record<string, unknown>> = Promise<T> & Omit<T, WellKnownProperty>;
+export type ThenableParamsObserver = Readonly<{
   observeParamAccess: (keys: readonly string[]) => void;
   observeReactPromiseStatus?: boolean;
 }>;
-declare function makeThenableParams<T extends Record<string, unknown>>(obj: T, observer?: ThenableParamsObserver): ThenableParams<T>;
-//#endregion
-export { ThenableParams, ThenableParamsObserver, makeThenableParams };
+export declare function makeThenableParams<T extends Record<string, unknown>>(obj: T, observer?: ThenableParamsObserver): ThenableParams<T>;
+//#endregion

package/dist/shims/thenable-params.js

@@ -1,31 +1,9 @@
 import { createPprFallbackShellSuspensePromiseForState, getPprFallbackShellState } from "./ppr-fallback-shell.js";
+import { isOwnPropertyCheck, isWellKnownProperty } from "./internal/thenable-well-known-properties.js";
 //#region src/shims/thenable-params.ts
 function hasParamProperty(obj, prop) {
 	return Object.prototype.hasOwnProperty.call(obj, prop);
 }
-const wellKnownProperties = /* @__PURE__ */ new Set([
-	"hasOwnProperty",
-	"isPrototypeOf",
-	"propertyIsEnumerable",
-	"toString",
-	"valueOf",
-	"toLocaleString",
-	"then",
-	"catch",
-	"finally",
-	"status",
-	"value",
-	"error",
-	"displayName",
-	"_debugInfo",
-	"toJSON",
-	"$$typeof",
-	"__esModule",
-	"@@iterator"
-]);
-function isWellKnownProperty(prop) {
-	return wellKnownProperties.has(prop);
-}
 function observeParamKeys(observer, keys) {
 	if (observer) observer.observeParamAccess(keys);
 }
@@ -140,7 +118,8 @@ function makeThenableParams(obj, observer) {
 				return Reflect.get(plain, prop);
 			}
 			const value = Reflect.get(target, prop, receiver);
-			return typeof value === "function" ? value.bind(target) : value;
+			if (typeof value !== "function") return value;
+			return value.bind(isOwnPropertyCheck(prop) ? receiver : target);
 		},
 		getOwnPropertyDescriptor(target, prop) {
 			if (typeof prop === "string" && !isWellKnownProperty(prop)) observeParamKeys(observer, [prop]);