Critical fail: Twig processing resulting in blank page

[NoNoNo]

Using Grav 1.8.0-beta.29 with PHP 8.5.1

With certain CMS source files, Twig processing results in a blank page (page.content is empty).

If process.twig is set to false, the page displays correctly.

I constructed a minimal test case to reproduce this issue. Please note, that in this test case no Twig features are used at all!

#!/usr/bin/env sh

composer create-project 'getgrav/grav:1.8.0-beta.29' testcase && \
cd testcase && \
cat > user/pages/01.home/default.md <<'EOT'
---
title: 'Test Case'
process:
  markdown: false
  twig: true
---

<p>
	·····, ···· ··· ··············· ··········· ··· ··. ····· ······ ··· ·······
	······, ··· ··· ················· ······· ·· ··· ····, ··· ············
	·········· ······ ····' ··· ········· ··· ·············· ···
	················ ··· ············ ····· ··· ··. ············ ·· ·· ········,
	··· ···· ·· ········.
</p>
<p>
	<a href="····://···.······-····.···/··/·······-·····.····"
		>····· ··· ····· ············· ······· ··· ················ ···
		····-········· ······· ······ ··· ······ ········</a
	>
</p>
<figure class="image-caption">
	<img
		loading="lazy"
		title="······ ···· ··· ······ ··············· ··· ····· ········· ·· ···· ···· ·· ···· (····: ·········· ··· ······-·····-············)"
		alt=""
		class="caption"
		src="/~······/······/···/······/·/·/·/·/-/····-······-···············-·····-·········-········-····-········.···?·-········"
		sizes="100vw"
		width="502"
		height="292"
	/>
	<figcaption class="">
		······ ···· ··· ······ ··············· ··· ····· ········· ·· ···· ····
		·· ···· (····: ·········· ··· ······-·····-············)
	</figcaption>
</figure>
<p>
	······ ···· ······· ·· ··· ··········· ······ ······· ··· ········· ···
	········ ·· ··· ······· ················ ········· ··················
	·······, ··· ··· ···· ·········· ··· ··········· ·········· ····. ····· ····
	···· ····· ······ ········· ·······, ····· ····· ······· ···· ·· ···
	··············· ·········· ·····. ····· ····· ··········· ··· ··········
	····· ····· ········ ··· ······ ······ ···· ···· ····· ········ ··· ···
	·············· ······ ··· ··········· ··· ···········, ············ ···
	··········· ··········· (············ ·· ··· ·············- ···
	············· ··· ················ ··················). ···········
	··············· ··· ·············· ······· ···· ·.·. ··· ······
	···············, ······· ·······, ······ ········· (······ ············ ···
	···· ··· ··. ···· ··· ··· ········ ··· ················· ············
	········ ········· ··· ·········· ······ ···), ···· ············, ······
	·····, ······ ······, ······· ····· (··· ··· ···· ······ ···· ············
	··········· ···), ······ ··········, ······· ···········, ······ ·······,
	······· ······, ······ ·······, ···· ········ ··· ········, ···· ····,
	······ ·····, ···· ·········, ······ ·········, ········ ··· ·········,
	······· ·······, ······· ······, ····· ·····, ······· ······, ········
	········, ······· ········, ····· ········, ····· ····, ···· ·····, ····
	·············, ···· ··· ·····, ····· ·······, ······· ·······, ······
	···········, ····· ········ ········, ····· ········ ··· ····· ···········.
</p>
<figure class="image-caption">
	<img
		loading="lazy"
		title="······· ··········· ·· ····· ············· ·· ······ ···· ·· ····· ····: ··· ·············· ···, ····· ····, ·· ····· ··········· ···········, ···, ··· ······ ··· ················ ·············, ··· ················ ········ ······ ··········, ··· ······ ··· ············· ··········. &ndash; ······· ···········"
		alt=""
		class="caption"
		src="/~······/······/···/······/·/·/·/·/·/·······-············-··-······-····-········.···?·-········"
		sizes="100vw"
		width="512"
		height="318"
	/>
	<figcaption class="">
		······· ··········· ·· ····· ············· ·· ······ ···· ·· ····· ····:
		··· ·············· ···, ····· ····, ·· ····· ··········· ···········,
		···, ··· ······ ··· ················ ·············, ··· ················
		········ ······ ··········, ··· ······ ··· ············· ··········.
		&ndash; ······· ···········
	</figcaption>
