@@ -233,7 +233,15 @@ export class CompletionBuilder<N extends TmplAstNode | AST> {
     options: ts.GetCompletionsAtPositionOptions | undefined,
   ): ts.WithMetadata<ts.CompletionInfo> | undefined {
     const blocksWithParens = ['if', 'else if', 'for', 'switch', 'case', 'defer'];
-    const blocksWithoutParens = ['else', 'empty', 'placeholder', 'error', 'loading', 'default'];
+    const blocksWithoutParens = [
+      'else',
+      'empty',
+      'placeholder',
+      'error',
+      'loading',
+      'default',
+      'boundary',
+    ];
 
     // Determine whether to provide a snippet, which includes parens and curly braces.
     // If the block has any expressions or a body, don't provide a snippet as the completion.
 
@@ -11,6 +11,8 @@ import {
   ASTWithSource,
   TmplAstBoundAttribute,
   TmplAstBoundDeferredTrigger,
+  TmplAstBoundaryBlock,
+  TmplAstBoundaryErrorBlock,
   TmplAstComponent,
   TmplAstContent,
   TmplAstDeferredBlock,
@@ -524,6 +526,57 @@ class TemplateSymbolVisitor extends TmplAstRecursiveVisitor {
     tmplAstVisitAll(this, block.children);
     this.popChildren();
   }
+  override visitBoundaryBlock(block: TmplAstBoundaryBlock): void {
+    const symbol: TemplateDocumentSymbol = {
+      text: '@boundary',
+      kind: ts.ScriptElementKind.functionElement,
+      lspKind: AngularSymbolKind.Event, // @boundary → Event ⚡
+      spans: [toTextSpan(block.mainBlockSpan)],
+      nameSpan: toTextSpan(block.startSourceSpan),
+    };
+    this.addSymbol(symbol);
+    this.pushChildren(symbol);
+    tmplAstVisitAll(this, block.children);
+    tmplAstVisitAll(this, block.errorBlocks);
+    this.popChildren();
+  }
+
+  override visitBoundaryErrorBlock(block: TmplAstBoundaryErrorBlock): void {
+    const triggers: string[] = [];
+    if (block.expression) {
+      const exprText = getExpressionText(block.expression);
+      triggers.push(`when ${exprText}`);
+    }
+    const name = triggers.length > 0 ? `@error (${triggers.join('; ')})` : '@error';
+
+    const symbol: TemplateDocumentSymbol = {
+      text: name,
+      kind: ts.ScriptElementKind.functionElement,
+      lspKind: AngularSymbolKind.Event, // @error → Event ⚡
+      spans: [toTextSpan(block.sourceSpan)],
+      nameSpan: toTextSpan(block.startSourceSpan),
+    };
+    this.addSymbol(symbol);
+    this.pushChildren(symbol);
+
+    for (const contextVar of block.contextVariables) {
+      this.processedVariables.add(contextVar);
+      // Show if explicitly aliased (name differs from value) OR if showImplicitForVariables is enabled
+      const isExplicitlyAliased = contextVar.name !== contextVar.value;
+      if (isExplicitlyAliased || this.options.showImplicitForVariables) {
+        const contextSymbol: TemplateDocumentSymbol = {
+          text: `let ${contextVar.name}`,
+          kind: ts.ScriptElementKind.localVariableElement,
+          spans: [toTextSpan(contextVar.keySpan)],
+          nameSpan: toTextSpan(contextVar.keySpan),
+        };
+        this.addSymbol(contextSymbol);
+      }
+    }
+
+    tmplAstVisitAll(this, block.children);
+    this.popChildren();
+  }
 
   // Elements and components
   override visitElement(element: TmplAstElement): void {
 
@@ -16,6 +16,7 @@ import {
   TmplAstNode,
   TmplAstRecursiveVisitor,
   TmplAstSwitchBlockCase,
+  TmplAstBoundaryBlock,
   tmplAstVisitAll,
 } from '@angular/compiler';
 import {isExternalResource, isNamedClassDeclaration, NgCompiler} from '@angular/compiler-cli';
@@ -68,7 +69,11 @@ class BlockVisitor extends TmplAstRecursiveVisitor {
       // The source span of for loops and deferred blocks contain all parts (ForLoopBlockEmpty,
       // DeferredBlockLoading, etc.). The folding range should only include the main block span for
       // these.
-      if (block instanceof TmplAstForLoopBlock || block instanceof TmplAstDeferredBlock) {
+      if (
+        block instanceof TmplAstForLoopBlock ||
+        block instanceof TmplAstDeferredBlock ||
+        block instanceof TmplAstBoundaryBlock
+      ) {
         mainBlockSpan = block.mainBlockSpan;
       }
       return {
 
@@ -39,6 +39,8 @@ import {
   TmplAstUnknownBlock,
   TmplAstVariable,
   TmplAstVisitor,
+  TmplAstBoundaryBlock,
+  TmplAstBoundaryErrorBlock,
 } from '@angular/compiler';
 import {NgCompiler, PotentialDirective} from '@angular/compiler-cli';
 
@@ -205,6 +207,15 @@ class ClassificationVisitor implements TmplAstVisitor {
     this.visitAll(block.children);
   }
 
+  visitBoundaryBlock(block: TmplAstBoundaryBlock) {
+    this.visitAll(block.children);
+    this.visitAll(block.errorBlocks);
+  }
+
+  visitBoundaryErrorBlock(block: TmplAstBoundaryErrorBlock) {
+    this.visitAll(block.children);
+  }
+
   visitTemplate(template: TmplAstTemplate) {
     this.visitAll(template.children);
   }
 
@@ -18,6 +18,8 @@ import {
   RecursiveAstVisitor,
   SafeCall,
   ThisReceiver,
+  TmplAstBoundaryBlock,
+  TmplAstBoundaryErrorBlock,
   TmplAstBoundAttribute,
   TmplAstBoundDeferredTrigger,
   TmplAstBoundEvent,
@@ -54,7 +56,6 @@ import {
   tmplAstVisitAll,
   TmplAstVisitor,
 } from '@angular/compiler';
-import {NgCompiler} from '@angular/compiler-cli';
 import {findFirstMatchingNode} from '@angular/compiler-cli/private/hybrid_analysis';
 import tss from 'typescript';
 
@@ -63,7 +64,6 @@ import {
   isTemplateNodeWithKeyAndValue,
   isWithin,
   isWithinKeyValue,
-  TypeCheckInfo,
 } from './utils';
 
 /**
@@ -703,6 +703,17 @@ class TemplateTargetVisitor implements TmplAstVisitor {
     this.visitAll(block.children);
   }
 
+  visitBoundaryBlock(block: TmplAstBoundaryBlock) {
+    this.visitAll(block.children);
+    this.visitAll(block.errorBlocks);
+  }
+
+  visitBoundaryErrorBlock(block: TmplAstBoundaryErrorBlock) {
+    this.visitAll(block.contextVariables);
+    block.expression && this.visitBinding(block.expression);
+    this.visitAll(block.children);
+  }
+
   visitUnknownBlock(block: TmplAstUnknownBlock) {}
 
   visitLetDeclaration(decl: TmplAstLetDeclaration) {
 
@@ -203,6 +203,35 @@ describe('get outlining spans', () => {
     expect(getTrimmedSpanText(result[0].textSpan, files['app.ts'])).toEqual('{{item}}');
     expect(getTrimmedSpanText(result[1].textSpan, files['app.ts'])).toEqual('empty list');
   });
+
+  it('should have outlining spans for boundary and error blocks', () => {
+    const files = {
+      'app.ts': `
+        import {Component} from '@angular/core';
+
+        @Component({
+          template: \`
+          @boundary {
+            boundary body
+          } @error (let err) {
+            error body
+          }
+          \`,
+          standalone: false,
+        })
+        export class AppCmp {
+        }`,
+    };
+    const env = LanguageServiceTestEnv.setup();
+    const project = createModuleAndProjectWithDeclarations(env, 'test', files);
+    project.expectNoSourceDiagnostics();
+
+    const appFile = project.openFile('app.ts');
+    const result = appFile.getOutliningSpans();
+    expect(result.length).toEqual(2);
+    expect(getTrimmedSpanText(result[0].textSpan, files['app.ts'])).toEqual('boundary body');
+    expect(getTrimmedSpanText(result[1].textSpan, files['app.ts'])).toEqual('error body');
+  });
 });
 
 function getTrimmedSpanText(span: ts.TextSpan, contents: string) {
 
@@ -848,6 +848,22 @@ describe('quick info', () => {
         });
       });
 
+      it('boundary error block context variables', () => {
+        expectQuickInfo({
+          templateOverride: `@boundary { } @error (let er¦r) { }`,
+          expectedSpanText: 'err',
+          expectedDisplayString: '(variable) err: Error',
+        });
+      });
+
+      it('boundary error block retry context variable', () => {
+        expectQuickInfo({
+          templateOverride: `@boundary { } @error (let err, rt¦ry = $reset) { }`,
+          expectedSpanText: 'rtry',
+          expectedDisplayString: '(variable) rtry: () => void',
+        });
+      });
+
       it('if block alias variable narrowed', () => {
         expectQuickInfo({
           templateOverride: `@if (signalValue; as al¦iasName) {}`,
 
@@ -12,7 +12,7 @@
       "name": "keyword.control.block.transition.ng"
     },
     "block": {
-      "begin": "(@)(if|else if|else|defer|placeholder|loading|error|switch|for|empty)(?:\\s*)",
+      "begin": "(@)(if|else if|else|defer|placeholder|loading|error|boundary|switch|for|empty)(?:\\s*)",
       "beginCaptures": {
         "1": {
           "patterns": [
@@ -108,6 +108,9 @@
         {
           "include": "#blockExpressionTrackClause"
         },
+        {
+          "include": "#blockExpressionWhenClause"
+        },
         {
           "include": "expression.ng"
         }
@@ -119,6 +122,20 @@
         }
       }
     },
+    "blockExpressionWhenClause": {
+      "begin": "\\bwhen\\b",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.control.when.ng"
+        }
+      },
+      "end": "(?=[$)])|(?<=;)",
+      "patterns": [
+        {
+          "include": "expression.ng"
+        }
+      ]
+    },
     "blockExpressionOfClause": {
       "begin": "([_$[:alpha:]][_$[:alnum:]]*)\\s+(of)\\b",
       "beginCaptures": {