diff --git a/.changeset/standalone-section-tag.md b/.changeset/standalone-section-tag.md
new file mode 100644
index 000000000..586c06e8d
--- /dev/null
+++ b/.changeset/standalone-section-tag.md
@@ -0,0 +1,6 @@
+---
+'@shopify/liquid-html-parser': patch
+'@shopify/theme-check-common': patch
+---
+
+Parse `section` as a standalone tag. Removes the hybrid block form, whose forward scan for `{% endsection %}` made files with many `section` tags parse in quadratic time.
diff --git a/packages/liquid-html-parser/specs/architecture.md b/packages/liquid-html-parser/specs/architecture.md
index a56c2c9e7..bb45a8cb0 100644
--- a/packages/liquid-html-parser/specs/architecture.md
+++ b/packages/liquid-html-parser/specs/architecture.md
@@ -37,7 +37,6 @@ src/
     tokenizer.ts          # Source -> Token[] (modal: HTML tag context with =, ", ')
     html.ts               # HTML element, void, self-closing, raw node, comment, doctype, dangling marker parsing
     liquid-blocks.ts      # Block tag body parsing, branched block parsing, finalizeBranch
-    liquid-hybrid.ts      # Hybrid tag parsing (section standalone/block detection)
     liquid-lines.ts       # {% liquid %} line-based parsing, parseLiquidStatement
     liquid-raw.ts         # Raw tag body parsing, Liquid-in-range parsing
     liquid-tags.ts        # Tag dispatch: environment lookup, MarkupParser creation, tolerant fallback
@@ -110,7 +109,6 @@ document/parser.ts (DocumentParser)
     |   - node-dispatch.ts: token-type switch -> parse function routing
     |   - liquid-tags.ts: tag dispatch (environment lookup, MarkupParser creation)
     |   - liquid-blocks.ts: block body + branched block parsing
-    |   - liquid-hybrid.ts: hybrid tag (section) standalone/block detection
     |   - liquid-raw.ts: raw tag body extraction + Liquid-in-range parsing
     |   - liquid-variable-output.ts: {{ }} variable output
     |   - liquid-lines.ts: {% liquid %} line-based parsing
@@ -156,7 +154,6 @@ The parser calls these utilities while building the AST.
 | `document/tree-builder.ts`           | Utility functions for the parser: `filterChildren`, `ChildFilterMode`, `mergeAdjacentTextNodes`, `mergeAdjacentTextNodesTrimmed`, `mergeAdjacentTextNodesStripEdges`, `compoundNamesMatch`. Pure functions, zero parser state.                                                                                                                                                                                                                                                                                                                                                                                                                      | Tokenizing. Parsing. Dispatch.                                                                                                                                |
 | `document/html.ts`                   | HTML element parsing (open/close matching, unclosed element handling), void elements, self-closing elements, raw HTML nodes (`<script>`, `<style>`, `<svg>`), comments, doctype, dangling marker close. Attribute parsing. Defines `HtmlParserDelegate` interface.                                                                                                                                                                                                                                                                                                                                                                                  | Liquid tag parsing. Expression parsing.                                                                                                                       |
 | `document/liquid-blocks.ts`          | Block tag body parsing (`parseBlockBody`), branched block parsing (`parseBranchedBlockBody`), `finalizeBranch`, `peekTagName`, `isBlockTerminator`, `consumeEndTag`. Defines `BlockParserDelegate` interface.                                                                                                                                                                                                                                                                                                                                                                                                                                       | Tag dispatch. Expression parsing. HTML parsing.                                                                                                               |
-| `document/liquid-hybrid.ts`          | Hybrid tag detection: scans forward in token array for matching end tag. Defines `HybridParserDelegate` interface.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Tag dispatch. Expression parsing.                                                                                                                             |
 | `document/liquid-lines.ts`           | `{% liquid %}` line-based parsing: `parseLiquidStatement`, line splitting, block nesting within liquid tags. Defines `LineParserDelegate` interface.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Document tokenization. HTML parsing.                                                                                                                          |
 | `document/liquid-raw.ts`             | Raw tag body extraction (scan forward for end tag). `parseLiquidInRange` for tags that parse Liquid inside their body. Defines `RawParserDelegate` interface.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | Expression parsing. Tag dispatch.                                                                                                                             |
 | `document/liquid-tags.ts`            | Tag dispatch: environment lookup, `MarkupParser` creation from envelope, tolerant-mode try/catch fallback to base case. Defines `TagParserDelegate` interface.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Block body parsing. HTML parsing.                                                                                                                             |
@@ -495,7 +492,6 @@ enum TagKind {
   Block = "block",
   Tag = "tag",
   Raw = "raw",
-  Hybrid = "hybrid",
 }
 
 type BranchName = "elsif" | "else" | "when";
@@ -517,16 +513,10 @@ interface TagDefinitionRaw<M = unknown> {
   parse(name: string, markup: MarkupParser, parser: Parser): M;
 }
 
-interface TagDefinitionHybrid<M = unknown> {
-  kind: TagKind.Hybrid;
-  parse(name: string, markup: MarkupParser, parser: Parser): M;
-}
-
 type TagDefinition<M = unknown> =
   | TagDefinitionBlock<M>
   | TagDefinitionTag<M>
-  | TagDefinitionRaw<M>
-  | TagDefinitionHybrid<M>;
+  | TagDefinitionRaw<M>;
 ```
 
 Dispatch uses switch + `assertNever`:
@@ -536,7 +526,6 @@ switch (def.kind) {
   case TagKind.Block:       return parseBlockTag(...);
   case TagKind.Tag:         return parseTag(...);
   case TagKind.Raw:         return parseRawTag(...);
-  case TagKind.Hybrid:      return parseHybridTag(...);
   default:                  return assertNever(def);
 }
 ```
@@ -611,7 +600,7 @@ Defined in frozen `ast.ts`. Produced when a `</tagName>` close tag does not matc
 
 ### D1: TagDefinition as discriminated union on `kind`
 
