@fictjs/ssr 0.27.0 → 0.28.1

package/README.md

@@ -1,6 +1,13 @@
 # @fictjs/ssr
 
-Fict's Server-Side Rendering (SSR) package, providing high-performance server-side rendering and client-side resumability capabilities.
+Fict's Satellite Server-Side Rendering (SSR) package, providing supported
+string and streaming rendering plus opt-in client resumability.
+
+> **Preview** — resumability, snapshot schema v2, and partial prerendering have no
+> semver guarantee and are excluded from Core 1.0. They require
+> `includeSnapshot: true`, compiler `resumable: true`, and the
+> `fict/experimental/loader` entrypoint. Basic string and streaming SSR does not
+> enable them by default.
 
 ## Table of Contents
 
@@ -20,7 +27,9 @@ Fict's Server-Side Rendering (SSR) package, providing high-performance server-si
 
 ## Overview
 
-Fict SSR adopts a **Resumability** architecture, which is fundamentally different from traditional Hydration:
+Supported SSR produces HTML without a resumability snapshot by default. The
+optional **Preview Resumability** architecture is fundamentally different from
+traditional hydration:
 
 | Feature                   | Traditional Hydration             | Fict Resumability                 |
 | ------------------------- | --------------------------------- | --------------------------------- |
@@ -29,7 +38,7 @@ Fict SSR adopts a **Resumability** architecture, which is fundamentally differen
 | Handler Loading           | All preloaded                     | Lazy loaded on demand             |
 | State Restoration         | Re-calculated                     | Restored from serialized snapshot |
 
-### How it Works
+### How Preview Resumability Works
 
 ```
 ┌─────────────────────────────────────────────────────────────────┐
@@ -79,7 +88,7 @@ import { renderToString } from '@fictjs/ssr'
 import { App } from './App'
 
 const html = renderToString(() => <App />, {
-  includeSnapshot: true,  // Include state snapshot (default true)
+  includeSnapshot: true, // Explicit Preview snapshot opt-in (default false)
   containerId: 'app',
   manifest: './dist/client/fict.manifest.json',
 })
@@ -90,7 +99,7 @@ const html = renderToString(() => <App />, {
 ```typescript
 // entry-client.tsx
 import { render } from 'fict'
-import { installResumableLoader } from 'fict/loader'
+import { installResumableLoader } from 'fict/experimental/loader'
 import { App } from './App'
 
 // Load manifest (production)
