@fictjs/ssr 0.27.0 → 0.28.1

package/dist/{render-core-D0nOT_Pe.js → render-core-BgW-UZfD.js}

@@ -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;
 	__fictEnableSSR();
 	__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 = render(view, container);
@@ -1017,7 +1193,7 @@ function renderToDocumentInSession(view, options) {
 		}
 	} catch (error) {
 		__fictDisableSSR();
-		cleanupRenderResources(teardown, restoreGlobals, restoreManifest, true);
+		cleanupRenderResources(teardown, restoreGlobals, restoreManifest, releaseRenderLease, true);
 		throw error;
 	}
 	__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);
 		__fictEnableSSR();
 		__fictSetSSRScopeIdentifierPrefix(scopeIdentifierPrefix);
 		__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 = render(view, container);
@@ -1632,6 +1813,9 @@ function buildStreamRuntimeScript(options) {
 	}
 	return `<script${nonce}>${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;
@@ -1821,4 +2005,4 @@ function serializeDoctype(document, override) {
 //#endregion
 export { renderToStream as a, renderToPipeableStream as i, renderToDocument as n, renderToString as o, renderToPartial as r, renderToStringAsync as s, createSSRDocument as t };
 
-//# sourceMappingURL=render-core-D0nOT_Pe.js.map
+//# sourceMappingURL=render-core-BgW-UZfD.js.map