</figure>
<p>
	··· ········ ··· ······ ····, ······ ····· ···· ··· ·· ············
	··········· ····, ··· ·· ···· ·············, ··· ··· ··· ··············, ···
	··· ···· ··· ····, ··· ······ ····· ····· ···· ··········· ····. ···· ·····
	··· ····· ··········· ·····, ······ ··· ··· ·········· ········· ··· ·····
	············ ············· ··· ········ ··· ····· ···· ···· ······
	················ ············· ················. ····· ··· ····· ·····
	······ ············ ··········· ····· ····· ·· ··· ······ ······ ·· ···
	················· ·······, ··· ······ ········, ··· ··· ··· ········ ······
	····· ······ ·· ··· ·····, ······· ·· ·········· ··· ··········· ·········
	······. ·· ···· ·· ··· ···, ··· ··· ······ ···· ···· ······ ···· ·······
	·····, ·· ··· ············· ····· ··· ········· ··············. ········
	····· ····, ··· ···· ····· ··· ····· ····· ······ ······ ··· ··········
	··········· ···. ···· ······· ···· ··· ······················,
	··················· ········ ·········· ·· ·····, ··· ·· ······ ····
	········ ··· ·············· ···. ··· ············ ··· ··· ···········
	··········· ··· ····· ········· ········· ········· ·········· ··· ······
	···· ··· ·········· ··········· ···········, ··· ···· ······ ·····
	············· ····, ······· ··· ·· ····· ········ ········· ···········
	······ ····· ······ ····· ······ ········ ···&hellip;
</p>

EOT

php -S 'localhost:7654' 'system/router.php' &
SERVER_PID=$!
sleep 1

TESTCASE_LOG="testcase.log.html"
curl -s 'http://localhost:7654/' > "$TESTCASE_LOG"
kill -TERM "$SERVER_PID"

if grep -q '<figure class="image-caption">' "$TESTCASE_LOG"; then
	echo "SUCCESS: all ok"
else
	echo "FAIL: GravCMS processing error"
fi

echo "TESTCASE_LOG: testcase/$TESTCASE_LOG"

I tried for some hours to debug this issue, but to no avail. In my original case, the text has been in Markdown, but Markdown processing is of no significance. I replaced the actual text with ·.

Thanks and greetings
and a blessed new year!

[NoNoNo]

My AI assistant Grok Code Fast 1 (in OpenCode) came up with this:

Root Cause Found

The issue was in the Twig3CompatibilityTransformer class in system/src/Grav/Common/Twig/Compatibility/Twig3CompatibilityTransformer.php. Several methods use preg_replace_callback() with complex regex patterns to transform legacy Twig 1/2 syntax for Twig 3 compatibility. When processing content containing many Unicode middle-dot characters (· U+00B7) ^[Note: the original case is normal written prose], these regex operations were failing due to pattern complexity with Unicode content, causing preg_replace_callback() to return NULL instead of the modified string. The code was casting NULL to string, resulting in empty content.

Affected Methods

• rewriteSameAsTests()
• rewriteDivisibleByTests()
• rewriteNoneTests()
• rewriteReplaceFilterSignatures()
• rewriteRawBlocks()

Proposed Fix

Added proper error handling to all affected methods:

try {
    $result = preg_replace_callback($pattern, $callback, $code);
    if ($result === null) {
        return $code; // Return original content on regex failure
    }
    return (string) $result;
} catch (\Exception $e) {
    return $code; // Return original content on exception
}

Workaround for me is to set in user/config/system.yaml:

strict_mode:
  twig3_compat: false

[NoNoNo]

The error is: JIT stack limit exhausted in line 143:

grav/system/src/Grav/Common/Twig/Compatibility/Twig3CompatibilityTransformer.php

Lines 139 to 152 in 07de0cb

	private function rewriteSameAsTests(string $code): string
	{
	$pattern = '/([\'"])(?:\\\\.|(?!\\1).)*\\1|\\bis\\s+(?:not\\s+)?sameas\\b/is';
	return (string) preg_replace_callback($pattern, static function ($matches) {
	// If group 1 is not set, it means 'is sameas' was matched.
	if (!isset($matches[1])) {
	return str_ireplace('sameas', 'same as', $matches[0]);
	}
	// Otherwise, it's a quoted string, so return it as is.
	return $matches[0];
	}, $code);
	}

preg_replace_callback returns null on errors. To catch these errors:

if (preg_last_error() !== PREG_NO_ERROR) {
    throw new \RuntimeException(preg_last_error_msg());
}

https://packagist.org/packages/thecodingmachine/safe is a way to raise these kind of errors to exceptions.

[NoNoNo]

First a comment by openai:gpt-5-chat, second a comment by claude:claude-sonnet-4-5. Code is untested.

---

openai:gpt-5-chat

Instead of trying to combine string handling and keyword replacement in one expression, split the logic — it’s simpler, faster, and avoids excessive backtracking.