-Tags define behavior via `kind: TagKind.Block | TagKind.Tag | TagKind.Raw | TagKind.Hybrid` with generic `Markup` parameter. Block tags declare `branches: BranchName[]`. The `kind` discriminant drives exhaustive dispatch (see Section 4, TagDefinition).
+Tags define behavior via `kind: TagKind.Block | TagKind.Tag | TagKind.Raw` with generic `Markup` parameter. Block tags declare `branches: BranchName[]`. The `kind` discriminant drives exhaustive dispatch (see Section 4, TagDefinition).
 
 ### D2: Internal BinaryExpression with adapter to frozen types
 
@@ -655,9 +644,9 @@ See Section 2 for domain table and import rules.
 
 Tokenizer produces flat `[LiquidTagOpen, Text, LiquidTagClose, ...]`. Parser matches pairs by consuming forward. Pairing is the parser's job.
 
-### D12: Section hybrid detection via lookahead
+### D12: `section` is a standalone tag
 
-When parser encounters `{% section %}`, it scans forward in the token array for `{% endsection %}`. The array is materialized, so scanning is a cheap index walk.
+`section` is a plain `TagKind.Tag`. Ruby Liquid has no block form, so `{% endsection %}` is a structural error (Theme Check reports it as `Unknown tag 'endsection'`). An earlier hybrid design scanned forward for `{% endsection %}` on every `section`, which made files with many sections parse in quadratic time.
 
 ### D13: HTML parsing in the document domain
 
@@ -768,13 +757,9 @@ liquid tag parse(name, markupParser, parser):
 
 **Inline comments:** Lines starting with `#` are intercepted before environment lookup — `#` is not a valid identifier start, so normal tag name extraction (`content.split(/\s/)[0]`) cannot handle it. The parser checks `content.startsWith('#')` and short-circuits to produce `LiquidTag { name: '#', markup: 'rest of line' }` directly.
 
-### 6.4 Section Hybrid Tag
-
-`section` is the only hybrid tag: standalone (`{% section 'name' %}`) or block (`{% section 'name' %}...{% endsection %}`).
+### 6.4 Section Tag
 
-**Detection:** When parser encounters `{% section %}`, it scans forward in the token array for `{% endsection %}`, respecting nesting. If found, parse as block. Otherwise, standalone.
-
-**Markup for both forms:** `SectionMarkup { name: LiquidString, args: LiquidNamedArgument[] }`. Same regardless of form. The difference is whether `children` is populated and `blockEndPosition` exists.
+`section` is standalone only (`{% section 'name' %}`), producing `SectionMarkup { name: LiquidString, args: LiquidNamedArgument[] }`. See D12.
 
 ### 6.5 Tolerant Mode vs Completion Mode
 
@@ -870,11 +855,6 @@ Parser sees LiquidTagOpen token
         |     If tagName == 'doc': pass body to liquid-doc/parser
         |     makeLiquidRawTag(envelope, body, endPos, endWs)
         |
-        +-- TagKind.Hybrid ->
-        |     Scan forward for matching {% endtagname %}
-        |     If found: parse as block
-        |     If not found: parse as standalone
-        |
         +-- default -> assertNever(def)
 ```
 
diff --git a/packages/liquid-html-parser/specs/recursive-descent.md b/packages/liquid-html-parser/specs/recursive-descent.md
index 6ab3ee0f6..aad52cf90 100644
--- a/packages/liquid-html-parser/specs/recursive-descent.md
+++ b/packages/liquid-html-parser/specs/recursive-descent.md
@@ -177,7 +177,6 @@ Standalone tags (no close tag) have `delimiterWhitespaceStart`/`delimiterWhitesp
 | **Branching** (delimiters inside blocks) | `elsif`, `else`, `when`                                                                                                                                 | Creates `LiquidBranch` nodes inside parent block.           |
 | **Raw** (body not parsed)                | `raw`, `comment`, `doc`, `javascript`, `schema`, `style`, `stylesheet`                                                                                  | Body is raw string until `{% endtagname %}`.                |
 | **Standalone** (no close tag)            | `echo`, `assign`, `render`, `include`, `increment`, `decrement`, `cycle`, `layout`, `section`, `sections`, `content_for`, `break`, `continue`, `liquid` | Self-contained, no children.                                |
-| **Hybrid**                               | `section` can be both standalone AND block form (`{% section 'name' %}...{% endsection %}`)                                                             | Check for presence of `{% endsection %}`.                   |
 
 **Position fields on block tags and branches:**
 
diff --git a/packages/liquid-html-parser/src/ast.test.ts b/packages/liquid-html-parser/src/ast.test.ts
index 996d97a6d..aff7dac87 100644
--- a/packages/liquid-html-parser/src/ast.test.ts
+++ b/packages/liquid-html-parser/src/ast.test.ts
@@ -1105,50 +1105,30 @@ describe('Unit: Stage 2 (AST)', () => {
       }
     });
 
