diff --git a/README.md b/README.md
index c3b2744..99f37af 100644
--- a/README.md
+++ b/README.md
@@ -18,6 +18,7 @@ Liquid is a template engine with interesting advantages:
 
 |  PHP Liquid | Shopify Liquid |
 |------------:|---------------:|
+|       v0.11 |          v5.13 |
 |       v0.10 |          v5.12 |
 |        v0.9 |           v5.8 |
 |        v0.8 |           v5.7 |
diff --git a/src/Drops/SelfDrop.php b/src/Drops/SelfDrop.php
new file mode 100644
index 0000000..52d938c
--- /dev/null
+++ b/src/Drops/SelfDrop.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace Keepsuit\Liquid\Drops;
+
+use Keepsuit\Liquid\Render\RenderContext;
+
+/**
+ * Proxy object that resolves property lookups through the current render context scope chain.
+ * Intentionally does not implement IsContextAware: a SelfDrop passed across a render boundary
+ * must keep its original context rather than being rebound to the partial's context.
+ */
+final class SelfDrop
+{
+    public function __construct(
+        private readonly RenderContext $context
+    ) {}
+
+    public function __get(string $name): mixed
+    {
+        $variables = $this->context->findVariables($name);
+
+        return $variables[0] ?? null;
+    }
+
+    public function __isset(string $name): bool
+    {
+        $variables = $this->context->findVariables($name);
+
+        return $variables !== [];
+    }
+
+    public function __toString(): string
+    {
+        return '';
+    }
+}
diff --git a/src/Exceptions/SyntaxException.php b/src/Exceptions/SyntaxException.php
index 5cdc7dc..cfa1d28 100644
--- a/src/Exceptions/SyntaxException.php
+++ b/src/Exceptions/SyntaxException.php
@@ -79,6 +79,14 @@ public static function unexpectedToken(Token $token): SyntaxException
         ));
     }
 
