vinext 1.2.1 → 1.3.1

package/dist/server/app-streamed-client-references.js

@@ -0,0 +1,156 @@
+import { getOrCreateAls } from "../shims/internal/als-registry.js";
+import { escapeHtmlAttr } from "./html.js";
+import * as ReactDOM from "react-dom";
+import { setOnClientReference } from "@vitejs/plugin-rsc/ssr";
+//#region src/server/app-streamed-client-references.ts
+/**
+* Stream the client references an SSR render may show before they load, and
+* link every client reference's scripts with the render's CSP nonce and the
+* configured crossOrigin, and its stylesheets with the configured crossOrigin.
+*
+* A render waits for its route's client references before it starts, except
+* those whose modules evaluate asynchronously (top-level await). Like Next.js,
+* it streams those: React suspends on one until it loads, showing the nearest
+* Suspense fallback first.
+*
+* plugin-rsc links a client module's stylesheets as the render reads its
+* exports, so a streamed module would link them wherever it rendered once
+* loaded, which depends on how long it took. Instead, a render links a
+* streamed reference's stylesheets in the route's import order, as Next.js's
+* Turbopack build does: just before the first reference after it links its
+* own, or after the shell's stylesheets when none does. Its scripts link as the
+* Flight stream names it.
+*
+* plugin-rsc hints a client module's scripts without the render's nonce, which
+* a nonce-based CSP blocks, and always as anonymous, so under
+* `crossOrigin: "use-credentials"` the browser fetches the module the page
+* then imports without credentials. React keeps the first hint for each
+* script, so a render with either hints them first, with both, as Next.js does.
+* plugin-rsc also links its stylesheets as anonymous whatever the config, so a
+* render links them first with the configured crossOrigin too. Unlike Next.js,
+* it links them as anonymous when that's unset: Vite's preload helper always
+* links a lazily imported module's stylesheets as anonymous, and a later page
+* doing so would fail the CORS check on the no-cors copy the browser cached.
+*/
+const WRAPPED = Symbol.for("vinext.streamedClientReferences.wrapped");
+const STYLESHEET_PRECEDENCE = "vite-rsc/client-reference";
+const referenceDeps = /* @__PURE__ */ new Map();
+const renderStorage = getOrCreateAls("vinext.streamedClientReferences");
+function hintsScripts(render) {
+	return !!render.nonce || render.crossOrigin === "use-credentials";
+}
+function linkScripts(deps, render) {
+	const options = {
+		as: "script",
+		crossOrigin: render.crossOrigin,
+		fetchPriority: "low",
+		nonce: render.nonce
+	};
+	for (const href of deps.js) ReactDOM.preloadModule(href, options);
+}
+function linkStylesheets(hrefs, render) {
+	const options = {
+		as: "style",
+		crossOrigin: render.crossOrigin,
+		precedence: STYLESHEET_PRECEDENCE
+	};
+	for (const href of hrefs) ReactDOM.preinit(href, options);
+}
+/**
+* Before reference `id` links its stylesheets, link those of the streamed
+* references that come before it in import order.
+*/
+function linkStreamedStylesheetsBefore(render, id) {
+	const position = render.positions.get(id);
+	if (position === void 0) return;
+	while (render.unlinked.length > 0 && render.positions.get(render.unlinked[0]) < position) {
+		const hrefs = referenceDeps.get(render.unlinked.shift())?.css ?? [];
+		for (const href of hrefs) render.linkedStylesheets.add(href);
+		linkStylesheets(hrefs, render);
+	}
+}
+/**
+* Wrap plugin-rsc's client-reference loader before any client reference
+* loads; a production build calls this as its SSR entry starts. `asyncIds` are
+* the references any route may stream, and `getLoader` returns a reference's
+* own loader from the client-references module.
+*/
+function wrapClientReferenceRequire(asyncIds, getLoader) {
+	const load = globalThis.__vite_rsc_client_require__;
+	if (typeof load !== "function" || WRAPPED in load) return;
+	setOnClientReference(({ id, deps }) => {
+		referenceDeps.set(id, deps);
+		const render = renderStorage.getStore();
+		if (render && !render.streamed.has(id)) for (const href of deps.css) render.linkedStylesheets.add(href);
+	});
+	const loads = /* @__PURE__ */ new Map();
+	const wrapped = (id) => {
+		const render = renderStorage.getStore();
+		if (render?.streamed.has(id)) {
+			const deps = referenceDeps.get(id);
+			if (deps) linkScripts(deps, render);
+		}
+		let loading = loads.get(id);
+		if (!loading) {
+			const loader = asyncIds.has(id) ? getLoader(id) : void 0;
+			loading = Promise.all([load(id), loader?.()]).then(([mod, exports]) => new Proxy(mod, { get(target, key, receiver) {
+				const render = renderStorage.getStore();
+				if (render) {
+					if (exports !== void 0 && render.streamed.has(id)) return Reflect.get(exports, key);
+					linkStreamedStylesheetsBefore(render, id);
+					const deps = referenceDeps.get(id);
+					if (deps && key in target) {
+						linkStylesheets(deps.css, render);
+						if (hintsScripts(render)) linkScripts(deps, render);
+					}
+				}
+				return Reflect.get(target, key, receiver);
+			} }));
+			loads.set(id, loading);
+		}
+		return loading;
+	};
+	Object.defineProperty(wrapped, WRAPPED, { value: true });
+	globalThis.__vite_rsc_client_require__ = wrapped;
+}
+function createStreamedClientReferences(route, nonce, crossOrigin) {
+	const streamed = new Set(route?.streamed);
+	return {
+		nonce,
+		crossOrigin,
+		streamed,
+		positions: new Map(route?.references.map((id, index) => [id, index])),
+		unlinked: route?.references.filter((id) => streamed.has(id)) ?? [],
+		linkedStylesheets: /* @__PURE__ */ new Set()
+	};
+}
+/**
+* Forget the stylesheets a discarded render linked, so the render that
+* replaces it links them again.
+*/
+function resetStreamedClientReferences(render, route) {
+	if (!render) return;
+	render.unlinked = route?.references.filter((id) => render.streamed.has(id)) ?? [];
+	render.linkedStylesheets.clear();
+}
+/** Run a render, and the Flight stream it reads, with its streamed references. */
+function runWithStreamedClientReferences(render, fn) {
+	return renderStorage.run(render, fn);
+}
+/**
+* The `<head>` links of the streamed stylesheets a render's shell left
+* unlinked, those of streamed references after every reference it rendered.
+*/
+function renderStreamedStylesheets(render) {
+	const hrefs = /* @__PURE__ */ new Set();
+	for (const id of render.unlinked.splice(0)) for (const href of referenceDeps.get(id)?.css ?? []) if (!render.linkedStylesheets.has(href)) hrefs.add(href);
+	const crossOrigin = render.crossOrigin === "use-credentials" ? "use-credentials" : "";
+	let html = "";
+	for (const href of hrefs) {
+		render.linkedStylesheets.add(href);
+		html += `<link rel="stylesheet" href="${escapeHtmlAttr(href)}" data-precedence="${STYLESHEET_PRECEDENCE}" crossorigin="${crossOrigin}"/>`;
+	}
+	return html;
+}
+//#endregion
+export { createStreamedClientReferences, renderStreamedStylesheets, resetStreamedClientReferences, runWithStreamedClientReferences, wrapClientReferenceRequire };