-    it('should parse section hybrid (block form) with endsection', () => {
+    it('should treat section as a standalone tag and endsection as an unknown tag', () => {
       for (const { toAST, expectPath } of testCases) {
-        const source = `{% section 'foo' %}content{% endsection %}`;
-        ast = toAST(source);
-        expectPath(ast, 'children.0.type').to.eql('LiquidTag');
+        ast = toAST(`{% section 'foo' %}content{% endsection %}`);
         expectPath(ast, 'children.0.name').to.eql('section');
-        expectPath(ast, 'children.0.markup.name.value').to.eql('foo');
-        expectPath(ast, 'children.0.children.0.type').to.eql('TextNode');
-        expectPath(ast, 'children.0.children.0.value').to.eql('content');
-
-        // blockEndPosition should span the {% endsection %} tag exactly
-        expectPath(ast, 'children.0.blockEndPosition.start').to.eql(
-          source.indexOf('{% endsection %}'),
-        );
-        expectPath(ast, 'children.0.blockEndPosition.end').to.eql(source.length);
-
-        // section node position.end should match endsection's end
-        expectPath(ast, 'children.0.position.end').to.eql(source.length);
+        expectPath(ast, 'children.0.children').to.eql(undefined);
+        expectPath(ast, 'children.1.value').to.eql('content');
+        expectPath(ast, 'children.2.name').to.eql('endsection');
 
-        expectPath(ast, 'children.0.delimiterWhitespaceStart').to.eql('');
-        expectPath(ast, 'children.0.delimiterWhitespaceEnd').to.eql('');
-      }
-    });
+        ast = toAST(`{% endsection %}`);
+        expectPath(ast, 'children.0.name').to.eql('endsection');
 
-    it('should capture whitespace trimming on endsection', () => {
-      for (const { toAST, expectPath } of testCases) {
-        const source = `{% section 'foo' %}content{%- endsection -%}`;
-        ast = toAST(source);
-        expectPath(ast, 'children.0.name').to.eql('section');
-        expectPath(ast, 'children.0.delimiterWhitespaceStart').to.eql('-');
-        expectPath(ast, 'children.0.delimiterWhitespaceEnd').to.eql('-');
-        expectPath(ast, 'children.0.blockEndPosition.start').to.eql(
-          source.indexOf('{%- endsection -%}'),
-        );
-        expectPath(ast, 'children.0.blockEndPosition.end').to.eql(source.length);
-        expectPath(ast, 'children.0.position.end').to.eql(source.length);
+        ast = toAST(`{% if a %}{% endsection %}{% endif %}`);
+        expectPath(ast, 'children.0.name').to.eql('if');
+        expectPath(ast, 'children.0.children.0.children.0.name').to.eql('endsection');
       }
     });
 
-    it('should throw on orphaned endsection', () => {
+    it('should still throw on stray end tags for other registered tags', () => {
       for (const { toAST } of testCases) {
-        expect(() => {
-          toAST(`{% endsection %}`);
-        }).to.throw(/without a matching/);
+        expect(() => toAST(`{% endrender %}`)).to.throw(/without a matching 'render'/);
+        expect(() => toAST(`{% endsections %}`)).to.throw(/without a matching 'sections'/);
+        expect(() => toAST(`{% if a %}{% endrender %}{% endif %}`)).to.throw(
+          /before LiquidTag 'if' was closed/,
+        );
       }
     });
 
diff --git a/packages/liquid-html-parser/src/document/liquid-blocks.ts b/packages/liquid-html-parser/src/document/liquid-blocks.ts
index ba08d651e..a8e992c49 100644
--- a/packages/liquid-html-parser/src/document/liquid-blocks.ts
+++ b/packages/liquid-html-parser/src/document/liquid-blocks.ts
@@ -20,6 +20,7 @@ import type {
   LiquidBranchNamed,
   AttributeNode,
 } from '../ast';
+import { isStructuralEndTag } from '../environment';
 import type { TagDefinitionBlock, BranchName, Parser } from '../environment';
 import { LiquidHTMLASTParsingError } from '../errors';
 import { assertNever } from '../utils';
@@ -126,7 +127,7 @@ export function parseBlockBody(
 
       if (tagName && tagName.startsWith('end')) {
         const innerName = tagName.slice(3);
-        if (parser.blockEnv.tagForName(innerName)) {
+        if (isStructuralEndTag(innerName, parser.blockEnv.tagForName(innerName))) {
           throw new LiquidHTMLASTParsingError(
             `Attempting to close LiquidTag '${innerName}' before LiquidTag '${parentName}' was closed`,
             parser.getSource(),
@@ -252,7 +253,7 @@ export function parseBranchedBody(
 
       if (tagName && tagName.startsWith('end')) {
         const innerName = tagName.slice(3);
-        if (parser.blockEnv.tagForName(innerName)) {
+        if (isStructuralEndTag(innerName, parser.blockEnv.tagForName(innerName))) {
           throw new LiquidHTMLASTParsingError(
             `Attempting to close LiquidTag '${innerName}' before LiquidTag '${parentName}' was closed`,
             parser.getSource(),
diff --git a/packages/liquid-html-parser/src/document/liquid-hybrid.test.ts b/packages/liquid-html-parser/src/document/liquid-hybrid.test.ts
deleted file mode 100644
index 79b3b3489..000000000
--- a/packages/liquid-html-parser/src/document/liquid-hybrid.test.ts
+++ /dev/null
@@ -1,201 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { toLiquidHtmlAST, toLiquidAST } from '../ast';
-import {
-  expectPath,
-  expectPosition,
-  expectBlockStartPosition,
-  expectBlockEndPosition,
-} from './test-helpers';
-
-describe('Unit: liquid-hybrid', () => {
-  describe('standalone form', () => {
-    it('should parse standalone section as LiquidTag with SectionMarkup', () => {
-      const ast = toLiquidHtmlAST(`{% section 'foo' %}`);
-      expectPath(ast, 'children.0.type').to.eql('LiquidTag');
-      expectPath(ast, 'children.0.name').to.eql('section');
-      expectPath(ast, 'children.0.markup.type').to.eql('SectionMarkup');
-      expectPath(ast, 'children.0.markup.name.type').to.eql('String');
-      expectPath(ast, 'children.0.markup.name.value').to.eql('foo');
-      expectPath(ast, 'children.0.markup.args').to.eql([]);
-      expectPath(ast, 'children.0.children').to.be.undefined;
-      expectPath(ast, 'children.0.blockEndPosition').to.be.undefined;
-    });
-
-    it('should parse standalone section with kwargs', () => {
-      const ast = toLiquidHtmlAST(`{% section 'foo', key: 'val' %}`);
-      expectPath(ast, 'children.0.type').to.eql('LiquidTag');
-      expectPath(ast, 'children.0.name').to.eql('section');
-      expectPath(ast, 'children.0.markup.name.value').to.eql('foo');
-      expectPath(ast, 'children.0.markup.args.0.type').to.eql('NamedArgument');
-      expectPath(ast, 'children.0.markup.args.0.name').to.eql('key');
-      expectPath(ast, 'children.0.markup.args.0.value.value').to.eql('val');
-      expectPath(ast, 'children.0.children').to.be.undefined;
-    });
-
-    it('should have correct position for standalone section', () => {
-      const source = `{% section 'foo' %}`;
-      const ast = toLiquidHtmlAST(source);
-      expectPosition(ast, 'children.0').to.eql(source);
-    });
-  });
-
-  describe('block form', () => {
-    it('should parse block section with children', () => {
-      const source = `{% section 'foo' %}content{% endsection %}`;
-      const ast = toLiquidHtmlAST(source);
-      expectPath(ast, 'children.0.type').to.eql('LiquidTag');
-      expectPath(ast, 'children.0.name').to.eql('section');
-      expectPath(ast, 'children.0.markup.type').to.eql('SectionMarkup');
-      expectPath(ast, 'children.0.markup.name.value').to.eql('foo');
-      expectPath(ast, 'children.0.children').to.have.lengthOf(1);
-      expectPath(ast, 'children.0.children.0.type').to.eql('TextNode');
-      expectPath(ast, 'children.0.children.0.value').to.eql('content');
-      expectBlockEndPosition(ast, 'children.0').to.eql('{% endsection %}');
-    });
-
-    it('should parse block section with kwargs', () => {
-      const source = `{% section 'foo', key: 'val' %}content{% endsection %}`;
-      const ast = toLiquidHtmlAST(source);
-      expectPath(ast, 'children.0.markup.name.value').to.eql('foo');
-      expectPath(ast, 'children.0.markup.args.0.name').to.eql('key');
-      expectPath(ast, 'children.0.children').to.have.lengthOf(1);
-      expectPath(ast, 'children.0.children.0.value').to.eql('content');
-    });
-
-    it('should parse empty block section', () => {
-      const ast = toLiquidHtmlAST(`{% section 'foo' %}{% endsection %}`);
-      expectPath(ast, 'children.0.name').to.eql('section');
-      expectPath(ast, 'children.0.children').to.have.lengthOf(0);
-    });
-
-    it('should parse block section with Liquid children', () => {
-      const ast = toLiquidHtmlAST(`{% section 'foo' %}{{ title }}{% echo "hi" %}{% endsection %}`);
-      expectPath(ast, 'children.0.children').to.have.lengthOf(2);
-      expectPath(ast, 'children.0.children.0.type').to.eql('LiquidVariableOutput');
-      expectPath(ast, 'children.0.children.1.type').to.eql('LiquidTag');
-      expectPath(ast, 'children.0.children.1.name').to.eql('echo');
-    });
-
-    it('should have correct position.end for block form', () => {
-      const source = `{% section 'foo' %}content{% endsection %}`;
-      const ast = toLiquidHtmlAST(source);
-      expectPath(ast, 'children.0.position.end').to.eql(source.length);
-    });
-
-    it('should set blockEndPosition spanning endsection exactly', () => {
-      const source = `{% section 'foo' %}content{% endsection %}`;
-      const ast = toLiquidHtmlAST(source);
-      expectBlockEndPosition(ast, 'children.0').to.eql('{% endsection %}');
-    });
-
-    it('should set blockStartPosition spanning open tag exactly', () => {
-      const source = `{% section 'foo' %}content{% endsection %}`;
-      const ast = toLiquidHtmlAST(source);
-      expectBlockStartPosition(ast, 'children.0').to.eql(`{% section 'foo' %}`);
-    });
-  });
-
-  describe('nesting-aware lookahead', () => {
-    it('should parse nested sections: outer block, inner block', () => {
-      const source = `{% section 'a' %}{% section 'b' %}{% endsection %}{% endsection %}`;
-      const ast = toLiquidHtmlAST(source);
-      expectPath(ast, 'children').to.have.lengthOf(1);
-      expectPath(ast, 'children.0.name').to.eql('section');
-      expectPath(ast, 'children.0.markup.name.value').to.eql('a');
-      expectPath(ast, 'children.0.children').to.have.lengthOf(1);
-      expectPath(ast, 'children.0.children.0.type').to.eql('LiquidTag');
-      expectPath(ast, 'children.0.children.0.name').to.eql('section');
-      expectPath(ast, 'children.0.children.0.markup.name.value').to.eql('b');
-      expectPath(ast, 'children.0.children.0.children').to.have.lengthOf(0);
-    });
-
-    it('should parse single endsection with nested section as siblings', () => {
-      const source = `{% section 'outer' %}{% section 'inner' %}{% endsection %}`;
-      const ast = toLiquidHtmlAST(source);
-      expectPath(ast, 'children').to.have.lengthOf(2);
-      expectPath(ast, 'children.0.name').to.eql('section');
-      expectPath(ast, 'children.0.markup.name.value').to.eql('outer');
-      expectPath(ast, 'children.0.children').to.be.undefined;
-      expectPath(ast, 'children.1.name').to.eql('section');
-      expectPath(ast, 'children.1.markup.name.value').to.eql('inner');
-      expectPath(ast, 'children.1.children').to.have.lengthOf(0);
-    });
-
-    it('should parse two standalone sections', () => {
-      const source = `{% section 'a' %}{% section 'b' %}`;
-      const ast = toLiquidHtmlAST(source);
-      expectPath(ast, 'children').to.have.lengthOf(2);
-      expectPath(ast, 'children.0.name').to.eql('section');
-      expectPath(ast, 'children.0.markup.name.value').to.eql('a');
-      expectPath(ast, 'children.0.children').to.be.undefined;
-      expectPath(ast, 'children.1.name').to.eql('section');
-      expectPath(ast, 'children.1.markup.name.value').to.eql('b');
-      expectPath(ast, 'children.1.children').to.be.undefined;
-    });
-  });
-
-  describe('whitespace stripping', () => {
-    it('should capture symmetric whitespace trimming on endsection', () => {
-      const source = `{% section 'foo' %}{%- endsection -%}`;
-      const ast = toLiquidHtmlAST(source);
-      expectPath(ast, 'children.0.delimiterWhitespaceStart').to.eql('-');
-      expectPath(ast, 'children.0.delimiterWhitespaceEnd').to.eql('-');
-    });
-
-    it('should capture asymmetric whitespace trimming on endsection', () => {
-      const source = `{% section 'foo' %}{% endsection -%}`;
-      const ast = toLiquidHtmlAST(source);
-      expectPath(ast, 'children.0.delimiterWhitespaceStart').to.eql('');
-      expectPath(ast, 'children.0.delimiterWhitespaceEnd').to.eql('-');
-    });
-  });
-
-  describe('error handling', () => {
-    it('should throw on orphaned endsection', () => {
-      expect(() => toLiquidHtmlAST('{% endsection %}')).to.throw(
-        /Attempting to close LiquidTag 'section' before it was opened/,
-      );
-    });
-
-    it('should fall back to base case for bad markup in block form (tolerant)', () => {
-      const ast = toLiquidHtmlAST('{% section !bad %}content{% endsection %}');
-      expectPath(ast, 'children.0.type').to.eql('LiquidTag');
-      expectPath(ast, 'children.0.name').to.eql('section');
-      expectPath(ast, 'children.0.markup').to.eql('!bad');
-      expectPath(ast, 'children.0.children').to.have.lengthOf(1);
-      expectPath(ast, 'children.0.children.0.value').to.eql('content');
-    });
-
-    it('should fall back to base case for bad markup in standalone form (tolerant)', () => {
-      const ast = toLiquidHtmlAST('{% section !bad %}');
-      expectPath(ast, 'children.0.type').to.eql('LiquidTag');
-      expectPath(ast, 'children.0.name').to.eql('section');
-      expectPath(ast, 'children.0.markup').to.eql('!bad');
-      expectPath(ast, 'children.0.children').to.be.undefined;
-    });
-  });
-
-  describe('parity: toLiquidAST matches toLiquidHtmlAST', () => {
-    it('should produce same structure for standalone section', () => {
-      const source = `{% section 'foo' %}`;
-      const htmlAst = toLiquidHtmlAST(source);
-      const liquidAst = toLiquidAST(source);
-      expectPath(htmlAst, 'children.0.name').to.eql('section');
-      expectPath(liquidAst, 'children.0.name').to.eql('section');
-      expectPath(htmlAst, 'children.0.markup.name.value').to.eql('foo');
-      expectPath(liquidAst, 'children.0.markup.name.value').to.eql('foo');
-      expectPath(htmlAst, 'children.0.children').to.be.undefined;
-      expectPath(liquidAst, 'children.0.children').to.be.undefined;
-    });
-
-    it('should produce same structure for block section', () => {
-      const source = `{% section 'foo' %}content{% endsection %}`;
-      const htmlAst = toLiquidHtmlAST(source);
-      const liquidAst = toLiquidAST(source);
-      expectPath(htmlAst, 'children.0.name').to.eql('section');
-      expectPath(liquidAst, 'children.0.name').to.eql('section');
-      expectPath(htmlAst, 'children.0.children.0.value').to.eql('content');
-      expectPath(liquidAst, 'children.0.children.0.value').to.eql('content');
-    });
-  });
-});
diff --git a/packages/liquid-html-parser/src/document/liquid-hybrid.ts b/packages/liquid-html-parser/src/document/liquid-hybrid.ts
deleted file mode 100644
index f855efa19..000000000
--- a/packages/liquid-html-parser/src/document/liquid-hybrid.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-import { TokenType } from './tokenizer';
-import type { Token } from './tokenizer';
-import { ParserBase } from './base';
-import { makeLiquidTagBaseCase, makeLiquidTagNamed } from './factories';
-import type { LiquidTagEnvelope } from './factories';
-import type { LiquidTag } from '../ast';
-import type { TagDefinitionHybrid } from '../environment';
-import { MarkupParser } from '../markup/parser';
-import { tokenizeMarkup } from '../markup/tokenizer';
-import { parseBlockBody } from './liquid-blocks';
-import type { BlockParserDelegate } from './liquid-blocks';
-
-/**
- * Interface capturing what hybrid-tag free functions need from the
- * DocumentParser. The parser class satisfies this contract, keeping
- * the coupling explicit and narrow.
- */
-export type HybridParserDelegate = BlockParserDelegate;
-
-// hybridTag := standaloneTag | "{%" tagName markup "%}" blockBody "{%" "end" tagName "%}"
-export function parseHybridTag(
-  parser: HybridParserDelegate,
-  def: TagDefinitionHybrid,
-  envelope: LiquidTagEnvelope,
-  closeToken: Token,
-): LiquidTag {
-  let markup: unknown;
-  let markupParsed = false;
-  let reason: string | undefined;
-  try {
-    const markupStringStart = closeToken.start - envelope.markupString.length;
-    const tokens = tokenizeMarkup(envelope.markupString, markupStringStart);
-    const markupParser = new MarkupParser(tokens, parser.getSource());
-    if (parser.isTolerant()) markupParser.enableTolerant();
-    markup = def.parse(envelope.tagName, markupParser, parser);
-    if (!markupParser.isAtEnd()) {
-      markup = undefined;
-      reason = 'unexpected tokens after markup';
-    } else {
-      markupParsed = true;
-    }
-  } catch (e) {
-    markup = undefined;
-    reason = e instanceof Error ? e.message : 'unknown error';
-  }
-
-  const endTagIndex = scanForEndTagNested(parser, envelope.tagName);
-
-  if (endTagIndex === -1) {
-    if (markupParsed) {
-      return makeLiquidTagNamed(envelope, markup);
-    }
-    return makeLiquidTagBaseCase(envelope, undefined, undefined, undefined, reason);
-  }
-
-  const { children, endPosition, endWhitespace } = parseBlockBody(parser, envelope);
-
-  if (markupParsed) {
-    return makeLiquidTagNamed(envelope, markup, children, endPosition, endWhitespace);
-  }
-  return makeLiquidTagBaseCase(envelope, children, endPosition, endWhitespace, reason);
-}
-
-/**
- * Scan forward for a matching end tag, respecting nesting of same-named tags.
- * Returns the token index of the end tag's LiquidTagOpen, or -1 if not found.
- */
-export function scanForEndTagNested(parser: ParserBase, tagName: string): number {
-  let depth = 0;
-  const endTagName = `end${tagName}`;
-  const source = parser.getSource();
-  const tokenCount = parser.tokenCount();
-  const pos = parser.getPosition();
-
-  for (let i = pos; i < tokenCount; i++) {
-    if (parser.tokenAt(i).type !== TokenType.LiquidTagOpen) continue;
-
-    const textIdx = i + 1;
-    if (textIdx >= tokenCount) continue;
-    if (parser.tokenAt(textIdx).type !== TokenType.Text) continue;
-
-    const textToken = parser.tokenAt(textIdx);
-    const text = source.slice(textToken.start, textToken.end);
-    const trimmed = text.trimStart();
-    const firstWs = trimmed.search(/\s/);
-    const name = firstWs === -1 ? trimmed.trim() : trimmed.slice(0, firstWs);
-
-    if (name === tagName) {
-      depth++;
-    } else if (name === endTagName) {
-      if (depth === 0) return i;
-      depth--;
-    }
-  }
-  return -1;
-}
diff --git a/packages/liquid-html-parser/src/document/liquid-lines.ts b/packages/liquid-html-parser/src/document/liquid-lines.ts
index f00cf46a1..3a30864bf 100644
--- a/packages/liquid-html-parser/src/document/liquid-lines.ts
+++ b/packages/liquid-html-parser/src/document/liquid-lines.ts
@@ -24,7 +24,6 @@ import type {
   LiquidLineContext,
   TagDefinitionBlock,
   TagDefinitionRaw,
-  TagDefinitionHybrid,
   BranchName,
   Environment,
   Parser,
@@ -120,9 +119,6 @@ export function parseLiquidStatement(
     case TagKind.Raw:
       return parseLineRawTag(parser, def, envelope, ctx);
 
-    case TagKind.Hybrid:
-      return parseLineHybridTag(parser, def, envelope, markupString, markupOffset, ctx);
-
     default:
       return assertNever(def);
   }
@@ -281,66 +277,6 @@ export function parseLineRawTag(
   return makeLiquidRawTag(envelope, body, endPosition, { start: '', end: '' });
 }
 
-// lineHybridTag := tagName markup (LF lineBlockBody "end" tagName)?
-export function parseLineHybridTag(
-  parser: LineParserDelegate,
-  def: TagDefinitionHybrid,
-  envelope: LiquidTagEnvelope,
-  markupString: string,
-  markupOffset: number,
-  ctx: LiquidLineContext,
-): LiquidTag {
-  let markup: unknown;
-  let markupParsed = false;
-  let reason: string | undefined;
-  try {
-    const tokens = tokenizeMarkup(markupString, markupOffset);
-    const markupParser = new MarkupParser(tokens, parser.getSource());
-    if (parser.isTolerant()) markupParser.enableTolerant();
-
-    markup = def.parse(envelope.tagName, markupParser, parser);
-    if (!markupParser.isAtEnd()) {
-      markup = undefined;
-      reason = 'unexpected tokens after markup';
-    } else {
-      markupParsed = true;
-    }
-  } catch (e) {
-    markup = undefined;
-    reason = e instanceof Error ? e.message : 'unknown error';
-  }
-
-  const endTagName = `end${envelope.tagName}`;
-  let hasEndTag = false;
-  let depth = 0;
-  for (let i = ctx.index; i < ctx.lines.length; i++) {
-    if (ctx.lines[i].tagName === envelope.tagName) {
-      depth++;
-    } else if (ctx.lines[i].tagName === endTagName) {
-      if (depth === 0) {
-        hasEndTag = true;
-        break;
-      }
-      depth--;
-    }
-  }
-
-  if (!hasEndTag) {
-    if (markupParsed) {
-      return makeLiquidTagNamed(envelope, markup);
-    }
-    return makeLiquidTagBaseCase(envelope, undefined, undefined, undefined, reason);
-  }
-
-  const { children, endNameOffset } = parseLineBlockBody(parser, envelope.tagName, ctx);
-  const endTagLength = 3 + envelope.tagName.length; // 'end' + tagName
-  const endPosition: Position = { start: endNameOffset, end: endNameOffset + endTagLength };
-  if (markupParsed) {
-    return makeLiquidTagNamed(envelope, markup, children, endPosition, { start: '', end: '' });
-  }
-  return makeLiquidTagBaseCase(envelope, children, endPosition, { start: '', end: '' }, reason);
-}
-
 // lineBlockBody := liquidStatement* "end" tagName
 export function parseLineBlockBody(
   parser: LineParserDelegate,
diff --git a/packages/liquid-html-parser/src/document/liquid-tags.ts b/packages/liquid-html-parser/src/document/liquid-tags.ts
index 604761a90..4890a3067 100644
--- a/packages/liquid-html-parser/src/document/liquid-tags.ts
+++ b/packages/liquid-html-parser/src/document/liquid-tags.ts
@@ -4,7 +4,7 @@ import { envelopeFromTokens, makeLiquidTagBaseCase, makeLiquidTagNamed } from '.
 import type { LiquidTagEnvelope } from './factories';
 import type { LiquidRawTag, LiquidTag } from '../ast';
 import type { TagDefinition, TagDefinitionTag } from '../environment';
-import { TagKind } from '../environment';
+import { TagKind, isStructuralEndTag } from '../environment';
 import { LiquidHTMLASTParsingError } from '../errors';
 import { assertNever } from '../utils';
 import { MarkupParser } from '../markup/parser';
@@ -13,7 +13,6 @@ import { parseBlockTag } from './liquid-blocks';
 import type { BlockParserDelegate } from './liquid-blocks';
 import { parseRawTag } from './liquid-raw';
 import type { RawParserDelegate } from './liquid-raw';
-import { parseHybridTag } from './liquid-hybrid';
 
 /**
  * Interface capturing what the liquid-tag dispatch function needs from
@@ -24,7 +23,7 @@ export interface TagParserDelegate extends BlockParserDelegate, RawParserDelegat
   tagForName(name: string): TagDefinition | undefined;
 }
 
-// liquidTag := "{%" tagName markup "%}" (block | raw | hybrid)?
+// liquidTag := "{%" tagName markup "%}" (block | raw)?
 export function parseLiquidTag(parser: TagParserDelegate): LiquidTag | LiquidRawTag {
   const openToken = parser.consume(TokenType.LiquidTagOpen);
   parser.accept(TokenType.Text);
@@ -46,7 +45,7 @@ export function parseLiquidTag(parser: TagParserDelegate): LiquidTag | LiquidRaw
   if (envelope.tagName.startsWith('end')) {
     const innerName = envelope.tagName.slice(3);
     const innerDef = parser.tagForName(innerName);
-    if (innerDef) {
+    if (isStructuralEndTag(innerName, innerDef)) {
       throw new LiquidHTMLASTParsingError(
         `Attempting to close LiquidTag '${innerName}' before it was opened without a matching '${innerName}'`,
         parser.getSource(),
@@ -72,9 +71,6 @@ export function parseLiquidTag(parser: TagParserDelegate): LiquidTag | LiquidRaw
     case TagKind.Raw:
       return parseRawTag(parser, def, envelope, closeToken);
 
-    case TagKind.Hybrid:
-      return parseHybridTag(parser, def, envelope, closeToken);
-
     default:
       return assertNever(def);
   }
diff --git a/packages/liquid-html-parser/src/environment.test.ts b/packages/liquid-html-parser/src/environment.test.ts
index 4dc9e3f22..5b53161eb 100644
--- a/packages/liquid-html-parser/src/environment.test.ts
+++ b/packages/liquid-html-parser/src/environment.test.ts
@@ -6,7 +6,6 @@ import {
   type TagDefinitionBlock,
   type TagDefinitionTag,
   type TagDefinitionRaw,
-  type TagDefinitionHybrid,
 } from './environment';
 import { assertNever } from './utils';
 
@@ -24,10 +23,6 @@ function makeRawDef(parseLiquidInBody?: boolean): TagDefinitionRaw {
   return { kind: TagKind.Raw, parse: stubParse, parseLiquidInBody };
 }
 
-function makeHybridDef(): TagDefinitionHybrid {
-  return { kind: TagKind.Hybrid, parse: stubParse };
-}
-
 describe('Unit: Environment', () => {
   beforeEach(() => {
     Environment.resetDefault();
@@ -84,7 +79,6 @@ describe('Unit: Environment', () => {
       expect(TagKind.Block).toBe('block');
       expect(TagKind.Tag).toBe('tag');
       expect(TagKind.Raw).toBe('raw');
-      expect(TagKind.Hybrid).toBe('hybrid');
     });
   });
 
@@ -98,8 +92,6 @@ describe('Unit: Environment', () => {
             return 'tag';
           case TagKind.Raw:
             return `raw(parseLiquid=${def.parseLiquidInBody ?? false})`;
-          case TagKind.Hybrid:
-            return 'hybrid';
           default:
             return assertNever(def);
         }
@@ -109,7 +101,6 @@ describe('Unit: Environment', () => {
       expect(describeKind(makeStandaloneDef())).toBe('tag');
       expect(describeKind(makeRawDef(true))).toBe('raw(parseLiquid=true)');
       expect(describeKind(makeRawDef())).toBe('raw(parseLiquid=false)');
-      expect(describeKind(makeHybridDef())).toBe('hybrid');
     });
   });
 });
diff --git a/packages/liquid-html-parser/src/environment.ts b/packages/liquid-html-parser/src/environment.ts
index 11289139a..8b2aca21c 100644
--- a/packages/liquid-html-parser/src/environment.ts
+++ b/packages/liquid-html-parser/src/environment.ts
@@ -1,11 +1,11 @@
 // Re-export all tag definition types so existing imports from './environment' keep working.
 export {
   TagKind,
+  isStructuralEndTag,
   type BranchName,
   type Parser,
   type TagDefinition,
   type TagDefinitionBlock,
-  type TagDefinitionHybrid,
   type TagDefinitionRaw,
   type TagDefinitionTag,
   type LiquidLine,
diff --git a/packages/liquid-html-parser/src/lax-recover.test.ts b/packages/liquid-html-parser/src/lax-recover.test.ts
index 1c698f5ee..c7632551f 100644
--- a/packages/liquid-html-parser/src/lax-recover.test.ts
+++ b/packages/liquid-html-parser/src/lax-recover.test.ts
@@ -130,6 +130,13 @@ describe('laxRecoverTagMarkup', () => {
     expect(() => laxRecoverTagMarkup('assign', src, src, 0, src.length)).toThrow();
   });
 
+  it('does not lax-recover section markup (Ruby raises in every error mode)', () => {
+    const markup = "'header' junk";
+    expect(() => laxRecoverTagMarkup('section', markup, markup, 0, markup.length)).toThrow(
+      LaxTagRecoveryError,
+    );
+  });
+
   it('throws a LaxTagRecoveryError for an unknown tag', () => {
     // Core Liquid raises "Unknown tag" via block.rb; recovery surfaces it
     // instead of swallowing to empty output.
diff --git a/packages/liquid-html-parser/src/lax-recover.ts b/packages/liquid-html-parser/src/lax-recover.ts
index c5b260636..ae741db69 100644
--- a/packages/liquid-html-parser/src/lax-recover.ts
+++ b/packages/liquid-html-parser/src/lax-recover.ts
@@ -90,7 +90,9 @@ export function laxRecoverTagMarkup(
   markupEnd: number,
 ): unknown {
   const def: TagDefinition | undefined = (builtinTags as Record<string, TagDefinition>)[tagName];
-  if (!def || (def.kind !== TagKind.Tag && def.kind !== TagKind.Block)) {
+  // Ruby's `section` tag has no lax parse: it raises on anything but
+  // `section '[type]'` in every error mode, so don't recover it here.
+  if (!def || tagName === 'section' || (def.kind !== TagKind.Tag && def.kind !== TagKind.Block)) {
     throw new LaxTagRecoveryError(`Unknown tag '${tagName}'`);
   }
   // increment/decrement lax_parse is `@variable_name = markup.strip`, which
diff --git a/packages/liquid-html-parser/src/tag-definitions.ts b/packages/liquid-html-parser/src/tag-definitions.ts
index d063fdc1c..7c7ea891c 100644
--- a/packages/liquid-html-parser/src/tag-definitions.ts
+++ b/packages/liquid-html-parser/src/tag-definitions.ts
@@ -14,7 +14,6 @@ export enum TagKind {
   Block = 'block',
   Tag = 'tag',
   Raw = 'raw',
-  Hybrid = 'hybrid',
 }
 
 export type BranchName = 'elsif' | 'else' | 'when';
@@ -37,16 +36,20 @@ export interface TagDefinitionRaw<M = unknown> {
   parse(name: string, markup: MarkupParser, parser: Parser): M;
 }
 
-export interface TagDefinitionHybrid<M = unknown> {
-  kind: TagKind.Hybrid;
-  parse(name: string, markup: MarkupParser, parser: Parser): M;
-}
-
 export type TagDefinition<M = unknown> =
   | TagDefinitionBlock<M>
   | TagDefinitionTag<M>
-  | TagDefinitionRaw<M>
-  | TagDefinitionHybrid<M>;
+  | TagDefinitionRaw<M>;
+
+/**
+ * Whether a stray `{% end<name> %}` for a registered tag is a structural parse
+ * error. `endsection` is the exception: `section` is standalone, and Ruby
+ * Liquid reports `{% endsection %}` as an unknown tag (the legacy block form
+ * was removed), so it parses as an unknown tag and Theme Check reports it.
+ */
+export function isStructuralEndTag(innerName: string, def: { kind: string } | undefined): boolean {
+  return def !== undefined && innerName !== 'section';
+}
 
 /** A parsed line from a {% liquid %} body. */
 export interface LiquidLine {
diff --git a/packages/liquid-html-parser/src/tags/section.test.ts b/packages/liquid-html-parser/src/tags/section.test.ts
index aa2ace1c7..cef45abf4 100644
--- a/packages/liquid-html-parser/src/tags/section.test.ts
+++ b/packages/liquid-html-parser/src/tags/section.test.ts
@@ -15,8 +15,8 @@ function parser(markup: string): MarkupParser {
 const stubParser = {} as Parser;
 
 describe('sectionTag', () => {
-  it('has hybrid kind', () => {
-    expect(sectionTag.kind).toBe(TagKind.Hybrid);
+  it('has tag kind', () => {
+    expect(sectionTag.kind).toBe(TagKind.Tag);
   });
 
   it('parses section with name only', () => {
diff --git a/packages/liquid-html-parser/src/tags/section.ts b/packages/liquid-html-parser/src/tags/section.ts
index 3df088ca2..bc91941ee 100644
--- a/packages/liquid-html-parser/src/tags/section.ts
+++ b/packages/liquid-html-parser/src/tags/section.ts
@@ -2,10 +2,10 @@ import type { SectionMarkup } from '../ast';
 import type { MarkupParser } from '../markup/parser';
 import { MarkupTokenType } from '../markup/tokenizer';
 import { NodeTypes } from '../types';
-import { TagKind, type TagDefinitionHybrid, type Parser } from '../tag-definitions';
+import { TagKind, type TagDefinitionTag, type Parser } from '../tag-definitions';
 
-export const sectionTag: TagDefinitionHybrid<SectionMarkup> = {
-  kind: TagKind.Hybrid,
+export const sectionTag: TagDefinitionTag<SectionMarkup> = {
+  kind: TagKind.Tag,
   parse(_name: string, markup: MarkupParser, _parser: Parser): SectionMarkup {
     const name = markup.valueExpression();
     if (name.type !== NodeTypes.String) {
diff --git a/packages/theme-check-common/src/checks/liquid-syntax-error/index.ts b/packages/theme-check-common/src/checks/liquid-syntax-error/index.ts
index 53fcf5140..7c21fa2fa 100644
--- a/packages/theme-check-common/src/checks/liquid-syntax-error/index.ts
+++ b/packages/theme-check-common/src/checks/liquid-syntax-error/index.ts
@@ -26,7 +26,7 @@ import { checkRawParserError, checkRawTag } from './raw';
 import { checkRenderTag } from './render';
 import { checkSchemaTag } from './schema';
 import { checkSectionsTag } from './sections';
-import { checkSectionTag } from './section';
+import { checkEndsectionTag, checkSectionTag } from './section';
 import { checkStyleTag } from './style';
 import { checkStylesheetTag } from './stylesheet';
 import { checkTablerowTag } from './tablerow';
@@ -64,6 +64,7 @@ const tagCheckers: Record<string, TagChecker> = {
   partial: checkPartialTag,
   render: checkRenderTag,
   section: checkSectionTag,
+  endsection: checkEndsectionTag,
   sections: checkSectionsTag,
   unless: checkUnlessTag,
 };
diff --git a/packages/theme-check-common/src/checks/liquid-syntax-error/section.ts b/packages/theme-check-common/src/checks/liquid-syntax-error/section.ts
index a8459c3be..fbb500727 100644
--- a/packages/theme-check-common/src/checks/liquid-syntax-error/section.ts
+++ b/packages/theme-check-common/src/checks/liquid-syntax-error/section.ts
@@ -2,6 +2,18 @@ import type { LiquidTag, SectionMarkup } from '@shopify/liquid-html-parser';
 import type { Context } from '.';
 import { hasBareArrayAccess, hasSkippedCharacters, rawMarkup } from './utils';
 
+/*
+ * +section+ is a standalone tag, so +{% endsection %}+ parses as an unknown
+ * tag. Ruby Liquid reports it the same way.
+ */
+export function checkEndsectionTag(node: LiquidTag, context: Context): void {
+  context.report({
+    message: "Unknown tag 'endsection'",
+    startIndex: node.position.start,
+    endIndex: node.position.end,
+  });
+}
+
 export function checkSectionTag(node: LiquidTag, context: Context): void {
   if (typeof node.markup === 'string') {
     context.report({
@@ -12,15 +24,6 @@ export function checkSectionTag(node: LiquidTag, context: Context): void {
     return;
   }
 
-  if (node.blockEndPosition) {
-    context.report({
-      message: "Unknown tag 'endsection'",
-      startIndex: node.blockEndPosition.start,
-      endIndex: node.blockEndPosition.end,
-    });
-    return;
-  }
-
   const markup = node.markup as SectionMarkup;
 
   /*