@@ -285,7 +294,7 @@ interface RenderToStringOptions {
   doctype?: string | null
 
   // Resumability Configuration
-  includeSnapshot?: boolean // Default: true
+  includeSnapshot?: boolean // Preview opt-in; default: false
   snapshotScriptId?: string // Default: '__FICT_SNAPSHOT__'
   snapshotTarget?: 'container' | 'body' | 'head'
 
@@ -299,7 +308,11 @@ By default SSR does not write `window`, `document`, `Node`, or related DOM const
 `globalThis`. This keeps concurrent renders from racing over process-global DOM state. Components
 should use Fict's render-provided document/ownerDocument paths; set `exposeGlobals: true` only for
 legacy code that still reads DOM globals during server render. That compatibility mode is restored
-on `dispose()`, but it is not concurrency-safe while overlapping renders are active.
+on `dispose()`. Default renders may overlap each other, but a compatibility render is exclusive
+with every other SSR render so no request can observe another request's process-global DOM. On a
+non-extensible hardened global object, ordinary render-local SSR remains available without a
+process marker; compatibility mode remains unavailable because it cannot acquire its exclusive
+lease or install DOM globals.
 
 ### renderToStringAsync
 
@@ -367,6 +380,11 @@ Trusted Types deployments should use this external observer runtime. The patch
 runtime moves `<template>` content with DOM APIs (`content` + `insertBefore`) and
 does not call `innerHTML`, `insertAdjacentHTML`, `eval`, or `Function`.
 
+When Preview snapshots are enabled on a nonce-free strict-CSP route, keep
+`snapshotTarget` at `container` or `body`. Incremental `head` snapshots require a
+small executable mover; external runtime mode rejects that combination unless
+`scriptNonce` is non-empty.
+
 Each shell stream receives an automatic unique namespace for its Suspense patch
 identifiers. When independently cached fragments or streams from multiple
 services can be composed into one document, pass a stable

package/dist/experimental.cjs

@@ -1,3 +1,3 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_render_core = require("./render-core-D_EheVwh.cjs");
+const require_render_core = require("./render-core-BDbPxAeQ.cjs");
 exports.renderToPartial = require_render_core.renderToPartial;

package/dist/experimental.d.cts

@@ -1,2 +1,2 @@
-import { l as renderToPartial, t as PartialPrerenderResult } from "./render-core-KCiJV_SK.cjs";
+import { l as renderToPartial, t as PartialPrerenderResult } from "./render-core-FDu-zTWN.cjs";
 export { type PartialPrerenderResult, renderToPartial };

package/dist/experimental.d.ts

@@ -1,2 +1,2 @@
-import { l as renderToPartial, t as PartialPrerenderResult } from "./render-core-KCiJV_SK.js";
+import { l as renderToPartial, t as PartialPrerenderResult } from "./render-core-FDu-zTWN.js";
 export { type PartialPrerenderResult, renderToPartial };

package/dist/experimental.js

@@ -1,2 +1,2 @@
-import { r as renderToPartial } from "./render-core-D0nOT_Pe.js";
+import { r as renderToPartial } from "./render-core-BgW-UZfD.js";
 export { renderToPartial };

package/dist/experimental.node.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_render_core = require("./render-core-D_EheVwh.cjs");
+const require_render_core = require("./render-core-BDbPxAeQ.cjs");
 require("./node-session-carrier-CTo-1Awq.cjs");
 require("./experimental.cjs");
 exports.renderToPartial = require_render_core.renderToPartial;

package/dist/experimental.node.d.cts

@@ -1,2 +1,2 @@
-import { l as renderToPartial, t as PartialPrerenderResult } from "./render-core-KCiJV_SK.cjs";
+import { l as renderToPartial, t as PartialPrerenderResult } from "./render-core-FDu-zTWN.cjs";
 export { type PartialPrerenderResult, renderToPartial };

package/dist/experimental.node.d.ts

@@ -1,2 +1,2 @@
-import { l as renderToPartial, t as PartialPrerenderResult } from "./render-core-KCiJV_SK.js";
+import { l as renderToPartial, t as PartialPrerenderResult } from "./render-core-FDu-zTWN.js";
 export { type PartialPrerenderResult, renderToPartial };

package/dist/experimental.node.js

@@ -1,4 +1,4 @@
-import { r as renderToPartial } from "./render-core-D0nOT_Pe.js";
+import { r as renderToPartial } from "./render-core-BgW-UZfD.js";
 import "./node-session-carrier-ClqRbdoQ.js";
 import "./experimental.js";
 export { renderToPartial };

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_render_core = require("./render-core-D_EheVwh.cjs");
+const require_render_core = require("./render-core-BDbPxAeQ.cjs");
 exports.createSSRDocument = require_render_core.createSSRDocument;
 exports.renderToDocument = require_render_core.renderToDocument;
 exports.renderToPipeableStream = require_render_core.renderToPipeableStream;

package/dist/index.d.cts

@@ -1,2 +1,2 @@
-import { a as RenderToStringOptions, c as renderToDocument, d as renderToStream, f as renderToString, i as RenderToStreamOptions, n as PipeableStream, o as SSRDom, p as renderToStringAsync, r as RenderToDocumentResult, s as createSSRDocument, u as renderToPipeableStream } from "./render-core-KCiJV_SK.cjs";
+import { a as RenderToStringOptions, c as renderToDocument, d as renderToStream, f as renderToString, i as RenderToStreamOptions, n as PipeableStream, o as SSRDom, p as renderToStringAsync, r as RenderToDocumentResult, s as createSSRDocument, u as renderToPipeableStream } from "./render-core-FDu-zTWN.cjs";
 export { type PipeableStream, type RenderToDocumentResult, type RenderToStreamOptions, type RenderToStringOptions, type SSRDom, createSSRDocument, renderToDocument, renderToPipeableStream, renderToStream, renderToString, renderToStringAsync };

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { a as RenderToStringOptions, c as renderToDocument, d as renderToStream, f as renderToString, i as RenderToStreamOptions, n as PipeableStream, o as SSRDom, p as renderToStringAsync, r as RenderToDocumentResult, s as createSSRDocument, u as renderToPipeableStream } from "./render-core-KCiJV_SK.js";
+import { a as RenderToStringOptions, c as renderToDocument, d as renderToStream, f as renderToString, i as RenderToStreamOptions, n as PipeableStream, o as SSRDom, p as renderToStringAsync, r as RenderToDocumentResult, s as createSSRDocument, u as renderToPipeableStream } from "./render-core-FDu-zTWN.js";
 export { type PipeableStream, type RenderToDocumentResult, type RenderToStreamOptions, type RenderToStringOptions, type SSRDom, createSSRDocument, renderToDocument, renderToPipeableStream, renderToStream, renderToString, renderToStringAsync };

package/dist/index.js

@@ -1,2 +1,2 @@
-import { a as renderToStream, i as renderToPipeableStream, n as renderToDocument, o as renderToString, s as renderToStringAsync, t as createSSRDocument } from "./render-core-D0nOT_Pe.js";
+import { a as renderToStream, i as renderToPipeableStream, n as renderToDocument, o as renderToString, s as renderToStringAsync, t as createSSRDocument } from "./render-core-BgW-UZfD.js";
 export { createSSRDocument, renderToDocument, renderToPipeableStream, renderToStream, renderToString, renderToStringAsync };

package/dist/index.node.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_render_core = require("./render-core-D_EheVwh.cjs");
+const require_render_core = require("./render-core-BDbPxAeQ.cjs");
 require("./index.cjs");
 require("./node-session-carrier-CTo-1Awq.cjs");
 exports.createSSRDocument = require_render_core.createSSRDocument;

package/dist/index.node.d.cts

@@ -1,2 +1,2 @@
-import { a as RenderToStringOptions, c as renderToDocument, d as renderToStream, f as renderToString, i as RenderToStreamOptions, n as PipeableStream, o as SSRDom, p as renderToStringAsync, r as RenderToDocumentResult, s as createSSRDocument, u as renderToPipeableStream } from "./render-core-KCiJV_SK.cjs";
+import { a as RenderToStringOptions, c as renderToDocument, d as renderToStream, f as renderToString, i as RenderToStreamOptions, n as PipeableStream, o as SSRDom, p as renderToStringAsync, r as RenderToDocumentResult, s as createSSRDocument, u as renderToPipeableStream } from "./render-core-FDu-zTWN.cjs";
 export { type PipeableStream, type RenderToDocumentResult, type RenderToStreamOptions, type RenderToStringOptions, type SSRDom, createSSRDocument, renderToDocument, renderToPipeableStream, renderToStream, renderToString, renderToStringAsync };

package/dist/index.node.d.ts

@@ -1,2 +1,2 @@
-import { a as RenderToStringOptions, c as renderToDocument, d as renderToStream, f as renderToString, i as RenderToStreamOptions, n as PipeableStream, o as SSRDom, p as renderToStringAsync, r as RenderToDocumentResult, s as createSSRDocument, u as renderToPipeableStream } from "./render-core-KCiJV_SK.js";
+import { a as RenderToStringOptions, c as renderToDocument, d as renderToStream, f as renderToString, i as RenderToStreamOptions, n as PipeableStream, o as SSRDom, p as renderToStringAsync, r as RenderToDocumentResult, s as createSSRDocument, u as renderToPipeableStream } from "./render-core-FDu-zTWN.js";
 export { type PipeableStream, type RenderToDocumentResult, type RenderToStreamOptions, type RenderToStringOptions, type SSRDom, createSSRDocument, renderToDocument, renderToPipeableStream, renderToStream, renderToString, renderToStringAsync };

package/dist/index.node.js

@@ -1,4 +1,4 @@
-import { a as renderToStream, i as renderToPipeableStream, n as renderToDocument, o as renderToString, s as renderToStringAsync, t as createSSRDocument } from "./render-core-D0nOT_Pe.js";
+import { a as renderToStream, i as renderToPipeableStream, n as renderToDocument, o as renderToString, s as renderToStringAsync, t as createSSRDocument } from "./render-core-BgW-UZfD.js";
 import "./index.js";
 import "./node-session-carrier-ClqRbdoQ.js";
 export { createSSRDocument, renderToDocument, renderToPipeableStream, renderToStream, renderToString, renderToStringAsync };

package/dist/{render-core-D_EheVwh.cjs → render-core-BDbPxAeQ.cjs}

@@ -22,7 +22,55 @@ function getNodeRequire() {
 }
 //#endregion
 //#region src/globals.ts
-function installGlobals(window, document) {
+const activeGlobalTargets = /* @__PURE__ */ new WeakSet();
+const activeSharedGlobalTargets = /* @__PURE__ */ new WeakMap();
+const GLOBALS_LEASE = Symbol.for("@fictjs/ssr.exposeGlobalsLease");
+const SHARED_RENDER_LEASE = Symbol.for("@fictjs/ssr.sharedRenderLease");
+/**
+* Reserve the process-global target for an SSR render that does not expose DOM
+* globals. Shared reservations may overlap each other, but they prevent a
+* compatibility-global render from starting until every owner has cleaned up.
+*/
+function acquireSharedGlobalTarget(target = globalThis) {
+	const local = activeSharedGlobalTargets.get(target);
+	if (local) {
+		const descriptor = Object.getOwnPropertyDescriptor(target, GLOBALS_LEASE);
+		if (!descriptor || !("value" in descriptor) || descriptor.value !== local.state) throw poisonedSharedLeaseError();
+		setSharedLeaseCount(local.state, readSharedLeaseCount(local.state) + 1);
+		local.count += 1;
+		return createSharedLeaseRelease(target, local);
+	}
+	if (activeGlobalTargets.has(target)) throw renderOverlapError();
+	const descriptor = Object.getOwnPropertyDescriptor(target, GLOBALS_LEASE);
+	let state;
+	if (descriptor === void 0) {
+		if (isDefinitelyNonExtensible(target)) return () => {};
+		state = createSharedLeaseState();
+		try {
+			Object.defineProperty(target, GLOBALS_LEASE, {
+				configurable: true,
+				enumerable: false,
+				value: state,
+				writable: false
+			});
+		} catch (error) {
+			const failure = /* @__PURE__ */ new Error(`[fict/ssr] Failed to acquire the shared SSR render lease: ${formatError(error)}`);
+			failure.cause = error;
+			throw failure;
+		}
+	} else {
+		if (!("value" in descriptor) || !isSharedLeaseState(descriptor.value)) throw renderOverlapError();
+		state = descriptor.value;
+		setSharedLeaseCount(state, readSharedLeaseCount(state) + 1);
+	}
+	const localLease = {
+		state,
+		count: 1
+	};
+	activeSharedGlobalTargets.set(target, localLease);
+	return createSharedLeaseRelease(target, localLease);
+}
+function installGlobals(window, document, target = globalThis) {
 	const win = window;
 	const required = {
 		window: win,
@@ -47,17 +95,44 @@ function installGlobals(window, document) {
 	};
 	const missing = Object.entries(required).filter(([, value]) => value === void 0).map(([key]) => key);
 	if (missing.length) throw new Error(`[fict/ssr] Missing DOM globals: ${missing.join(", ")}`);
-	const globals = {
+	const globals = Object.entries({
 		...required,
 		...optional
-	};
-	const keys = Object.keys(globals);
-	const snapshot = captureGlobals(keys);
-	for (const key of keys) {
-		const value = globals[key];
-		if (value !== void 0) globalThis[key] = value;
+	}).filter(([, value]) => value !== void 0);
+	const lease = acquireGlobalTarget(target);
+	let snapshot = [];
+	let installingKey = "<capture>";
+	try {
+		snapshot = captureGlobals(target, globals.map(([key]) => key));
+		for (const [key, value] of globals) {
+			installingKey = key;
+			const previous = snapshot.find((entry) => entry.key === key)?.descriptor;
+			Object.defineProperty(target, key, {
+				configurable: true,
+				enumerable: previous?.enumerable ?? true,
+				value,
+				writable: true
+			});
+		}
+	} catch (error) {
+		let rollbackError;
+		try {
+			restoreGlobals(target, snapshot);
+			releaseGlobalTarget(target, lease);
+		} catch (caught) {
+			rollbackError = caught;
+		}
+		const failure = /* @__PURE__ */ new Error(rollbackError === void 0 ? `[fict/ssr] Failed to install DOM global \`${installingKey}\`: ${formatError(error)}` : `[fict/ssr] Failed to install DOM global \`${installingKey}\` and roll back the partial installation: ${formatError(error)}; rollback: ${formatError(rollbackError)}`);
+		failure.cause = error;
+		throw failure;
 	}
-	return () => restoreGlobals(snapshot);
+	let active = true;
+	return () => {
+		if (!active) return;
+		restoreGlobals(target, snapshot);
+		releaseGlobalTarget(target, lease);
+		active = false;
+	};
 }
 function installManifest(manifest) {
 	if (!manifest) return () => {};
@@ -85,22 +160,120 @@ function installManifest(manifest) {
 		else delete globalThis[key];
 	};
 }
-function captureGlobals(keys) {
+function captureGlobals(target, keys) {
 	const snapshot = [];
-	for (const key of keys) {
-		const exists = Object.prototype.hasOwnProperty.call(globalThis, key);
-		const value = globalThis[key];
-		snapshot.push({
-			key,
-			exists,
-			value
+	for (const key of keys) snapshot.push({
+		key,
+		descriptor: Object.getOwnPropertyDescriptor(target, key)
+	});
+	return snapshot;
+}
+function restoreGlobals(target, snapshot) {
+	let firstError;
+	for (let index = snapshot.length - 1; index >= 0; index--) {
+		const entry = snapshot[index];
+		if (!entry) continue;
+		try {
+			if (entry.descriptor) Object.defineProperty(target, entry.key, entry.descriptor);
+			else if (!Reflect.deleteProperty(target, entry.key)) throw new Error(`Could not delete newly installed global \`${entry.key}\`.`);
+		} catch (error) {
+			firstError ??= error;
+		}
+	}
+	if (firstError !== void 0) throw firstError;
+}
+function acquireGlobalTarget(target) {
+	if (activeGlobalTargets.has(target) || activeSharedGlobalTargets.has(target) || Object.getOwnPropertyDescriptor(target, GLOBALS_LEASE) !== void 0) throw renderOverlapError();
+	const lease = {};
+	activeGlobalTargets.add(target);
+	try {
+		Object.defineProperty(target, GLOBALS_LEASE, {
+			configurable: true,
+			enumerable: false,
+			value: lease,
+			writable: false
 		});
+	} catch (error) {
+		activeGlobalTargets.delete(target);
+		const failure = /* @__PURE__ */ new Error(`[fict/ssr] Failed to acquire the process DOM-global compatibility lease: ${formatError(error)}`);
+		failure.cause = error;
+		throw failure;
 	}
-	return snapshot;
+	return lease;
+}
+function releaseGlobalTarget(target, lease) {
+	const descriptor = Object.getOwnPropertyDescriptor(target, GLOBALS_LEASE);
+	if (!descriptor || !("value" in descriptor) || descriptor.value !== lease) throw new Error("[fict/ssr] The process DOM-global compatibility lease changed before cleanup.");
+	if (!Reflect.deleteProperty(target, GLOBALS_LEASE)) throw new Error("[fict/ssr] Could not release the process DOM-global compatibility lease.");
+	activeGlobalTargets.delete(target);
+}
+function formatError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function isDefinitelyNonExtensible(target) {
+	try {
+		return !Object.isExtensible(target);
+	} catch {
+		return false;
+	}
+}
+function createSharedLeaseState() {
+	const state = {};
+	Object.defineProperties(state, {
+		[SHARED_RENDER_LEASE]: {
+			configurable: false,
+			enumerable: false,
+			value: true,
+			writable: false
+		},
+		count: {
+			configurable: false,
+			enumerable: false,
+			value: 1,
+			writable: true
+		}
+	});
+	return state;
+}
+function isSharedLeaseState(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const marker = Object.getOwnPropertyDescriptor(value, SHARED_RENDER_LEASE);
+	const count = Object.getOwnPropertyDescriptor(value, "count");
+	return marker !== void 0 && "value" in marker && marker.value === true && count !== void 0 && "value" in count && Number.isSafeInteger(count.value) && count.value > 0 && count.writable === true;
+}
+function readSharedLeaseCount(state) {
+	const descriptor = Object.getOwnPropertyDescriptor(state, "count");
+	if (!descriptor || !("value" in descriptor) || !Number.isSafeInteger(descriptor.value) || descriptor.value <= 0 || descriptor.writable !== true) throw poisonedSharedLeaseError();
+	return descriptor.value;
 }
-function restoreGlobals(snapshot) {
-	for (const entry of snapshot) if (entry.exists) globalThis[entry.key] = entry.value;
-	else delete globalThis[entry.key];
+function setSharedLeaseCount(state, count) {
+	try {
+		Object.defineProperty(state, "count", { value: count });
+	} catch (error) {
+		const failure = poisonedSharedLeaseError();
+		failure.cause = error;
+		throw failure;
+	}
+}
+function createSharedLeaseRelease(target, local) {
+	let active = true;
+	return () => {
+		if (!active) return;
+		const descriptor = Object.getOwnPropertyDescriptor(target, GLOBALS_LEASE);
+		if (!descriptor || !("value" in descriptor) || descriptor.value !== local.state) throw poisonedSharedLeaseError();
+		const count = readSharedLeaseCount(local.state);
+		if (count > 1) setSharedLeaseCount(local.state, count - 1);
+		else if (!Reflect.deleteProperty(target, GLOBALS_LEASE)) throw new Error("[fict/ssr] Could not release the shared SSR render lease.");
+		local.count -= 1;
+		if (local.count === 0) activeSharedGlobalTargets.delete(target);
+		active = false;
+	};
+}
+function renderOverlapError() {
+	return /* @__PURE__ */ new Error("[fict/ssr] `exposeGlobals: true` cannot be used by overlapping or nested renders, including renders that do not expose globals. Keep DOM access render-local, or wait for every active render to clean up.");
+}
+function poisonedSharedLeaseError() {
+	return /* @__PURE__ */ new Error("[fict/ssr] The shared SSR render lease changed before cleanup.");
 }
 function readTextFileFromPath(path) {
 	const deno = globalThis.Deno;
@@ -996,18 +1169,21 @@ function renderToDocument(view, options = {}) {
 function renderToDocumentInSession(view, options) {
 	validateScopeIdentifierPrefix(options.scopeIdentifierPrefix);
 	const scopeIdentifierPrefix = resolveScopeIdentifierPrefix(options.scopeIdentifierPrefix);
-	const includeSnapshot = options.includeSnapshot !== false;
+	const includeSnapshot = options.includeSnapshot === true;
 	(0, _fictjs_runtime_internal.__fictEnableSSR)();
 	(0, _fictjs_runtime_internal.__fictSetSSRScopeIdentifierPrefix)(scopeIdentifierPrefix);
 	let dom;
 	let restoreGlobals = () => {};
 	let restoreManifest = () => {};
+	let releaseRenderLease = () => {};
 	let container;
 	let teardown = () => {};
 	try {
+		const shouldExpose = options.exposeGlobals === true;
+		releaseRenderLease = shouldExpose ? () => {} : acquireSharedGlobalTarget();
 		dom = resolveDom(options);
 		const { document, window } = dom;
-		restoreGlobals = options.exposeGlobals === true ? installGlobals(window, document) : () => {};
+		restoreGlobals = shouldExpose ? installGlobals(window, document) : () => {};
 		restoreManifest = installManifest(options.manifest);
 		container = resolveContainer(document, options);
 		teardown = (0, _fictjs_runtime.render)(view, container);
@@ -1017,7 +1193,7 @@ function renderToDocumentInSession(view, options) {
 		}
 	} catch (error) {
 		(0, _fictjs_runtime_internal.__fictDisableSSR)();
-		cleanupRenderResources(teardown, restoreGlobals, restoreManifest, true);
+		cleanupRenderResources(teardown, restoreGlobals, restoreManifest, releaseRenderLease, true);
 		throw error;
 	}
 	(0, _fictjs_runtime_internal.__fictDisableSSR)();
@@ -1025,10 +1201,10 @@ function renderToDocumentInSession(view, options) {
 	try {
 		html = serializeOutput(dom.document, container, options);
 	} catch (error) {
-		cleanupRenderResources(teardown, restoreGlobals, restoreManifest, true);
+		cleanupRenderResources(teardown, restoreGlobals, restoreManifest, releaseRenderLease, true);
 		throw error;
 	}
-	const dispose = () => cleanupRenderResources(teardown, restoreGlobals, restoreManifest, false);
+	const dispose = () => cleanupRenderResources(teardown, restoreGlobals, restoreManifest, releaseRenderLease, false);
 	return {
 		html,
 		document: dom.document,
@@ -1216,13 +1392,14 @@ function resolveDom(options) {
 function isPromiseLike(value) {
 	return typeof value === "object" && value !== null && typeof value.then === "function";
 }
-function cleanupRenderResources(teardown, restoreGlobals, restoreManifest, suppressErrors) {
+function cleanupRenderResources(teardown, restoreGlobals, restoreManifest, releaseRenderLease, suppressErrors) {
 	let failed = false;
 	let firstError;
 	for (const cleanup of [
 		teardown,
 		restoreGlobals,
-		restoreManifest
+		restoreManifest,
+		releaseRenderLease
 	]) try {
 		cleanup();
 	} catch (error) {
@@ -1273,6 +1450,7 @@ function startStreamingRenderInSession(session, view, options, writer, releaseSe
 	let dom = null;
 	let restoreGlobals = () => {};
 	let restoreManifest = () => {};
+	let releaseRenderLease = () => {};
 	let teardown = () => {};
 	let container = null;
 	let closed = false;
@@ -1290,7 +1468,7 @@ function startStreamingRenderInSession(session, view, options, writer, releaseSe
 	const mode = options.mode ?? "shell";
 	const scopeIdentifierPrefix = resolveScopeIdentifierPrefix(options.scopeIdentifierPrefix);
 	const streamIdentifierPrefix = mode === "shell" ? resolveStreamIdentifierPrefix(options.streamIdentifierPrefix) : null;
-	const includeSnapshot = options.includeSnapshot !== false;
+	const includeSnapshot = options.includeSnapshot === true;
 	const sentScopeSnapshots = /* @__PURE__ */ new Map();
 	const boundaryMap = /* @__PURE__ */ new Map();
 	let boundaryId = 0;
@@ -1397,7 +1575,7 @@ function startStreamingRenderInSession(session, view, options, writer, releaseSe
 			});
 		} catch {}
 		try {
-			cleanupRenderResources(teardown, restoreGlobals, restoreManifest, true);
+			cleanupRenderResources(teardown, restoreGlobals, restoreManifest, releaseRenderLease, true);
 		} finally {
 			releaseSession();
 		}
@@ -1553,11 +1731,14 @@ function startStreamingRenderInSession(session, view, options, writer, releaseSe
 		removeAbortListener = () => options.signal?.removeEventListener("abort", onAbort);
 	}
 	try {
+		validateExternalHeadSnapshotCsp(resolvedOptions, includeSnapshot, mode);
 		(0, _fictjs_runtime_internal.__fictEnableSSR)();
 		(0, _fictjs_runtime_internal.__fictSetSSRScopeIdentifierPrefix)(scopeIdentifierPrefix);
 		(0, _fictjs_runtime_internal.__fictSetSSRStreamHooks)(hooks);
+		const shouldExpose = resolvedOptions.exposeGlobals === true;
+		releaseRenderLease = shouldExpose ? () => {} : acquireSharedGlobalTarget();
 		dom = resolveDom(resolvedOptions);
-		restoreGlobals = resolvedOptions.exposeGlobals === true ? installGlobals(dom.window, dom.document) : () => {};
+		restoreGlobals = shouldExpose ? installGlobals(dom.window, dom.document) : () => {};
 		restoreManifest = installManifest(resolvedOptions.manifest);
 		container = resolveContainer(dom.document, resolvedOptions);
 		teardown = (0, _fictjs_runtime.render)(view, container);
@@ -1632,6 +1813,9 @@ function buildStreamRuntimeScript(options) {
 	}
 	return `<script${nonce}>${require_stream_runtime.createStreamRuntimeCode({ observerMode: resolveStreamPatchMode(options) === "observer" })}<\/script>`;
 }
+function validateExternalHeadSnapshotCsp(options, includeSnapshot, mode) {
+	if (includeSnapshot && mode === "shell" && options.snapshotTarget === "head" && options.streamRuntime === "external" && !options.scriptNonce) throw new Error("[fict/ssr] Streaming Preview snapshots with `snapshotTarget: \"head\"` and an external runtime require a non-empty `scriptNonce`, because incremental head insertion uses an inline executable mover. Use `snapshotTarget: \"container\"` or `\"body\"` for a nonce-free strict CSP route.");
+}
 function buildPatchChunk(id, content, options) {
 	const namespaceAttribute = content.namespace ? ` data-fict-patch-namespace="${content.namespace}"` : "";
 	const html = content.namespace === "svg" ? `<svg>${content.html}</svg>` : content.namespace === "mathml" ? `<math>${content.html}</math>` : content.html;