feat: fallback static parsing for completely invalid notebooks (#8723)

## 📝 Summary

Allows notebooks with broken syntax to be parsed by extracting the "cell
boundaries" (i.e. @app.cell) and leveraging indentation. Possibly a bit
heavy handed, but leverages a simple state machine to work through the
tokens to find the boundaries.

NB, this is _ONLY_ a fallback mechanism, but should prevent breakage in
vs-code/ watch when the source file breaks.

Author: dmadisetti

marimo/_ast/load.py

@@ -58,7 +58,7 @@ def _maybe_contents(filename: Optional[Union[str, Path]]) -> Optional[str]:
     if filename is None:
         return None
 
-    return Path(filename).read_text(encoding="utf-8").strip()
+    return Path(filename).read_text(encoding="utf-8", errors="replace").strip()
 
 
 def find_cell(filename: str, lineno: int) -> CellDef | None:

marimo/_ast/parse.py

@@ -511,14 +511,27 @@ def from_file(filename: Union[str, Path]) -> Parser:
     def __init__(self, contents: str, filepath: str = "<marimo>"):
         self.extractor = Extractor(contents=contents)
         self.filepath = filepath
+        self._scanner_generated_lines: frozenset[int] = frozenset()
 
     def node_stack(self) -> PeekStack[Node]:
-        tree = ast_parse(
-            self.extractor.contents or "",
-            filename=self.filepath,
-            suppress_warnings=False,
-        )
-        return PeekStack(iter(tree.body))
+        try:
+            tree = ast_parse(
+                self.extractor.contents or "",
+                filename=self.filepath,
+                suppress_warnings=False,
+            )
+            return PeekStack(iter(tree.body))
+        except SyntaxError:
+            # File has syntax errors — use scanner to recover individual cells.
+            # Never re-raise: parse_notebook must return a best-effort result
+            # so --watch and IPC are never broken by a syntax error.
+            from marimo._ast.scanner import scan_parse_fallback
+
+            nodes, scanner_lines = scan_parse_fallback(
+                self.extractor.contents or "", self.filepath
+            )
+            self._scanner_generated_lines = scanner_lines
+            return PeekStack(iter(nodes))
 
     def parse_header(self, body: PeekStack[Node]) -> ParseResult[Header]:
         # header? = (docstring | comments)*
@@ -662,7 +675,20 @@ def parse_body(self, body: PeekStack[Node]) -> ParseResult[list[CellDef]]:
             if is_body_cell(node):
                 cell_result = self.extractor.to_cell(node)
                 violations.extend(cell_result.violations)
-                cells.append(cell_result.unwrap())
+                cell = cell_result.unwrap()
+                # Scanner-generated unparsable cells indicate a syntax
+                # error in the original cell source.
+                if (
+                    isinstance(cell, UnparsableCell)
+                    and node.lineno in self._scanner_generated_lines
+                ):
+                    violations.append(
+                        Violation(
+                            SCANNER_UNPARSABLE_CELL_VIOLATION,
+                            lineno=node.lineno,
+                        )
+                    )
+                cells.append(cell)
             elif is_run_guard(node):
                 break
             else:
@@ -1157,6 +1183,9 @@ def parse_notebook(
 ONLY_HEADER_EXTRACTED_VIOLATION = "Only able to extract header."
 NON_MARIMO_PYTHON_SCRIPT_VIOLATION = "non-marimo Python content beyond header"
 EXPECTED_RUN_GUARD_VIOLATION = "Expected run guard statement"
+SCANNER_UNPARSABLE_CELL_VIOLATION = (
+    "Cell contains a syntax error and could not be parsed"
+)
 
 # Soft violations are auto-corrected on save with no data loss.
 # Any violation NOT in this set is considered "hard" (potential data loss).