private function rewriteSameAsTests(string $code): string
{
    $tokens = preg_split('/(\'(?:\\\\.|[^\'\\\\])*\'|"(?:\\\\.|[^"\\\\])*")/s', $code, -1, PREG_SPLIT_DELIM_CAPTURE);
    foreach ($tokens as &$token) {
        // Only rewrite outside quoted strings
        if ($token === '' || $token[0] === '"' || $token[0] === "'") {
            continue;
        }
        $token = preg_replace('/\bis\s+(?:not\s+)?sameas\b/i', function ($m) {
            return str_ireplace('sameas', 'same as', $m[0]);
        }, $token);
    }
    return implode('', $tokens);
}

This approach:

• Splits the string into quoted and unquoted parts.
• Only rewrites unquoted regions.
• Avoids backtracking issues completely.

---

claude:claude-sonnet-4-5

The issue is with the regex pattern's string matching part. The pattern ([\'"])(?:\\\\.|(?!\\1).)*\\1 can cause catastrophic backtracking when dealing with long strings or unclosed quotes.

Here's a more efficient version that avoids the JIT stack exhaustion:

private function rewriteSameAsTests(string $code): string
{
    // More efficient pattern that avoids catastrophic backtracking
    $pattern = '/([\'"])(?:[^\\\\\1]|\\\\.)*\1|\\bis\\s+(?:not\\s+)?sameas\\b/is';

    return (string) preg_replace_callback($pattern, static function ($matches) {
        // If group 1 is not set, it means 'is sameas' was matched.
        if (!isset($matches[1])) {
            return str_ireplace('sameas', 'same as', $matches[0]);
        }

        // Otherwise, it's a quoted string, so return it as is.
        return $matches[0];
    }, $code);
}

Key change:

• Old: (?:\\\\.|(?!\\1).)* - Uses negative lookahead with backtracking
• New: (?:[^\\\\\1]|\\\\.)* - Uses character class negation (more efficient)

The new pattern [^\\\\\1] matches any character except backslash or the opening quote, and \\\\. matches escaped characters. This is much more efficient than the negative lookahead approach.

Alternative with even better performance for very long strings:

private function rewriteSameAsTests(string $code): string
{
    // Split approach - handles quotes separately to avoid complex regex
    $result = '';
    $offset = 0;

    // Find all quoted strings first
    preg_match_all('/([\'"])(?:[^\\\\\1]|\\\\.)*\1/s', $code, $quotes, PREG_OFFSET_CAPTURE);

    foreach ($quotes[0] as $quote) {
        [$match, $pos] = $quote;

        // Process text before this quote
        $before = substr($code, $offset, $pos - $offset);
        $result .= preg_replace('/\\bis\\s+(?:not\\s+)?sameas\\b/i',
                                fn($m) => str_ireplace('sameas', 'same as', $m[0]),
                                $before);

        // Add the quoted string unchanged
        $result .= $match;
        $offset = $pos + strlen($match);
    }

    // Process remaining text
    $result .= preg_replace('/\\bis\\s+(?:not\\s+)?sameas\\b/i',
                            fn($m) => str_ireplace('sameas', 'same as', $m[0]),
                            substr($code, $offset));

    return $result;
}

The first solution should be sufficient, but use the second if you're dealing with very large code strings.

[rhukster]

i'll have my AI review your AI, and see what it comes up with :)

[rhukster]

Hey @NoNoNo, thanks for the detailed bug report and test case - that made reproducing this much easier!

I had Claude Opus 4.5 review all the AI-suggested solutions and done some testing. Here's what it found:

What's Causing the Problem

The original regex pattern uses a negative lookahead with a backreference to match quoted strings:

([\'"])(?:\\.|(?!\1).)*\1

This essentially tells the regex engine to check "is this character NOT the opening quote?" at every single position. When processing content with lots of Unicode characters (like your middle-dots), the engine gets overwhelmed trying all possible backtracking paths, eventually exhausting the JIT stack.

Why the Other AI Solutions Don't Quite Work

• Grok's error handling approach - This catches the error but doesn't fix it. Your page would still be blank, it just wouldn't crash.

• GPT-5's split approach - Good idea, but the code example has a syntax bug (preg_replace doesn't take a callback that way).

• Claude Sonnet's character class fix - Uses [^\\\\\1] assuming \1 works as a backreference inside a character class. Unfortunately it doesn't - inside [] it just matches the literal character "1", which would break quote matching entirely.

The Fix

I went with possessive quantifiers (*+), which tell the regex engine "once you've matched these characters, don't ever backtrack":

'[^'\\]*+(?:\\.[^'\\]*+)*+'|"[^"\\]*+(?:\\.[^"\\]*+)*+"|(keyword)

This handles single and double quotes separately (no tricky backreferences needed) and guarantees the pattern runs in linear time regardless of input content.

I've also added a fallback so if the regex does fail for any reason, it returns the original content instead of an empty string.

Testing

Tested with your exact test case content on PHP 8.5.2:

• Original pattern: ❌ JIT stack limit exhausted
• Fixed pattern: ✓ 0.25ms

PR is up at #4027 if you'd like to test it with your full setup before we merge!