grammar and changeset

Author: ematipico

.changeset/hot-eyes-sink.md

@@ -42,6 +42,8 @@ export default defineConfig({
 
 The third sub-feature is content caching. It allows to cache **values** of nodes during the rendering phase. Among the new tools, this seemed to be the least useful, so for now it's not possible to control its size:
 
+When disabled, the pool engine won't cache strings, but only types.
+
 ```js
 // astro.config.mjs
 export default defineConfig({

packages/astro/src/runtime/server/render/queue/builder.ts

@@ -47,7 +47,10 @@ export async function buildRenderQueue(
 
 	// Process nodes depth-first
 	while (stack.length > 0) {
-		const item = stack.pop()!;
+		const item = stack.pop();
+		if (!item) {
+			continue;
+		}
 		let { node, parent } = item;
 
 		// Handle promises immediately (wait for resolution)
@@ -71,7 +74,7 @@ export async function buildRenderQueue(
 		// Handle different node types
 		if (typeof node === 'string') {
 			// Plain text content - use content-aware caching
-			// acquire('text', ...) returns TextNode, so we can safely assert
+			// Acquire('text', ...) returns TextNode, so we can safely assert
 			const queueNode = pool.acquire('text', node) as TextNode;
 			queueNode.content = node;
 			queue.nodes.push(queueNode);
@@ -105,10 +108,10 @@ export async function buildRenderQueue(
 			continue;
 		}
 
-		// Handle JSX vnodes (from MDX or JSX expressions)
+		// Handle JSX VNodes (from MDX or JSX expressions)
 		if (isVNode(node)) {
-			// Process JSX vnode through the JSX builder
-			// This will recursively handle the vnode and its children
+			// Process JSX VNode through the JSX builder
+			// This will push the VNode and its children onto the stack for processing
 			renderJSXToQueue(node, result, queue, pool, stack, parent, item.metadata);
 			continue;
 		}
@@ -138,7 +141,7 @@ export async function buildRenderQueue(
 			const expressions = node['expressions'];
 
 			// Push in forward order - stack pop() will reverse, then final reverse() corrects it
-			// Push first html part - mark as HTMLString so it won't be escaped
+			// Push first HTML part - mark as HTMLString so it won't be escaped
 			if (htmlParts[0]) {
 				const htmlString = queue.htmlStringCache
 					? queue.htmlStringCache.getOrCreate(htmlParts[0])
@@ -150,11 +153,11 @@ export async function buildRenderQueue(
 				});
 			}
 
-			// Interleave expressions and html parts
-			for (let i = 0; i < expressions.length; i++) {
+			// Interleave expressions and HTML parts
+			for (let i = 0; i < expressions.length; i = i + 1) {
 				// Push expression
 				stack.push({ node: expressions[i], parent, metadata: item.metadata });
-				// Push html part after expression - mark as HTMLString
+				// Push HTML part after expression - mark as HTMLString
 				if (htmlParts[i + 1]) {
 					const htmlString = queue.htmlStringCache
 						? queue.htmlStringCache.getOrCreate(htmlParts[i + 1])

packages/astro/src/runtime/server/render/queue/jsx-builder.ts

@@ -46,14 +46,14 @@ export function resetJSXQueueStats() {
 }
 
 /**
- * Processes JSX vnodes and adds them to the render queue.
+ * Processes JSX VNodes and adds them to the render queue.
  * Unlike renderJSX(), this doesn't build strings recursively -
  * it pushes nodes directly to the queue for batching and memory efficiency.
  *
  * This function handles JSX created by astro:jsx (JSX in .astro files).
- * It converts vnodes to queue nodes, enabling content-aware pooling and batching.
+ * It converts VNodes to queue nodes, enabling content-aware pooling and batching.
  *
- * @param vnode - JSX vnode to process
+ * @param vnode - JSX VNode to process
  * @param result - SSR result context
  * @param queue - Queue to append nodes to
  * @param pool - Node pool for memory efficiency
@@ -71,7 +71,7 @@ export function renderJSXToQueue(
 	metadata?: StackItem['metadata'],
 ): void {
 	// Track that JSX queue rendering is being used
-	jsxQueueStats.vnodeCount++;
+	jsxQueueStats.vnodeCount = jsxQueueStats.vnodeCount + 1;
 
 	// Handle primitive types
 	if (vnode instanceof HTMLString) {
@@ -106,13 +106,13 @@ export function renderJSXToQueue(
 	// Handle arrays - push each item to stack
 	if (Array.isArray(vnode)) {
 		// Push in reverse order so they're popped in correct order
-		for (let i = vnode.length - 1; i >= 0; i--) {
+		for (let i = vnode.length - 1; i >= 0; i = i - 1) {
 			stack.push({ node: vnode[i], parent, metadata });
 		}
 		return;
 	}
 
-	// Handle vnodes
+	// Handle VNodes
 	if (!isVNode(vnode)) {
 		// Fallback: convert to string
 		const str = String(vnode);
@@ -150,15 +150,15 @@ function handleVNode(
 
 	// Astro component factory
 	if (isAstroComponentFactory(vnode.type)) {
-		jsxQueueStats.componentCount++;
+		jsxQueueStats.componentCount = jsxQueueStats.componentCount + 1;
 		const factory = vnode.type;
 		let props: Record<string, any> = {};
 		let slots: Record<string, any> = {};
 
 		for (const [key, value] of Object.entries(vnode.props ?? {})) {
 			if (key === 'children' || (value && typeof value === 'object' && value['$$slot'])) {
 				// Slots need to return rendered content
-				// We create a function that renders the JSX vnode to string
+				// We create a function that renders the JSX VNode to string
 				slots[key === 'children' ? 'default' : key] = () => renderJSX(result, value);
 			} else {
 				props[key] = value;
@@ -177,7 +177,7 @@ function handleVNode(
 
 	// HTML element (string type like 'div', 'span')
 	if (typeof vnode.type === 'string' && vnode.type !== ClientOnlyPlaceholder) {
-		jsxQueueStats.elementCount++;
+		jsxQueueStats.elementCount = jsxQueueStats.elementCount + 1;
 		renderHTMLElement(vnode, result, queue, pool, stack, parent, metadata);
 		return;
 	}
@@ -223,7 +223,7 @@ function renderHTMLElement(
 	const isVoidElement = (children == null || children === '') && voidElementNames.test(tag);
 
 	if (isVoidElement) {
-		// Self-closing element as html-string (cached by content)
+		// Self-closing element as HTML-string (cached by content)
 		const html = `<${tag}${attrs}/>`;
 		const node = pool.acquire('html-string', html) as HtmlStringNode;
 		node.html = html;
@@ -232,7 +232,7 @@ function renderHTMLElement(
 	}
 
 	// Non-void element: open tag + children + close tag
-	// Build opening tag as html-string (cached by content)
+	// Build opening tag as HTML-string (cached by content)
 	const openTag = `<${tag}${attrs}>`;
 	const openTagHtml = queue.htmlStringCache
 		? queue.htmlStringCache.getOrCreate(openTag)
@@ -246,7 +246,7 @@ function renderHTMLElement(
 		stack.push({ node: processedChildren, parent, metadata });
 	}
 
-	// Create closing tag as html-string (cached by content)
+	// Create closing tag as HTML-string (cached by content)
 	const closeTag = `</${tag}>`;
 	const closeTagHtml = queue.htmlStringCache
 		? queue.htmlStringCache.getOrCreate(closeTag)

packages/astro/src/runtime/server/render/queue/pool.ts

@@ -60,24 +60,24 @@ export class NodePool {
 	 *
 	 * @param maxSize - Maximum number of nodes to keep in the pool (default: 1000)
 	 * @param enableStats - Enable statistics tracking (default: false for performance)
-	 * @param enableContentCache - Enable content-aware caching for text/html nodes (default: true)
+	 * @param enableContentCache - Enable content-aware caching for text/HTML nodes (default: true)
 	 */
 	constructor(maxSize = 1000, enableContentCache = false, enableStats = false) {
 		this.maxSize = maxSize;
 		this.enableStats = enableStats;
 		this.enableContentCache = enableContentCache;
 		if (maxSize > 0) {
-			// Warm up cache only if the pool size is bigger than 0. We treat zero as if there's no pool.
+			// Warm up cache only if the pool size is greater than 0. We treat zero as if there's no pool.
 			this.warmCache([...COMMON_HTML_PATTERNS]);
 		}
 	}
 
 	/**
-	 * Acquires a queue node from the pool or creates a new one if pool is empty.
-	 * Supports content-aware caching for text and html-string nodes.
+	 * Acquires a queue node from the pool or creates a new one if the pool is empty.
+	 * Supports content-aware caching for text and HTML-string nodes.
 	 *
 	 * @param type - The type of queue node to create
-	 * @param content - Optional content for content-aware caching (text or html)
+	 * @param content - Optional content for content-aware caching (text or HTML)
 	 * @returns A queue node ready to be populated with data
 	 */
 	acquire(type: QueueNode['type'], content?: string): QueueNode {
@@ -179,7 +179,7 @@ export class NodePool {
 				this.stats.releasedDropped = this.stats.releasedDropped + 1;
 			}
 		}
-		// If pool is full, let the node be garbage collected
+		// If the pool is full, let the node be garbage collected
 	}
 
 	/**
@@ -336,8 +336,8 @@ export const COMMON_HTML_PATTERNS = [
 ] as const;
 
 /**
- * Returns an instance of the `NodePool` based on its configuration
- * @param config
+ * Returns an instance of the `NodePool` based on its configuration.
+ * @param config - The queued rendering configuration from the SSR manifest
  */
 export function newNodePool(
 	config: NonNullable<SSRManifest['experimentalQueuedRendering']>,

packages/astro/src/runtime/server/render/queue/renderer.ts

@@ -6,7 +6,7 @@ import type { QueueNode, RenderQueue } from './types.js';
 /**
  * Renders a queue of nodes to a destination.
  * This function processes nodes sequentially with batching optimization.
- * Consecutive batchable nodes (text, html-string, simple elements) are
+ * Consecutive batchable nodes (text, HTML-string, simple elements) are
  * combined into a single write to reduce overhead.
  *
  * @param queue - The render queue to process
@@ -32,7 +32,7 @@ export async function renderQueue(
 				const batchStart = i;
 				while (i < queue.nodes.length && canBatch(queue.nodes[i])) {
 					batchBuffer += renderNodeToString(queue.nodes[i]);
-					i++;
+					i = i + 1;
 				}
 
 				// Flush accumulated batch
@@ -58,7 +58,7 @@ export async function renderQueue(
 					pool.release(node);
 				}
 
-				i++;
+				i = i + 1;
 			}
 		} catch (error) {
 			// Stop on first error as requested