+    public static function tagSyntaxException(string $tagName, string $validSyntax, SyntaxException $original): SyntaxException
+    {
+        $exception = new SyntaxException(sprintf('%s - Valid syntax: %s', $original->getMessage(), $validSyntax), previous: $original);
+        $exception->tagName = $tagName;
+
+        return $exception;
+    }
+
     protected function messagePrefix(): string
     {
         return 'Liquid syntax error';
diff --git a/src/Parse/TokenStream.php b/src/Parse/TokenStream.php
index 936a7c3..be0702b 100644
--- a/src/Parse/TokenStream.php
+++ b/src/Parse/TokenStream.php
@@ -92,8 +92,6 @@ public function consumeOrFalse(TokenType $type): Token|false
 
     /**
      * @throws SyntaxException
-     *
-     * @phpstan-impure
      */
     public function id(string $identifier): Token
     {
@@ -143,6 +141,14 @@ public function expression(): mixed
         return $this->expressionParser->parseExpression();
     }
 
+    /**
+     * @throws SyntaxException
+     */
+    public function simpleVariableName(): string
+    {
+        return $this->consume(TokenType::Identifier)->data;
+    }
+
     /**
      * @return Argument
      *
diff --git a/src/Render/RenderContext.php b/src/Render/RenderContext.php
index 6aed4f0..77e3057 100644
--- a/src/Render/RenderContext.php
+++ b/src/Render/RenderContext.php
@@ -9,6 +9,7 @@
 use Keepsuit\Liquid\Contracts\LiquidErrorHandler;
 use Keepsuit\Liquid\Contracts\MapsToLiquid;
 use Keepsuit\Liquid\Drop;
+use Keepsuit\Liquid\Drops\SelfDrop;
 use Keepsuit\Liquid\Environment;
 use Keepsuit\Liquid\ErrorHandlers\RethrowErrorHandler;
 use Keepsuit\Liquid\Exceptions\ArithmeticException;
@@ -59,6 +60,8 @@ final class RenderContext
      */
     protected array $interrupts = [];
 
+    private ?SelfDrop $selfDrop = null;
+
     public function __construct(
         /**
          * Environment variables only available in the current context
@@ -183,6 +186,13 @@ public function findVariables(string $key): array
 
         $variables = array_values(array_filter($variables, fn (mixed $value) => ! $value instanceof MissingValue));
 
+        // Inject the implicit self drop only when no value (including explicit null) was found.
+        // An explicit `self = nil` leaves [null] in $variables, so the fallback is skipped,
+        // correctly distinguishing defined-null from undefined.
+        if ($variables === [] && $key === 'self') {
+            return [$this->getSelfDrop()];
+        }
+
         foreach ($variables as $variable) {
             if ($variable instanceof IsContextAware) {
                 $variable->setContext($this);
@@ -192,6 +202,11 @@ public function findVariables(string $key): array
         return $variables;
     }
 
+    public function getSelfDrop(): SelfDrop
+    {
+        return $this->selfDrop ??= new SelfDrop($this);
+    }
+
     public function internalContextLookup(mixed $scope, int|string $key): mixed
     {
         try {
diff --git a/src/Tags/AssignTag.php b/src/Tags/AssignTag.php
index 62a2e75..647e6cc 100644
--- a/src/Tags/AssignTag.php
+++ b/src/Tags/AssignTag.php
@@ -5,7 +5,6 @@
 use Keepsuit\Liquid\Contracts\HasParseTreeVisitorChildren;
 use Keepsuit\Liquid\Exceptions\SyntaxException;
 use Keepsuit\Liquid\Nodes\Variable;
-use Keepsuit\Liquid\Nodes\VariableLookup;
 use Keepsuit\Liquid\Parse\ExpressionParser;
 use Keepsuit\Liquid\Parse\TagParseContext;
 use Keepsuit\Liquid\Parse\TokenType;
@@ -18,8 +17,6 @@
  */
 class AssignTag extends Tag implements HasParseTreeVisitorChildren
 {
-    protected const SYNTAX_ERROR = "Syntax Error in 'assign' - Valid syntax: assign [var] = [source]";
-
     protected string $to;
 
     protected Variable $from;
@@ -32,11 +29,7 @@ public static function tagName(): string
     public function parse(TagParseContext $context): static
     {
         try {
-            $to = $context->params->expression();
-            $this->to = match (true) {
-                $to instanceof VariableLookup, is_string($to) => (string) $to,
-                default => throw new SyntaxException(self::SYNTAX_ERROR),
-            };
+            $this->to = $context->params->simpleVariableName();
 
             $context->params->consume(TokenType::Equals);
 
@@ -44,7 +37,7 @@ public function parse(TagParseContext $context): static
 
             $context->params->assertEnd();
         } catch (SyntaxException $e) {
-            throw new SyntaxException(self::SYNTAX_ERROR);
+            throw SyntaxException::tagSyntaxException('assign', 'assign <var> = <source>', $e);
         }
 
         return $this;
diff --git a/src/Tags/BreakTag.php b/src/Tags/BreakTag.php
index 41afd3d..09a57e6 100644
--- a/src/Tags/BreakTag.php
+++ b/src/Tags/BreakTag.php
@@ -2,6 +2,7 @@
 
 namespace Keepsuit\Liquid\Tags;
 
+use Keepsuit\Liquid\Exceptions\SyntaxException;
 use Keepsuit\Liquid\Interrupts\BreakInterrupt;
 use Keepsuit\Liquid\Parse\TagParseContext;
 use Keepsuit\Liquid\Render\RenderContext;
@@ -16,7 +17,11 @@ public static function tagName(): string
 
     public function parse(TagParseContext $context): static
     {
-        $context->params->assertEnd();
+        try {
+            $context->params->assertEnd();
+        } catch (SyntaxException $e) {
+            throw SyntaxException::tagSyntaxException(static::tagName(), 'break', $e);
+        }
 
         return $this;
     }
diff --git a/src/Tags/CaptureTag.php b/src/Tags/CaptureTag.php
index 393214b..1e5fa30 100644
--- a/src/Tags/CaptureTag.php
+++ b/src/Tags/CaptureTag.php
@@ -4,15 +4,12 @@
 
 use Keepsuit\Liquid\Exceptions\SyntaxException;
 use Keepsuit\Liquid\Nodes\BodyNode;
-use Keepsuit\Liquid\Nodes\VariableLookup;
 use Keepsuit\Liquid\Parse\TagParseContext;
 use Keepsuit\Liquid\Render\RenderContext;
 use Keepsuit\Liquid\TagBlock;
 
 class CaptureTag extends TagBlock
 {
-    protected const SYNTAX_ERROR = "Syntax Error in 'capture' - Valid syntax: capture [var]";
-
     protected string $to;
 
     protected BodyNode $body;
@@ -23,13 +20,13 @@ public function parse(TagParseContext $context): static
 
         $this->body = $context->body;
 
-        $to = $context->params->expression();
-        $this->to = match (true) {
-            is_string($to), $to instanceof VariableLookup => (string) $to,
-            default => throw new SyntaxException(self::SYNTAX_ERROR),
-        };
+        try {
+            $this->to = $context->params->simpleVariableName();
 
-        $context->params->assertEnd();
+            $context->params->assertEnd();
+        } catch (SyntaxException $e) {
+            throw SyntaxException::tagSyntaxException('capture', 'capture <var>', $e);
+        }
 
         return $this;
     }
diff --git a/src/Tags/CaseTag.php b/src/Tags/CaseTag.php
index 66381f3..c9fde1e 100644
--- a/src/Tags/CaseTag.php
+++ b/src/Tags/CaseTag.php
@@ -32,11 +32,20 @@ public static function tagName(): string
 
     public function parse(TagParseContext $context): static
     {
-        if ($context->tag === 'case') {
-            $this->left = $context->params->expression();
-            $context->params->assertEnd();
-        } else {
-            $this->conditions[] = $this->mapBodySectionToCondition($context);
+        try {
+            if ($context->tag === 'case') {
+                $this->left = $context->params->expression();
+                $context->params->assertEnd();
+            } else {
+                $this->conditions[] = $this->mapBodySectionToCondition($context);
+            }
+        } catch (SyntaxException $e) {
+            throw SyntaxException::tagSyntaxException(static::tagName(), match ($context->tag) {
+                'case' => 'case <expression>',
+                'when' => 'when <expression> [, <expression>...]',
+                'else' => 'else',
+                default => ''
+            }, $e);
         }
 
         return $this;
diff --git a/src/Tags/ContinueTag.php b/src/Tags/ContinueTag.php
index 957084d..fd6cd1b 100644
--- a/src/Tags/ContinueTag.php
+++ b/src/Tags/ContinueTag.php
@@ -2,6 +2,7 @@
 
 namespace Keepsuit\Liquid\Tags;
 
+use Keepsuit\Liquid\Exceptions\SyntaxException;
 use Keepsuit\Liquid\Interrupts\ContinueInterrupt;
 use Keepsuit\Liquid\Parse\TagParseContext;
 use Keepsuit\Liquid\Render\RenderContext;
@@ -16,7 +17,11 @@ public static function tagName(): string
 
     public function parse(TagParseContext $context): static
     {
-        $context->params->assertEnd();
+        try {
+            $context->params->assertEnd();
+        } catch (SyntaxException $e) {
+            throw SyntaxException::tagSyntaxException(static::tagName(), 'continue', $e);
+        }
 
         return $this;
     }
diff --git a/src/Tags/CycleTag.php b/src/Tags/CycleTag.php
index de809e5..a6226de 100644
--- a/src/Tags/CycleTag.php
+++ b/src/Tags/CycleTag.php
@@ -12,8 +12,6 @@
 
 class CycleTag extends Tag implements HasParseTreeVisitorChildren
 {
-    protected const SYNTAX_ERROR = "Syntax Error in 'cycle' - Valid syntax: cycle [name :] var [, var2, var3 ...]";
-
     /**
      * @var (string|int|float)[]
      */
@@ -28,40 +26,49 @@ public static function tagName(): string
 
     public function parse(TagParseContext $context): static
     {
-        $this->name = null;
-        $this->variables = [];
+        try {
+            $this->name = null;
+            $this->variables = [];
+
+            if ($context->params->look(TokenType::Colon, 1)) {
+                $currentToken = $context->params->current();
 
-        if ($context->params->look(TokenType::Colon, 1)) {
-            if (! in_array($context->params->current()?->type, [TokenType::String, TokenType::Number, TokenType::Identifier])) {
-                throw new SyntaxException(self::SYNTAX_ERROR);
+                $name = $context->params->expression();
+                $this->name = match (true) {
+                    is_string($name), is_numeric($name), $name instanceof VariableLookup => (string) $name,
+                    $currentToken === null => throw SyntaxException::unexpectedEndOfTemplate(),
+                    default => throw SyntaxException::unexpectedToken($currentToken),
+                };
+
+                $context->params->consume(TokenType::Colon);
             }
 
-            $name = $context->params->expression();
-            $this->name = match (true) {
-                is_string($name), is_numeric($name), $name instanceof VariableLookup => (string) $name,
-                default => throw new SyntaxException(self::SYNTAX_ERROR),
-            };
+            do {
+                $currentToken = $context->params->current();
 
-            $context->params->consume(TokenType::Colon);
-        }
+                if (! $currentToken) {
+                    throw SyntaxException::unexpectedEndOfTemplate();
+                }
 
-        do {
-            if (! in_array($context->params->current()?->type, [TokenType::String, TokenType::Number])) {
-                throw new SyntaxException(self::SYNTAX_ERROR);
-            }
+                if (! in_array($currentToken->type, [TokenType::String, TokenType::Number])) {
+                    throw SyntaxException::unexpectedToken($currentToken);
+                }
 
-            $variable = $context->params->expression();
-            $this->variables[] = match (true) {
-                is_string($variable), is_numeric($variable) => $variable,
-                default => throw new SyntaxException(self::SYNTAX_ERROR),
-            };
-        } while ($context->params->consumeOrFalse(TokenType::Comma));
+                $variable = $context->params->expression();
+                $this->variables[] = match (true) {
+                    is_string($variable), is_numeric($variable) => $variable,
+                    default => throw SyntaxException::unexpectedToken($currentToken)
+                };
+            } while ($context->params->consumeOrFalse(TokenType::Comma));
 
-        if ($this->name === null) {
-            $this->name = json_encode($this->variables, JSON_THROW_ON_ERROR);
-        }
+            if ($this->name === null) {
+                $this->name = json_encode($this->variables, JSON_THROW_ON_ERROR);
+            }
 
-        $context->params->assertEnd();
+            $context->params->assertEnd();
+        } catch (SyntaxException $e) {
+            throw SyntaxException::tagSyntaxException(static::tagName(), 'cycle [<name>:] <value>[, <value>...]', $e);
+        }
 
         return $this;
     }
diff --git a/src/Tags/DocTag.php b/src/Tags/DocTag.php
index 817dcd9..c6d8297 100644
--- a/src/Tags/DocTag.php
+++ b/src/Tags/DocTag.php
@@ -25,17 +25,21 @@ public static function hasRawBody(): bool
 
     public function parse(TagParseContext $context): static
     {
-        $context->params->assertEnd();
+        try {
+            $context->params->assertEnd();
 
-        assert($context->body instanceof BodyNode);
+            assert($context->body instanceof BodyNode);
 
-        $body = $context->body->children()[0] ?? null;
-        $this->body = match (true) {
-            $body instanceof Raw => $body,
-            default => throw new SyntaxException('doc tag must have a single raw body'),
-        };
+            $body = $context->body->children()[0] ?? null;
+            $this->body = match (true) {
+                $body instanceof Raw => $body,
+                default => throw new SyntaxException('must have a single raw body'),
+            };
 
-        $this->ensureNoNestedDocTags();
+            $this->ensureNoNestedDocTags();
+        } catch (SyntaxException $e) {
+            throw SyntaxException::tagSyntaxException(static::tagName(), 'doc', $e);
+        }
 
         return $this;
     }
diff --git a/src/Tags/EchoTag.php b/src/Tags/EchoTag.php
index 1d510f4..2944ced 100644
--- a/src/Tags/EchoTag.php
+++ b/src/Tags/EchoTag.php
@@ -3,6 +3,7 @@
 namespace Keepsuit\Liquid\Tags;
 
 use Keepsuit\Liquid\Contracts\HasParseTreeVisitorChildren;
+use Keepsuit\Liquid\Exceptions\SyntaxException;
 use Keepsuit\Liquid\Nodes\Variable;
 use Keepsuit\Liquid\Parse\TagParseContext;
 use Keepsuit\Liquid\Render\RenderContext;
@@ -14,9 +15,13 @@ class EchoTag extends Tag implements HasParseTreeVisitorChildren
 
     public function parse(TagParseContext $context): static
     {
-        $this->variable = $context->params->variable();
+        try {
+            $this->variable = $context->params->variable();
 
-        $context->params->assertEnd();
+            $context->params->assertEnd();
+        } catch (SyntaxException $e) {
+            throw SyntaxException::tagSyntaxException(static::tagName(), 'echo <expression>', $e);
+        }
 
         return $this;
     }
diff --git a/src/Tags/ForTag.php b/src/Tags/ForTag.php
index a1ed39b..855ca96 100644
--- a/src/Tags/ForTag.php
+++ b/src/Tags/ForTag.php
@@ -54,11 +54,19 @@ public static function tagName(): string
 
     public function parse(TagParseContext $context): static
     {
-        match ($context->tag) {
-            'for' => $this->parseForBlock($context),
-            'else' => $this->parseElseBlock($context),
-            default => throw new SyntaxException('Invalid tag'),
-        };
+        try {
+            match ($context->tag) {
+                'for' => $this->parseForBlock($context),
+                'else' => $this->parseElseBlock($context),
+                default => throw new SyntaxException('Invalid tag'),
+            };
+        } catch (SyntaxException $e) {
+            throw SyntaxException::tagSyntaxException(static::tagName(), match ($context->tag) {
+                'for' => 'for <var> in <collection> [attributes...]',
+                'else' => 'else',
+                default => ''
+            }, $e);
+        }
 
         return $this;
     }
diff --git a/src/Tags/IfChanged.php b/src/Tags/IfChanged.php
index 388a152..c90dbcd 100644
--- a/src/Tags/IfChanged.php
+++ b/src/Tags/IfChanged.php
@@ -2,6 +2,7 @@
 
 namespace Keepsuit\Liquid\Tags;
 
+use Keepsuit\Liquid\Exceptions\SyntaxException;
 use Keepsuit\Liquid\Nodes\BodyNode;
 use Keepsuit\Liquid\Parse\TagParseContext;
 use Keepsuit\Liquid\Render\RenderContext;
@@ -22,7 +23,11 @@ public function parse(TagParseContext $context): static
 
         $this->body = $context->body;
 
-        $context->params->assertEnd();
+        try {
+            $context->params->assertEnd();
+        } catch (SyntaxException $e) {
+            throw SyntaxException::tagSyntaxException(static::tagName(), 'ifchanged', $e);
+        }
 
         return $this;
     }
diff --git a/src/Tags/IfTag.php b/src/Tags/IfTag.php
index c01245b..644ed79 100644
--- a/src/Tags/IfTag.php
+++ b/src/Tags/IfTag.php
@@ -4,6 +4,7 @@
 
 use Keepsuit\Liquid\Condition\Condition;
 use Keepsuit\Liquid\Condition\ElseCondition;
+use Keepsuit\Liquid\Exceptions\SyntaxException;
 use Keepsuit\Liquid\Parse\TagParseContext;
 use Keepsuit\Liquid\Parse\TokenType;
 use Keepsuit\Liquid\Render\RenderContext;
@@ -22,7 +23,16 @@ public static function tagName(): string
 
     public function parse(TagParseContext $context): static
     {
-        $this->conditions[] = $this->mapBodySectionToCondition($context);
+        try {
+            $this->conditions[] = $this->mapBodySectionToCondition($context);
+        } catch (SyntaxException $e) {
+            throw SyntaxException::tagSyntaxException(static::tagName(), match ($context->tag) {
+                'if' => 'if <condition>',
+                'elsif' => 'elsif <condition>',
+                'else' => 'else',
+                default => ''
+            }, $e);
+        }
 
         return $this;
     }
@@ -46,6 +56,9 @@ public function parseTreeVisitorChildren(): array
         return $this->conditions;
     }
 
+    /**
+     * @throws SyntaxException
+     */
     protected function mapBodySectionToCondition(TagParseContext $bodySection): Condition
     {
         $condition = match ($bodySection->tag) {
@@ -85,11 +98,17 @@ public function isSubTag(string $tagName): bool
         return in_array($tagName, ['else', 'elsif'], true);
     }
 
+    /**
+     * @throws SyntaxException
+     */
     protected function parseCondition(TagParseContext $bodySection): Condition
     {
         return $this->parseBinaryComparison($bodySection);
     }
 
+    /**
+     * @throws SyntaxException
+     */
     protected function parseBinaryComparison(TagParseContext $bodySection): Condition
     {
         $condition = $this->parseComparison($bodySection);
@@ -104,6 +123,9 @@ protected function parseBinaryComparison(TagParseContext $bodySection): Conditio
         return $firstCondition;
     }
 
+    /**
+     * @throws SyntaxException
+     */
     protected function parseComparison(TagParseContext $bodySection): Condition
     {
         $a = $bodySection->params->expression();
diff --git a/src/Tags/IncrementTag.php b/src/Tags/IncrementTag.php
index 34ce7af..a70dd30 100644
--- a/src/Tags/IncrementTag.php
+++ b/src/Tags/IncrementTag.php
@@ -3,7 +3,6 @@
 namespace Keepsuit\Liquid\Tags;
 
 use Keepsuit\Liquid\Exceptions\SyntaxException;
-use Keepsuit\Liquid\Nodes\VariableLookup;
 use Keepsuit\Liquid\Parse\TagParseContext;
 use Keepsuit\Liquid\Render\RenderContext;
 use Keepsuit\Liquid\Tag;
@@ -19,13 +18,13 @@ public static function tagName(): string
 
     public function parse(TagParseContext $context): static
     {
-        $variableName = $context->params->expression();
-        $this->variableName = match (true) {
-            $variableName instanceof VariableLookup || is_string($variableName) => (string) $variableName,
-            default => throw new SyntaxException('Invalid variable name'),
-        };
+        try {
+            $this->variableName = $context->params->simpleVariableName();
 
-        $context->params->assertEnd();
+            $context->params->assertEnd();
+        } catch (SyntaxException $e) {
+            throw SyntaxException::tagSyntaxException(static::tagName(), sprintf('%s <var>', static::tagName()), $e);
+        }
 
         return $this;
     }
diff --git a/src/Tags/RawTag.php b/src/Tags/RawTag.php
index d3eabe2..53ec180 100644
--- a/src/Tags/RawTag.php
+++ b/src/Tags/RawTag.php
@@ -25,15 +25,19 @@ public static function hasRawBody(): bool
 
     public function parse(TagParseContext $context): static
     {
-        $context->params->assertEnd();
-
-        assert($context->body instanceof BodyNode);
-
-        $body = $context->body->children()[0] ?? null;
-        $this->body = match (true) {
-            $body instanceof Raw => $body,
-            default => throw new SyntaxException('raw tag must have a single raw body'),
-        };
+        try {
+            $context->params->assertEnd();
+
+            assert($context->body instanceof BodyNode);
+
+            $body = $context->body->children()[0] ?? null;
+            $this->body = match (true) {
+                $body instanceof Raw => $body,
+                default => throw new SyntaxException('must have a single raw body'),
+            };
+        } catch (SyntaxException $e) {
+            throw SyntaxException::tagSyntaxException(static::tagName(), 'raw', $e);
+        }
 
         return $this;
     }
diff --git a/src/Tags/RenderTag.php b/src/Tags/RenderTag.php
index c9a5318..8f66954 100644
--- a/src/Tags/RenderTag.php
+++ b/src/Tags/RenderTag.php
@@ -41,59 +41,63 @@ public static function tagName(): string
 
     public function parse(TagParseContext $context): static
     {
-        $this->isForLoop = false;
-        $this->variableNameExpression = null;
-        $this->attributes = [];
-
-        $context->getParseContext()->nested(function () use ($context) {
-            $templateNameExpression = $context->params->expression();
-            $this->templateNameExpression = match (true) {
-                is_string($templateNameExpression) => $templateNameExpression,
-                $this->allowDynamicPartials() && $templateNameExpression instanceof VariableLookup => $templateNameExpression,
-                default => throw new SyntaxException('Template name must be a string'),
-            };
-
-            $context->params->consumeOrFalse(TokenType::Comma);
-
-            if ($context->params->idOrFalse('for')) {
-                $this->isForLoop = true;
-                $this->variableNameExpression = $context->params->expression();
-            } elseif ($context->params->idOrFalse('with')) {
-                $this->variableNameExpression = $context->params->expression();
-            }
+        try {
+            $this->isForLoop = false;
+            $this->variableNameExpression = null;
+            $this->attributes = [];
+
+            $context->getParseContext()->nested(function () use ($context) {
+                $templateNameExpression = $context->params->expression();
+                $this->templateNameExpression = match (true) {
+                    is_string($templateNameExpression) => $templateNameExpression,
+                    $this->allowDynamicPartials() && $templateNameExpression instanceof VariableLookup => $templateNameExpression,
+                    default => throw new SyntaxException('Template name must be a string'),
+                };
 
-            $context->params->consumeOrFalse(TokenType::Comma);
+                $context->params->consumeOrFalse(TokenType::Comma);
 
-            if ($context->params->idOrFalse('as')) {
-                $aliasName = $context->params->expression();
-                $this->aliasName = match (true) {
-                    is_string($aliasName), $aliasName instanceof VariableLookup => (string) $aliasName,
-                    default => throw new SyntaxException('Alias name must be a valid variable name'),
-                };
-            } else {
-                $this->aliasName = null;
-            }
+                if ($context->params->idOrFalse('for')) {
+                    $this->isForLoop = true;
+                    $this->variableNameExpression = $context->params->expression();
+                } elseif ($context->params->idOrFalse('with')) {
+                    $this->variableNameExpression = $context->params->expression();
+                }
 
-            while (! $context->params->isEnd()) {
                 $context->params->consumeOrFalse(TokenType::Comma);
 
-                $attributeName = $context->params->expression();
-                if (! (is_string($attributeName) || $attributeName instanceof VariableLookup)) {
-                    throw new SyntaxException('Attribute name must be a valid variable name');
+                if ($context->params->idOrFalse('as')) {
+                    $aliasName = $context->params->expression();
+                    $this->aliasName = match (true) {
+                        is_string($aliasName), $aliasName instanceof VariableLookup => (string) $aliasName,
+                        default => throw new SyntaxException('Alias name must be a valid variable name'),
+                    };
+                } else {
+                    $this->aliasName = null;
                 }
 
-                $context->params->consume(TokenType::Colon);
-                $attributeValue = $context->params->expression();
+                while (! $context->params->isEnd()) {
+                    $context->params->consumeOrFalse(TokenType::Comma);
 
-                $this->attributes[(string) $attributeName] = $attributeValue;
-            }
+                    $attributeName = $context->params->expression();
+                    if (! (is_string($attributeName) || $attributeName instanceof VariableLookup)) {
+                        throw new SyntaxException('Attribute name must be a valid variable name');
+                    }
 
-            $context->params->assertEnd();
+                    $context->params->consume(TokenType::Colon);
+                    $attributeValue = $context->params->expression();
 
-            if (is_string($this->templateNameExpression)) {
-                $context->getParseContext()->loadPartial($this->templateNameExpression);
-            }
-        });
+                    $this->attributes[(string) $attributeName] = $attributeValue;
+                }
+
+                $context->params->assertEnd();
+
+                if (is_string($this->templateNameExpression)) {
+                    $context->getParseContext()->loadPartial($this->templateNameExpression);
+                }
+            });
+        } catch (SyntaxException $e) {
+            throw SyntaxException::tagSyntaxException(static::tagName(), 'render <template> [with|for <expression>] [as <var>] [<attribute>: <value>...]', $e);
+        }
 
         return $this;
     }
diff --git a/src/Tags/TableRowTag.php b/src/Tags/TableRowTag.php
index 0bf49e5..f014a1b 100644
--- a/src/Tags/TableRowTag.php
+++ b/src/Tags/TableRowTag.php
@@ -4,6 +4,7 @@
 
 use Keepsuit\Liquid\Drops\TableRowLoopDrop;
 use Keepsuit\Liquid\Exceptions\InvalidArgumentException;
+use Keepsuit\Liquid\Exceptions\SyntaxException;
 use Keepsuit\Liquid\Interrupts\BreakInterrupt;
 use Keepsuit\Liquid\Nodes\BodyNode;
 use Keepsuit\Liquid\Nodes\Range;
@@ -31,29 +32,33 @@ public static function tagName(): string
 
     public function parse(TagParseContext $context): static
     {
-        assert($context->body !== null);
+        try {
+            assert($context->body !== null);
 
-        $this->body = $context->body;
+            $this->body = $context->body;
 
-        $this->variableName = $context->params->consume(TokenType::Identifier)->data;
-        $context->params->id('in');
-        $this->collectionName = $context->params->expression();
+            $this->variableName = $context->params->consume(TokenType::Identifier)->data;
+            $context->params->id('in');
+            $this->collectionName = $context->params->expression();
 
-        while (true) {
-            $context->params->consumeOrFalse(TokenType::Comma);
+            while (true) {
+                $context->params->consumeOrFalse(TokenType::Comma);
 
-            if ($context->params->isEnd()) {
-                break;
+                if ($context->params->isEnd()) {
+                    break;
+                }
+
+                $attribute = $context->params->consume(TokenType::Identifier)->data;
+                $context->params->consume(TokenType::Colon);
+                $value = $context->params->expression();
+                $this->attributes[$attribute] = $value;
             }
 
-            $attribute = $context->params->consume(TokenType::Identifier)->data;
-            $context->params->consume(TokenType::Colon);
-            $value = $context->params->expression();
-            $this->attributes[$attribute] = $value;
+            $context->params->assertEnd();
+        } catch (SyntaxException $e) {
+            throw SyntaxException::tagSyntaxException(static::tagName(), 'tablerow <var> in <collection> [attributes...]', $e);
         }
 
-        $context->params->assertEnd();
-
         return $this;
     }
 
diff --git a/tests/Integration/ExpressionTest.php b/tests/Integration/ExpressionTest.php
index cf7a1ba..a9725bb 100644
--- a/tests/Integration/ExpressionTest.php
+++ b/tests/Integration/ExpressionTest.php
@@ -39,6 +39,13 @@
     );
 });
 
+test('bare bracket is not a valid expression', function () {
+    assertMatchSyntaxError(
+        'Liquid syntax error (line 1): `[` is not a valid expression',
+        '{{ [foo] }}',
+    );
+});
+
 function assertExpressionResult(mixed $expected, string $markup, ...$assigns): void
 {
     $liquid = "{% if expect == $markup %}pass{% else %}got {{ $markup }}{% endif %}";
diff --git a/tests/Integration/ParsingQuirksTest.php b/tests/Integration/ParsingQuirksTest.php
index f6d9b81..da8764b 100644
--- a/tests/Integration/ParsingQuirksTest.php
+++ b/tests/Integration/ParsingQuirksTest.php
@@ -40,7 +40,7 @@
 
 test('meaningless parens error', function () {
     assertMatchSyntaxError(
-        'Liquid syntax error (line 1): Invalid range syntax, correct syntax is (start..end)',
+        'Liquid syntax error (line 1): Invalid range syntax, correct syntax is (start..end) - Valid syntax: if <condition>',
         "{% if a == 'foo' or (b == 'bar' and c == 'baz') or false %} YES {% endif %}"
     );
 });
@@ -51,7 +51,7 @@
         '{% if true && false %} YES {% endif %}'
     );
     assertMatchSyntaxError(
-        'Liquid syntax error (line 1): Unexpected token |: "|"',
+        'Liquid syntax error (line 1): Unexpected token |: "|" - Valid syntax: if <condition>',
         '{% if true || false %} YES {% endif %}'
     );
 });
diff --git a/tests/Integration/SelfDropTest.php b/tests/Integration/SelfDropTest.php
new file mode 100644
index 0000000..ef6fbff
--- /dev/null
+++ b/tests/Integration/SelfDropTest.php
@@ -0,0 +1,110 @@
+<?php
+
+use Keepsuit\Liquid\EnvironmentFactory;
+
+test('self bracket lookup resolves variable by name', function () {
+    assertTemplateResult('bar', '{{ self[key] }}', staticData: ['key' => 'foo', 'foo' => 'bar']);
+});
+
+test('self dot lookup accesses variable by property name', function () {
+    assertTemplateResult('bar', '{{ self.foo }}', staticData: ['foo' => 'bar']);
+});
+
+test('self lookup uses normal scope hierarchy', function () {
+    assertTemplateResult('local', '{% assign foo = "local" %}{{ self.foo }}');
+});
+
+test('explicit self variable shadows fallback self drop', function () {
+    assertTemplateResult('override', '{% assign self = "override" %}{{ self }}');
+    assertTemplateResult('', '{% assign self = "override" %}{{ self.foo }}');
+});
+
+test('self bracket lookup with variable key', function () {
+    assertTemplateResult('Alice', '{{ self[key] }}', staticData: ['key' => 'name', 'name' => 'Alice']);
+});
+
+test('self bracket lookup can be composed in nested expression', function () {
+    assertTemplateResult('found', '{{ a[self["b"]] }}', staticData: ['b' => 'x', 'x' => 'found', 'a' => ['found' => 'found', 'x' => 'found']]);
+});
+
+test('self assigned to variable reflects later assignments', function () {
+    assertTemplateResult('late', '{% assign s = self %}{% assign foo = "late" %}{{ s.foo }}');
+});
+
+test('self passed to partial keeps caller context', function () {
+    assertTemplateResult('caller_value', '{% render "partial", self: self %}', data: ['outer' => 'caller_value'], partials: [
+        'partial' => '{{ self.outer }}',
+    ]);
+});
+
+test('implicit self in partial is isolated to partial scope', function () {
+    assertTemplateResult('', '{% render "partial" %}', data: ['outer' => 'caller_value'], partials: [
+        'partial' => '{{ self.outer }}',
+    ]);
+});
+
+test('nested partials preserve each self context independently', function () {
+    // Middle's implicit self sees its own assign; inner gets middle's self and sees middle_var.
+    assertTemplateResult('middle_value', '{% render "middle" %}', partials: [
+        'middle' => '{% assign middle_var = "middle_value" %}{% render "inner", self: self %}',
+        'inner' => '{{ self.middle_var }}',
+    ]);
+
+    // Root passes its own self to middle; middle's explicit self can see root's local data.
+    assertTemplateResult('root_value', '{% render "middle", self: self %}', data: ['root_var' => 'root_value'], partials: [
+        'middle' => '{{ self.root_var }}',
+    ]);
+});
+
+test('repeated self lookups compare equal', function () {
+    assertTemplateResult('yes', '{% if self == self %}yes{% endif %}');
+});
+
+test('assigned self drop compares equal to itself', function () {
+    assertTemplateResult('T', '{% assign s = self %}{% if s == s %}T{% else %}F{% endif %}');
+});
+
+test('two variables from same self context compare equal', function () {
+    assertTemplateResult('yes', '{% assign a = self %}{% assign b = self %}{% if a == b %}yes{% endif %}');
+});
+
+test('self missing property renders blank under strict variables', function () {
+    $factory = new EnvironmentFactory;
+    $factory->setStrictVariables(true);
+    assertTemplateResult('', '{{ self.missing_key }}', factory: $factory);
+});
+
+test('self defined property resolves correctly under strict variables', function () {
+    $factory = new EnvironmentFactory;
+    $factory->setStrictVariables(true);
+    assertTemplateResult('42', '{{ self.x }}', staticData: ['x' => 42], factory: $factory);
+});
+
+test('self passed as render param preserves original scope when variable name collides', function () {
+    assertTemplateResult('42|43',
+        '{%- assign var = 42 -%}{%- assign s = self -%}{%- render "snippet", other_self: s -%}',
+        partials: [
+            'snippet' => '{%- assign var = 43 -%}{{- other_self.var }}|{{ self.var -}}',
+        ]
+    );
+});
+
+test('self passed to nested renders preserves each level independently', function () {
+    assertTemplateResult('1|2|3',
+        '{%- assign a = 1 -%}{%- assign s1 = self -%}{%- render "snippet1", outer: s1 -%}',
+        partials: [
+            'snippet1' => '{%- assign a = 2 -%}{%- assign s2 = self -%}{%- render "snippet2", outer: outer, middle: s2 -%}',
+            'snippet2' => '{%- assign a = 3 -%}{{- outer.a }}|{{ middle.a }}|{{ self.a -}}',
+        ]
+    );
+});
+
+test('explicit null self does not trigger self drop fallback', function () {
+    assertTemplateResult('', '{% assign self = nil %}{{ self }}');
+    // The assigned nil should be returned, not the SelfDrop
+    assertTemplateResult('yes', '{% assign self = nil %}{% if self == nil %}yes{% endif %}');
+});
+
+test('self dot self renders blank without infinite recursion', function () {
+    assertTemplateResult('', '{{ self.self }}');
+});
diff --git a/tests/Integration/Tags/AssignTagTest.php b/tests/Integration/Tags/AssignTagTest.php
index b321dee..c277b1f 100644
--- a/tests/Integration/Tags/AssignTagTest.php
+++ b/tests/Integration/Tags/AssignTagTest.php
@@ -40,10 +40,10 @@
 
 test('assign syntax error', function () {
     expect(fn () => renderTemplate('{% assign foo not values %}.'))
-        ->toThrow(SyntaxException::class, 'assign');
+        ->toThrow(SyntaxException::class);
 
     expect(fn () => renderTemplate("{% assign foo = ('X' | downcase) %}"))
-        ->toThrow(SyntaxException::class, 'assign');
+        ->toThrow(SyntaxException::class);
 });
 
 test('expression with whitespace in square brackets', function () {
@@ -84,6 +84,20 @@
     expect($context->resourceLimits->getAssignScore())->toBe(5);
 });
 
+test('assign strict parsing rejects dotted target', function () {
+    assertMatchSyntaxError(
+        'Liquid syntax error (line 1): Expected ==, got . - Valid syntax: assign <var> = <source>',
+        '{% assign foo.bar = "x" %}',
+    );
+});
+
+test('assign strict parsing rejects bracketed target', function () {
+    assertMatchSyntaxError(
+        'Liquid syntax error (line 1): Expected ==, got [ - Valid syntax: assign <var> = <source>',
+        '{% assign foo[bar] = "x" %}',
+    );
+});
+
 test('assign score of int', function () {
     expect(assignScoreOf(123))->toBe(1);
 });
diff --git a/tests/Integration/Tags/CaptureTagTest.php b/tests/Integration/Tags/CaptureTagTest.php
index a5afd46..89fd03b 100644
--- a/tests/Integration/Tags/CaptureTagTest.php
+++ b/tests/Integration/Tags/CaptureTagTest.php
@@ -3,7 +3,7 @@
 use Keepsuit\Liquid\Render\RenderContext;
 
 test('capture block content in variable', function () {
-    assertTemplateResult('test string', "{% capture 'var' %}test string{% endcapture %}{{var}}");
+    assertTemplateResult('test string', '{% capture var %}test string{% endcapture %}{{var}}');
 });
 
 test('capture with hyphen in variable name', function () {
@@ -44,6 +44,27 @@
     assertTemplateResult('3-3', $source);
 });
 
+test('capture strict parsing rejects dotted target', function () {
+    assertMatchSyntaxError(
+        'Liquid syntax error (line 1): Unexpected token .: "." - Valid syntax: capture <var>',
+        '{% capture foo.bar %}x{% endcapture %}',
+    );
+});
+
+test('capture strict parsing rejects bracketed target', function () {
+    assertMatchSyntaxError(
+        'Liquid syntax error (line 1): Unexpected token [: "[" - Valid syntax: capture <var>',
+        '{% capture foo[bar] %}x{% endcapture %}',
+    );
+});
+
+test('capture strict parsing rejects quoted string target', function () {
+    assertMatchSyntaxError(
+        'Liquid syntax error (line 1): Expected Identifier, got String - Valid syntax: capture <var>',
+        "{% capture 'foo' %}x{% endcapture %}",
+    );
+});
+
 test('increment assign score by bytes', function () {
     $context = new RenderContext;
     parseTemplate('{% capture foo %}すごい{% endcapture %}')->render($context);
diff --git a/tests/Integration/Tags/DocTagTest.php b/tests/Integration/Tags/DocTagTest.php
index 95dd6db..00ec5f9 100644
--- a/tests/Integration/Tags/DocTagTest.php
+++ b/tests/Integration/Tags/DocTagTest.php
@@ -21,7 +21,7 @@
     {% enddoc %}
     LIQUID;
 
-    assertMatchSyntaxError('Liquid syntax error (line 2): Unexpected token Identifier: "extra"', $template);
+    assertMatchSyntaxError('Liquid syntax error (line 2): Unexpected token Identifier: "extra" - Valid syntax: doc', $template);
 });
 
 test('doc tag must support valid tags', function () {
@@ -65,7 +65,7 @@
     {% enddoc %}
     LIQUID;
 
-    assertMatchSyntaxError('Liquid syntax error (line 4): Nested doc tags are not allowed', $template);
+    assertMatchSyntaxError('Liquid syntax error (line 4): Nested doc tags are not allowed - Valid syntax: doc', $template);
 });
 
 test('doc tag ignores nested raw tags', function () {
diff --git a/tests/Integration/Tags/IncrementTagTest.php b/tests/Integration/Tags/IncrementTagTest.php
index 8342764..7655579 100644
--- a/tests/Integration/Tags/IncrementTagTest.php
+++ b/tests/Integration/Tags/IncrementTagTest.php
@@ -32,3 +32,31 @@
         LIQUID
     );
 });
+
+test('increment strict parsing rejects dotted target', function () {
+    assertMatchSyntaxError(
+        'Liquid syntax error (line 1): Unexpected token .: "." - Valid syntax: increment <var>',
+        '{% increment foo.bar %}',
+    );
+});
+
+test('increment strict parsing rejects bracketed target', function () {
+    assertMatchSyntaxError(
+        'Liquid syntax error (line 1): Unexpected token [: "[" - Valid syntax: increment <var>',
+        '{% increment foo[bar] %}',
+    );
+});
+
+test('decrement strict parsing rejects dotted target', function () {
+    assertMatchSyntaxError(
+        'Liquid syntax error (line 1): Unexpected token .: "." - Valid syntax: decrement <var>',
+        '{% decrement foo.bar %}',
+    );
+});
+
+test('decrement strict parsing rejects bracketed target', function () {
+    assertMatchSyntaxError(
+        'Liquid syntax error (line 1): Unexpected token [: "[" - Valid syntax: decrement <var>',
+        '{% decrement foo[bar] %}',
+    );
+});
diff --git a/tests/Integration/Tags/StandardTagTest.php b/tests/Integration/Tags/StandardTagTest.php
index 22c1dad..cd98db4 100644
--- a/tests/Integration/Tags/StandardTagTest.php
+++ b/tests/Integration/Tags/StandardTagTest.php
@@ -75,7 +75,7 @@
 
 test('capture detects bad syntax', function () {
     assertMatchSyntaxError(
-        'Liquid syntax error (line 1): Syntax Error in \'capture\' - Valid syntax: capture [var]',
+        'Liquid syntax error (line 1): Unexpected end of template - Valid syntax: capture <var>',
         '{{ var2 }}{% capture %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
         staticData: ['var' => 'content']
     );
@@ -249,17 +249,17 @@
 
 test('case strict parsing rejects trailing tokens', function () {
     assertMatchSyntaxError(
-        'Liquid syntax error (line 1): Unexpected token Identifier: "extra"',
+        'Liquid syntax error (line 1): Unexpected token Identifier: "extra" - Valid syntax: case <expression>',
         '{% case condition extra %}{% when 1 %} hit {% endcase %}',
         staticData: ['condition' => 1],
     );
     assertMatchSyntaxError(
-        'Liquid syntax error (line 1): Unexpected token Identifier: "extra"',
+        'Liquid syntax error (line 1): Unexpected token Identifier: "extra" - Valid syntax: when <expression> [, <expression>...]',
         '{% case condition %}{% when 1 extra %} hit {% endcase %}',
         staticData: ['condition' => 1],
     );
     assertMatchSyntaxError(
-        'Liquid syntax error (line 1): Unexpected end of template',
+        'Liquid syntax error (line 1): Unexpected end of template - Valid syntax: when <expression> [, <expression>...]',
         '{% case condition %}{% when 1, %} hit {% endcase %}',
         staticData: ['condition' => 1],
     );
@@ -322,7 +322,7 @@
 
 test('cycle strict parsing rejects trailing tokens', function () {
     assertMatchSyntaxError(
-        'Liquid syntax error (line 1): Unexpected token Identifier: "extra"',
+        'Liquid syntax error (line 1): Unexpected token Identifier: "extra" - Valid syntax: cycle [<name>:] <value>[, <value>...]',
         '{% cycle "one", "two" extra %}',
     );
 });
diff --git a/tests/Integration/Tags/TableRowTest.php b/tests/Integration/Tags/TableRowTest.php
index d2dfdf0..e487818 100644
--- a/tests/Integration/Tags/TableRowTest.php
+++ b/tests/Integration/Tags/TableRowTest.php
@@ -289,12 +289,12 @@
 
 test('tablerow strict parsing rejects malformed params', function () {
     assertMatchSyntaxError(
-        'Liquid syntax error (line 1): Expected :, got Number',
+        'Liquid syntax error (line 1): Expected :, got Number - Valid syntax: tablerow <var> in <collection> [attributes...]',
         '{% tablerow n in numbers cols 3 %}{% endtablerow %}',
         ['numbers' => [1, 2, 3]],
     );
     assertMatchSyntaxError(
-        'Liquid syntax error (line 1): Unexpected end of template',
+        'Liquid syntax error (line 1): Unexpected end of template - Valid syntax: tablerow <var> in <collection> [attributes...]',
         '{% tablerow n in numbers cols: 3, limit %}{% endtablerow %}',
         ['numbers' => [1, 2, 3]],
     );