package/dist/server/app-visited-response-cache.d.ts

@@ -35,4 +35,5 @@ export declare function findVisitedResponseCacheEntry(cache: Map<string, Visited
 export declare function deleteVisitedResponseCacheEntry(cache: Map<string, VisitedResponseCacheEntry>, rscUrl: string, interceptionContext: string | null): boolean;
 export declare function deleteAllVisitedResponseCacheEntries(cache: Map<string, VisitedResponseCacheEntry>, rscUrl: string, interceptionContext: string | null): number;
 export declare function deleteInvalidatedHistoryRestoreEntries(cache: Map<string, VisitedResponseCacheEntry>): void;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-worker-stages.d.ts

@@ -114,4 +114,5 @@ export declare function withoutAppPageDispatchQuery(requestUrl: string, props: A
  */
 export declare function isStaticCandidateAppPageDispatch(projection: CacheabilityManifest, request: Request, props: AppMatchedWorkerResponseStageProps): boolean;
 export declare function isAppWorkerResponseStageProps(value: unknown): value is AppWorkerResponseStageProps;
-//#endregion
+//#endregion
+export {};

package/dist/server/artifact-compatibility.d.ts

@@ -50,4 +50,5 @@ export declare function createArtifactCompatibilityEnvelope(input?: ArtifactComp
 export declare function createArtifactCompatibilityGraphVersion(input: ArtifactCompatibilityGraphVersionInput): string;
 export declare function parseArtifactCompatibilityEnvelope(value: unknown): ArtifactCompatibilityEnvelope | null;
 export declare function evaluateArtifactCompatibility(current: ArtifactCompatibilityEnvelope, candidate: ArtifactCompatibilityEnvelope, options?: ArtifactCompatibilityEvaluationOptions): ArtifactCompatibilityDecision;
-//#endregion
+//#endregion
+export {};

package/dist/server/bfcache-identity.d.ts

@@ -41,4 +41,5 @@ export type BfcacheSegmentDescriptor = {
   sourceBoundSegmentKey: string;
 };
 export declare function deriveBfcacheSegmentIdentity(descriptor: BfcacheSegmentDescriptor): string;
-//#endregion
+//#endregion
+export {};

package/dist/server/cache-headers.d.ts

@@ -2,4 +2,5 @@
 type VinextCacheState = "HIT" | "MISS" | "STALE" | "STATIC";
 export declare function setCacheStateHeaders(headers: Headers, cacheState: VinextCacheState): void;
 export declare function buildCacheStateHeaders(cacheState: VinextCacheState): Record<string, string>;
-//#endregion
+//#endregion
+export {};

package/dist/server/cacheability-request.d.ts

@@ -46,4 +46,5 @@ export type CacheabilityAdmissionCaptureBudget = {
 export declare function createCacheabilityAdmissionCaptureBudget(maxBytes: number): CacheabilityAdmissionCaptureBudget;
 export declare function captureCacheabilityAdmissionBody(body: ReadableStream<Uint8Array> | null, deadlineAt: number, limit?: number, budget?: CacheabilityAdmissionCaptureBudget): Promise<CapturedAdmissionBody>;
 export declare function finalizeWorkerCacheabilityResponse(response: Response, ctx: ExecutionContextLike): Promise<Response>;
-//#endregion
+//#endregion
+export {};

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

@@ -99,4 +99,5 @@ export declare function createClientReusePayloadHash(input: string): string;
 export declare function createClientReuseManifest(input: CreateClientReuseManifestInput): ClientReuseManifestWire;
 export declare function serializeClientReuseManifest(input: CreateClientReuseManifestInput): string;
 export declare function parseClientReuseManifestHeader(rawHeader: string | null | undefined, options?: ParseClientReuseManifestOptions): ClientReuseManifestParseResult;
-//#endregion
+//#endregion
+export {};

package/dist/server/config-headers.d.ts

@@ -39,4 +39,5 @@ type ApplyConfigHeadersOptions = {
 export declare function applyConfigHeadersToResponse(responseHeaders: Headers, options: ApplyConfigHeadersOptions): void;
 /** Apply matched next.config.js headers to an early response header record. */
 export declare function applyConfigHeadersToHeaderRecord(headers: HeaderRecord, options: ApplyConfigHeadersOptions): void;
-//#endregion
+//#endregion
+export {};

package/dist/server/config-headers.js

@@ -76,10 +76,12 @@ function appendVaryHeaderRecord(headers, value) {
 function applyConfigHeadersToResponse(responseHeaders, options) {
 	const matched = retainLastSingularConfigValues(matchHeaders(options.pathname, options.configHeaders, options.requestContext, options.basePathState, options.recordCacheability === false ? void 0 : markConditionalConfigHeaderCacheability));
 	if (options.recordCacheability !== false) markExplicitConfigResponseVeto(matched);
+	const configCookies = [];
 	for (const header of matched) {
 		const lowerName = header.key.toLowerCase();
 		if (lowerName === "x-vinext-special-error-status") continue;
-		if (lowerName === "link") {
+		if (lowerName === "set-cookie") configCookies.push(header.value);
+		else if (lowerName === "link") {
 			if (options.middlewareHeaders?.get(lowerName)) continue;
 			const postConfigLink = options.appendToPostConfigLink ? responseHeaders.get(lowerName) : null;
 			responseHeaders.set(header.key, postConfigLink ? `${header.value}, ${postConfigLink}` : header.value);
@@ -88,15 +90,22 @@ function applyConfigHeadersToResponse(responseHeaders, options) {
 		else if (ADDITIVE_CONFIG_HEADER_NAMES.has(lowerName)) responseHeaders.append(header.key, header.value);
 		else if ((typeof options.overwriteExisting === "function" ? options.overwriteExisting(lowerName) : options.overwriteExisting?.has(lowerName)) || !responseHeaders.has(lowerName)) responseHeaders.set(header.key, header.value);
 	}
+	if (configCookies.length > 0 && !options.middlewareHeaders?.get("set-cookie")) {
+		const responseCookies = responseHeaders.getSetCookie();
+		responseHeaders.delete("set-cookie");
+		for (const cookie of [...configCookies, ...responseCookies]) responseHeaders.append("set-cookie", cookie);
+	}
 }
 /** Apply matched next.config.js headers to an early response header record. */
 function applyConfigHeadersToHeaderRecord(headers, options) {
 	const matched = retainLastSingularConfigValues(matchHeaders(options.pathname, options.configHeaders, options.requestContext, options.basePathState, options.recordCacheability === false ? void 0 : markConditionalConfigHeaderCacheability));
 	if (options.recordCacheability !== false) markExplicitConfigResponseVeto(matched);
+	const middlewareSetsCookie = Boolean(options.middlewareHeaders?.get("set-cookie")) || findHeaderRecordKey(headers, "set-cookie") !== void 0;
 	for (const header of matched) {
 		const lowerName = header.key.toLowerCase();
-		if (lowerName === "set-cookie") appendHeaderRecord(headers, lowerName, header.value);
-		else if (lowerName === "vary") appendVaryHeaderRecord(headers, header.value);
+		if (lowerName === "set-cookie") {
+			if (!middlewareSetsCookie) appendHeaderRecord(headers, lowerName, header.value);
+		} else if (lowerName === "vary") appendVaryHeaderRecord(headers, header.value);
 		else if (findHeaderRecordKey(headers, lowerName) === void 0) headers[lowerName] = header.value;
 	}
 }

package/dist/server/csp.d.ts

@@ -5,4 +5,5 @@ export declare function getScriptNonceFromHeader(cspHeaderValue: string): string
 export declare function getScriptNonceFromHeaders(headers: Headers | null | undefined): string | undefined;
 export declare function getScriptNonceFromNodeHeaderSources(...headersList: readonly (NodeHeaders | null | undefined)[]): string | undefined;
 export declare function getScriptNonceFromHeaderSources(...headersList: readonly (Headers | null | undefined)[]): string | undefined;
-//#endregion
+//#endregion
+export {};

package/dist/server/default-global-not-found-module.d.ts

@@ -9,4 +9,5 @@ declare function DefaultGlobalNotFound(): React.ReactElement;
 export declare const DEFAULT_GLOBAL_NOT_FOUND_MODULE: {
   readonly default: typeof DefaultGlobalNotFound;
 };
-//#endregion
+//#endregion
+export {};

package/dist/server/default-http-access-fallback-modules.d.ts

@@ -0,0 +1,33 @@
+import DefaultForbidden from "../shims/default-forbidden.js";
+import DefaultNotFound from "../shims/default-not-found.js";
+import DefaultUnauthorized from "../shims/default-unauthorized.js";
+//#region src/server/default-http-access-fallback-modules.d.ts
+/**
+ * Module-shaped wrappers around vinext's built-in not-found, forbidden and
+ * unauthorized components. Used as the fallback when an app does not define
+ * its own `app/not-found.tsx` (and has not opted into
+ * `app/global-not-found.tsx`), `app/forbidden.tsx` or `app/unauthorized.tsx`.
+ * The runtime treats any `{ default: Component }` record as a boundary
+ * module, so wrapping the components this way lets us thread the defaults
+ * through the existing boundary plumbing without introducing a parallel code
+ * path.
+ *
+ * Mirrors Next.js's `builtin/not-found.js`, `builtin/forbidden.js` and
+ * `builtin/unauthorized.js`, which the app loader selects for the root
+ * segment when the user has not supplied the file:
+ * https://github.com/vercel/next.js/blob/canary/packages/next/src/build/webpack/loaders/next-app-loader/index.ts
+ * https://github.com/vercel/next.js/blob/canary/crates/next-core/src/app_structure.rs
+ */
+export declare const DEFAULT_NOT_FOUND_MODULE: {
+  readonly default: typeof DefaultNotFound;
+};
+export declare const DEFAULT_FORBIDDEN_MODULE: {
+  readonly default: typeof DefaultForbidden;
+};
+export declare const DEFAULT_UNAUTHORIZED_MODULE: {
+  readonly default: typeof DefaultUnauthorized;
+};
+export declare function getDefaultHttpAccessFallbackModule(statusCode: number): {
+  readonly default: typeof DefaultNotFound;
+} | null;
+//#endregion

package/dist/server/default-http-access-fallback-modules.js

@@ -0,0 +1,31 @@
+import DefaultForbidden from "../shims/default-forbidden.js";
+import DefaultNotFound from "../shims/default-not-found.js";
+import DefaultUnauthorized from "../shims/default-unauthorized.js";
+//#region src/server/default-http-access-fallback-modules.ts
+/**
+* Module-shaped wrappers around vinext's built-in not-found, forbidden and
+* unauthorized components. Used as the fallback when an app does not define
+* its own `app/not-found.tsx` (and has not opted into
+* `app/global-not-found.tsx`), `app/forbidden.tsx` or `app/unauthorized.tsx`.
+* The runtime treats any `{ default: Component }` record as a boundary
+* module, so wrapping the components this way lets us thread the defaults
+* through the existing boundary plumbing without introducing a parallel code
+* path.
+*
+* Mirrors Next.js's `builtin/not-found.js`, `builtin/forbidden.js` and
+* `builtin/unauthorized.js`, which the app loader selects for the root
+* segment when the user has not supplied the file:
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/build/webpack/loaders/next-app-loader/index.ts
+* https://github.com/vercel/next.js/blob/canary/crates/next-core/src/app_structure.rs
+*/
+const DEFAULT_NOT_FOUND_MODULE = { default: DefaultNotFound };
+const DEFAULT_FORBIDDEN_MODULE = { default: DefaultForbidden };
+const DEFAULT_UNAUTHORIZED_MODULE = { default: DefaultUnauthorized };
+function getDefaultHttpAccessFallbackModule(statusCode) {
+	if (statusCode === 404) return DEFAULT_NOT_FOUND_MODULE;
+	if (statusCode === 403) return DEFAULT_FORBIDDEN_MODULE;
+	if (statusCode === 401) return DEFAULT_UNAUTHORIZED_MODULE;
+	return null;
+}
+//#endregion
+export { DEFAULT_FORBIDDEN_MODULE, DEFAULT_NOT_FOUND_MODULE, DEFAULT_UNAUTHORIZED_MODULE, getDefaultHttpAccessFallbackModule };

package/dist/server/defer-until-stream-consumed.d.ts

@@ -1,7 +1,41 @@
 //#region src/server/defer-until-stream-consumed.d.ts
+export type StreamConsumptionCallbacks = {
+  /** Runs once when the consumer reads the first chunk. */
+  onStart?: () => void;
+  /** Runs once when the stream ends, errors or is cancelled. */
+  onFlush?: () => void;
+  onError?: (error: unknown) => void;
+  onCancel?: (reason: unknown) => void;
+};
 /**
  * Defers cleanup until the downstream consumer drains or cancels the stream.
  * `onCancel` runs before the cancellation reaches the source stream.
  */
 export declare function deferUntilStreamConsumed(stream: ReadableStream<Uint8Array>, onFlush: () => void, onError?: (error: unknown) => void, onCancel?: (reason: unknown) => void): ReadableStream<Uint8Array>;
+/**
+ * Runs the callbacks as the downstream consumer reads the stream: `onStart`
+ * when it reads the first chunk, the others when the stream ends, errors or
+ * is cancelled.
+ *
+ * The wrapper reads the source directly instead of piping it through an
+ * identity `TransformStream`, and a wrapper that is wrapped again before
+ * anything reads it takes on the new callbacks instead of adding a layer.
+ * Every streamed response passes through several of these, and each layer
+ * cost a pipe, two more streams and their promise hops per chunk. Nothing is
+ * read ahead of the consumer, so an unread wrapper is still untouched.
+ *
+ * The callbacks run as separate layers would run them. Start, flush and error
+ * callbacks run innermost first, and a layer sees the error an inner layer's
+ * callback threw as its stream error, or the error its own flush callback
+ * threw. Cancel callbacks run outermost first. A layer whose error or cancel
+ * callback throws doesn't run its flush callback. When a start callback
+ * throws, that layer and the layers outside it see the error, and the layers
+ * inside it are cancelled with it. As with the pipe, each layer's callbacks
+ * run in the async context that added them, and the source is read and
+ * cancelled in the context of the first layer. Cleanup reads and clears
+ * request-scoped state, and spans the source starts while producing chunks
+ * need their request parent, but the consumer (the runtime sending the body)
+ * reads from outside that scope.
+ */
+export declare function observeStreamConsumption(stream: ReadableStream<Uint8Array>, callbacks: StreamConsumptionCallbacks): ReadableStream<Uint8Array>;
 //#endregion

package/dist/server/defer-until-stream-consumed.js

@@ -1,37 +1,170 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/server/defer-until-stream-consumed.ts
+const UNREAD_WRAPPERS_KEY = Symbol.for("vinext.deferUntilStreamConsumed.unreadWrappers");
+const unreadWrappers = globalThis[UNREAD_WRAPPERS_KEY] ??= /* @__PURE__ */ new WeakMap();
 /**
 * Defers cleanup until the downstream consumer drains or cancels the stream.
 * `onCancel` runs before the cancellation reaches the source stream.
 */
 function deferUntilStreamConsumed(stream, onFlush, onError, onCancel) {
-	let called = false;
-	const once = () => {
-		if (!called) {
-			called = true;
-			onFlush();
+	return observeStreamConsumption(stream, {
+		onFlush,
+		onError,
+		onCancel
+	});
+}
+/**
+* Runs the callbacks as the downstream consumer reads the stream: `onStart`
+* when it reads the first chunk, the others when the stream ends, errors or
+* is cancelled.
+*
+* The wrapper reads the source directly instead of piping it through an
+* identity `TransformStream`, and a wrapper that is wrapped again before
+* anything reads it takes on the new callbacks instead of adding a layer.
+* Every streamed response passes through several of these, and each layer
+* cost a pipe, two more streams and their promise hops per chunk. Nothing is
+* read ahead of the consumer, so an unread wrapper is still untouched.
+*
+* The callbacks run as separate layers would run them. Start, flush and error
+* callbacks run innermost first, and a layer sees the error an inner layer's
+* callback threw as its stream error, or the error its own flush callback
+* threw. Cancel callbacks run outermost first. A layer whose error or cancel
+* callback throws doesn't run its flush callback. When a start callback
+* throws, that layer and the layers outside it see the error, and the layers
+* inside it are cancelled with it. As with the pipe, each layer's callbacks
+* run in the async context that added them, and the source is read and
+* cancelled in the context of the first layer. Cleanup reads and clears
+* request-scoped state, and spans the source starts while producing chunks
+* need their request parent, but the consumer (the runtime sending the body)
+* reads from outside that scope.
+*/
+function observeStreamConsumption(stream, callbacks) {
+	const layer = {
+		...callbacks,
+		runInCreationContext: AsyncLocalStorage.snapshot()
+	};
+	const unread = unreadWrappers.get(stream);
+	if (unread && !stream.locked) {
+		unread.push(layer);
+		return stream;
+	}
+	const layers = [layer];
+	let started = false;
+	let settled = false;
+	const finish = (sourceFailure, first = 0, end = layers.length) => {
+		let failure = sourceFailure;
+		for (const current of layers.slice(first, end)) current.runInCreationContext(() => {
+			const reportedError = failure !== void 0;
+			try {
+				if (failure) current.onError?.(failure.error);
+			} catch (error) {
+				failure = { error };
+				return;
+			}
+			try {
+				current.onFlush?.();
+			} catch (error) {
+				failure = { error };
+				if (reportedError) return;
+				try {
+					current.onError?.(error);
+				} catch (callbackError) {
+					failure = { error: callbackError };
+				}
+			}
+		});
+		return failure;
+	};
+	const cancelLayers = (reason, end) => {
+		let failure;
+		for (const current of layers.slice(0, end).reverse()) current.runInCreationContext(() => {
+			try {
+				current.onCancel?.(reason);
+			} catch (error) {
+				failure ??= { error };
+				return;
+			}
+			try {
+				current.onFlush?.();
+			} catch (error) {
+				failure ??= { error };
+			}
+		});
+		return failure;
+	};
+	const start = () => {
+		for (const [index, current] of layers.entries()) {
+			try {
+				current.runInCreationContext(() => current.onStart?.());
+			} catch (error) {
+				return {
+					error,
+					index
+				};
+			}
+			if (settled) return void 0;
 		}
 	};
-	const cleanup = new TransformStream({ flush() {
-		once();
-	} });
-	const reader = stream.pipeThrough(cleanup).getReader();
-	return new ReadableStream({
+	const reader = stream.getReader();
+	const release = () => {
+		try {
+			reader.releaseLock();
+		} catch {}
+	};
+	const wrapped = new ReadableStream({
 		pull(controller) {
-			return reader.read().then(({ done, value }) => {
-				if (done) controller.close();
-				else controller.enqueue(value);
+			unreadWrappers.delete(wrapped);
+			return layer.runInCreationContext(() => reader.read()).then(({ done, value }) => {
+				if (settled) return;
+				if (!done) {
+					if (!started) {
+						started = true;
+						const startFailure = start();
+						if (settled) return;
+						if (startFailure) {
+							settled = true;
+							const { error, index } = startFailure;
+							let failure = finish({ error }, index, index + 1);
+							cancelLayers(error, index);
+							layer.runInCreationContext(() => reader.cancel(error)).catch(() => {}).finally(release);
+							failure = finish(failure, index + 1);
+							controller.error(failure?.error);
+							return;
+						}
+					}
+					controller.enqueue(value);
+					return;
+				}
+				settled = true;
+				release();
+				const failure = finish(void 0);
+				if (failure) controller.error(failure.error);
+				else controller.close();
 			}, (error) => {
-				onError?.(error);
-				once();
-				controller.error(error);
+				if (settled) return;
+				settled = true;
+				release();
+				controller.error(finish({ error })?.error);
 			});
 		},
 		cancel(reason) {
-			onCancel?.(reason);
-			once();
-			return reader.cancel(reason);
+			unreadWrappers.delete(wrapped);
+			let failure;
+			if (!settled) {
+				settled = true;
+				failure = cancelLayers(reason, layers.length);
+			}
+			const cancelled = layer.runInCreationContext(() => reader.cancel(reason)).finally(release);
+			if (!failure) return cancelled;
+			const { error } = failure;
+			const fail = () => {
+				throw error;
+			};
+			return cancelled.then(fail, fail);
 		}
-	});
+	}, { highWaterMark: 0 });
+	unreadWrappers.set(wrapped, layers);
+	return wrapped;
 }
 //#endregion
-export { deferUntilStreamConsumed };
+export { deferUntilStreamConsumed, observeStreamConsumption };

package/dist/server/dev-lockfile.d.ts

@@ -19,6 +19,9 @@
  *   (`process.kill(pid, 0)`), which is good enough for the dev-server
  *   "another server is running" use case. Race conditions on lock acquisition
  *   are tolerated: at worst, two dev servers race and one fails to bind a port.
+ *   Unlike a `flock()`, the lock file survives a hard restart, so a lock
+ *   written before the current boot is treated as stale whatever its PID: the
+ *   PID may now belong to an unrelated process. See `predatesCurrentBoot()`.
  * - Lock file lives in `<root>/.vinext/dev/lock.json` (mirroring Next.js'
  *   `.next/dev/lock` layout). `.vinext/` is already used by the fonts plugin
  *   to cache self-hosted Google Fonts, so this re-uses the same project-local
@@ -62,6 +65,31 @@ export declare function readLockfile(lockfilePath: string): DevServerInfo | unde
  * signal it (in which case it's still running, just owned by someone else).
  */
 export declare function isPidAlive(pid: number): boolean;
+/**
+ * Returns true if a lock with the given `startedAt` was written before the
+ * machine last booted.
+ *
+ * Such a lock was left behind by a session whose exit handler never ran (a
+ * crash, a forced restart, power loss). PIDs are handed out again after a
+ * boot, so the lock's PID may be held by an unrelated process, and
+ * `isPidAlive()` alone would report the dead server as running.
+ *
+ * The boot time is derived from `Date.now() - os.uptime()`. Stepping the wall
+ * clock forward moves it too (`os.uptime()` doesn't change), so a forward
+ * step larger than the uptime at which a server started makes its lock look
+ * stale, e.g. a VM resuming after the host slept. The second `vinext dev`
+ * then takes over, as in the acquisition race tolerated below: Vite moves it
+ * to another port, or it fails to bind with `strictPort`.
+ *
+ * Known limitations, where a lock is still checked by PID alone:
+ * - A wall clock that comes back from a reboot behind the previous session
+ *   (an RTC running slow, or NTP stepping it back) can leave the lock's
+ *   `startedAt` after the derived boot time.
+ * - Windows Fast Startup shuts down by hibernating the kernel, so
+ *   `os.uptime()` keeps counting across that shutdown.
+ * - A container restart doesn't reset the host's uptime.
+ */
+export declare function predatesCurrentBoot(startedAt: number): boolean;
 type FormatErrorOptions = {
   /** Existing server info from the lock file, if readable. */
   existing: DevServerInfo | undefined;
@@ -87,7 +115,8 @@ type AcquireOptions = {
   /** Initial server info to write. Port/URL may be updated later via `update()`. */
   info: DevServerInfo;
   /**
-   * If a lock file exists but its PID is dead, take over instead of failing.
+   * If a lock file exists but is stale (its PID is dead, or it was written
+   * before the current boot), take over instead of failing.
    * Defaults to `true`. Set to `false` for testing.
    */
   takeOverStale?: boolean;
@@ -117,4 +146,5 @@ type AcquireResult = AcquireSuccess | AcquireFailure;
  * already holds the lock.
  */
 export declare function tryAcquireLockfile(opts: AcquireOptions): AcquireResult;
-//#endregion
+//#endregion
+export {};