fix(docking): guard detached dock area in addDockWidget hot path

- ADS removeDockArea() calls setParent(nullptr) then deleteLater(),
  leaving a live but orphaned area for one event-loop turn; passing
  it to addDockWidget() dereferenced a null container and crashed
- Introduce DockAreaSanitizer to collapse orphaned areas to nullptr
  so ADS falls back to the always-valid dock manager as container
- Add lastTabClosed signal (type-agnostic, queued) so closing the
  last browser or mini-app tab respawns "New X" the same way the
  last editor tab does; wire handleEditorAreaEmptied as single owner
- Snapshot initialEditor() before adding any new tab and close it
  after, preventing mid-flight empty-area respawn in MiniAppManager
- Add m_isClosing guard so handleEditorAreaEmptied no-ops during
  window tear-down
- Cover sanitizeDockArea() with a widget-level Qt test that
  reproduces the exact detach transition without private ADS state

Author: nullmastermind

src/CMakeLists.txt

@@ -26,6 +26,7 @@ qt_add_executable(NotepadAI
 	DataPaths.h
 	DebugManager.h
 	DefaultDirectoryManager.h
+	DockAreaSanitizer.h
 	DockedEditor.h
 	DockedEditorTitleBar.h
 
@@ -108,6 +109,7 @@ qt_add_executable(NotepadAI
 	DataPaths.cpp
 	DebugManager.cpp
 	DefaultDirectoryManager.cpp
+	DockAreaSanitizer.cpp
 	DockedEditor.cpp
 
 	EditorManager.cpp

src/DockAreaSanitizer.cpp

@@ -0,0 +1,33 @@
+/*
+ * This file is part of Notepad Next.
+ * Copyright 2026 NotepadAI contributors
+ *
+ * Notepad Next is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Notepad Next is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Notepad Next.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "DockAreaSanitizer.h"
+
+#include "DockAreaWidget.h"
+
+ads::CDockAreaWidget *sanitizeDockArea(ads::CDockAreaWidget *area)
+{
+    // An area detached from its container (parent already nullptr, deleteLater
+    // pending) reports dockContainer() == nullptr. Collapse it to nullptr so the
+    // caller takes ADS's safe add-to-container fallback instead of dereferencing
+    // a null container. nullptr in -> nullptr out; attached area passes through.
+    if (area && !area->dockContainer())
+        return nullptr;
+
+    return area;
+}

src/DockAreaSanitizer.h

@@ -0,0 +1,43 @@
+/*
+ * This file is part of Notepad Next.
+ * Copyright 2026 NotepadAI contributors
+ *
+ * Notepad Next is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Notepad Next is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Notepad Next.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef DOCKAREASANITIZER_H
+#define DOCKAREASANITIZER_H
+
+namespace ads { class CDockAreaWidget; }
+
+// Pure predicate guarding the "feed a dock area to ADS addDockWidget" hot path.
+//
+// ADS's CDockContainerWidget::removeDockArea() does setParent(nullptr) and THEN
+// deleteLater(), so for one event-loop turn a removed dock area is alive (a
+// QPointer to it stays non-null) yet orphaned: CDockAreaWidget::dockContainer()
+// walks parentWidget() and returns nullptr. Passing such an area as the 3rd arg
+// of CDockManager::addDockWidget() makes Container = area->dockContainer() null,
+// and the following topLevelDockArea() dereferences that null container — the
+// crash recorded in crash_report.txt (Preview reopened while its area was being
+// torn down).
+//
+// sanitizeDockArea() collapses a detached area to nullptr so callers route into
+// ADS's add-to-container fallback (Container = the always-valid dock manager),
+// which creates a fresh area for the tab. A null input stays null; a still-
+// attached area passes through unchanged. Pure and side-effect-free so it is
+// unit-testable in isolation (see tests/test_docked_editor_current_area.cpp),
+// mirroring the TerminalCwdResolver split.
+ads::CDockAreaWidget *sanitizeDockArea(ads::CDockAreaWidget *area);
+
+#endif // DOCKAREASANITIZER_H

src/DockedEditor.cpp

@@ -18,6 +18,7 @@
 
 
 #include "DockedEditor.h"
+#include "DockAreaSanitizer.h"
 #include "DockAreaTabBar.h"
 #include "DockAreaWidget.h"
 #include "DockWidgetTab.h"
@@ -92,6 +93,17 @@ DockedEditor::DockedEditor(QWidget *parent) : QObject(parent)
         emit editorActivated(editor);
     });
 
+    // Fire lastTabClosed() once the area is fully empty. dockWidgetRemoved is
+    // emitted by CDockManager ONLY from CDockWidget::deleteDockWidget() (the
+    // delete-on-close path) — never during drag/split/float — and AFTER the
+    // widget and any now-empty dock area are removed, so totalTabCount() reads
+    // the settled state here. Both tab kinds use DockWidgetDeleteOnClose, so
+    // neither lingers as a hidden phantom in the layout count.
+    connect(dockManager, &ads::CDockManager::dockWidgetRemoved, this, [this](ads::CDockWidget *) {
+        if (totalTabCount() == 0)
+            emit lastTabClosed();
+    });
+
     connect(dockManager, &ads::CDockManager::dockAreaCreated, this, [=](ads::CDockAreaWidget* DockArea) {
         DockedEditorTitleBar *titleBar = qobject_cast<DockedEditorTitleBar *>(DockArea->titleBar());
         connect(titleBar, &DockedEditorTitleBar::doubleClicked, this, &DockedEditor::titleBarDoubleClicked);
@@ -133,6 +145,60 @@ int DockedEditor::count() const
     return total;
 }
 
+int DockedEditor::totalTabCount() const
+{
+    // Counts every tab of every kind — editors AND nn_previewTab tabs (preview,
+    // browser, mini-apps, future kinds) — so it answers "is the editor area
+    // empty?" with no per-type branching: a new tab kind is counted for free.
+    //
+    // We iterate dockContainers() (the main dock manager container PLUS every
+    // floating container), NOT just the main container's dockAreaCount(). Today
+    // all tab types clear DockWidgetFloatable so none can be torn out into a
+    // floating window — but counting only the main container would silently
+    // undercount the instant any future tab type is made floatable, reopening
+    // the spurious-"New 1" bug in a way that's painful to trace. Iterating all
+    // containers makes the count correct regardless of the floatable flag.
+    //
+    // dockWidgetsCount() (the raw layout count) is correct here rather than
+    // openDockWidgetsCount() (which filters !isClosed()): both our tab kinds set
+    // DockWidgetDeleteOnClose, so a closed tab is REMOVED from the layout, never
+    // left hidden-but-present. There is therefore no closed-but-undeleted
+    // phantom to overcount, and this avoids a per-widget isClosed() scan. Each
+    // dockWidgetsCount() is O(1) (a layout count), so this stays a cheap walk.
+    int total = 0;
+
+    for (const ads::CDockContainerWidget *container : dockManager->dockContainers()) {
+        for (int i = 0; i < container->dockAreaCount(); ++i)
+            total += container->dockArea(i)->dockWidgetsCount();
+    }
+
+    return total;
+}
+
+ScintillaNext *DockedEditor::initialEditor() const
+{
+    // Only a reusable scratch tab if it is the sole editor. count() is
+    // editors-only (skips nn_previewTab), matching the historic semantics:
+    // a lone "New X" alongside e.g. a browser tab is still replaceable.
+    if (count() != 1)
+        return nullptr;
+
+    ScintillaNext *editor = getCurrentEditor();
+
+    // getCurrentEditor() can be null mid-close: the cached pointer is auto-
+    // nulled by QPointer when its editor is destroyed. Treat as "none".
+    if (editor == nullptr)
+        return nullptr;
+
+    // Reject anything the user might care about: a temporary buffer, a real or
+    // missing file, or a buffer with undo/redo history (i.e. it was edited).
+    // Only a truly pristine "New X" survives and may be transparently closed.
+    if (editor->isTemporary() || editor->isFile() || editor->canUndo() || editor->canRedo())
+        return nullptr;
+
+    return editor;
+}
+
 QVector<ScintillaNext *> DockedEditor::editors() const
 {
     QVector<ScintillaNext *> editors;
@@ -172,7 +238,13 @@ void DockedEditor::dockWidgetCloseRequested()
 
 ads::CDockAreaWidget *DockedEditor::currentDockArea() const
 {
-    return dockManager->focusedDockWidget() ? dockManager->focusedDockWidget()->dockAreaWidget() : latestDockArea.data();
+    ads::CDockWidget *focused = dockManager->focusedDockWidget();
+    ads::CDockAreaWidget *area = focused ? focused->dockAreaWidget() : latestDockArea.data();
+
+    // Collapse a detached-but-not-yet-destroyed area to nullptr (see
+    // sanitizeDockArea / DockAreaSanitizer.h for why this prevents the
+    // null-container crash in CDockManager::addDockWidget).
+    return sanitizeDockArea(area);
 }
 
 void DockedEditor::addEditor(ScintillaNext *editor)

src/DockedEditor.h

@@ -52,8 +52,34 @@ class DockedEditor : public QObject
 
     void switchToEditor(const ScintillaNext *editor);
 
+    // Number of real editors only (excludes preview/browser/mini-app tabs).
     int count() const;
 
+    // Number of tabs of EVERY kind currently in the center dock area —
+    // editors plus all `nn_previewTab` tabs (preview, browser, mini-apps, and
+    // any future tab type routed through the same dock manager). Use this, not
+    // count(), to decide whether the editor area is truly empty (e.g. whether
+    // to spawn a fresh "New X" buffer). New tab kinds are counted automatically
+    // as long as they are added through addEditor()/addPreviewTab().
+    int totalTabCount() const;
+
+    // The single reusable "initial" editor — an unedited, pristine "New X"
+    // scratch buffer that is currently the sole editor — or nullptr if there
+    // isn't one. "Pristine" means: a New-type buffer (not a file, not missing,
+    // not temporary) with nothing to undo/redo, i.e. the user never touched it.
+    //
+    // This is THE shared definition of "is there a throwaway scratch tab I can
+    // transparently replace?". Every surface that opens a new piece of content
+    // (newFile, file open, file preview, web/browser tabs, future tab kinds)
+    // must snapshot this BEFORE adding its own tab, then close the result AFTER,
+    // so the scratch "New X" is swapped out without ever emptying the area mid-
+    // flight (which would otherwise fire lastTabClosed and respawn). Centralised
+    // here — on DockedEditor, which every tab-spawning subsystem already holds —
+    // so MainWindow-less callers (e.g. MiniAppManager's web tabs) share it
+    // instead of reinventing the pristine test. MainWindow::getInitialEditor()
+    // delegates here.
+    ScintillaNext *initialEditor() const;
+
     ScintillaNext *previewEditor() const;
     void pinPreviewEditor();
 
@@ -87,6 +113,12 @@ private slots:
     void previewTabActivated(QWidget *widget);
     void previewEditorSet();
 
+    // Emitted after the LAST tab of ANY kind (editor or nn_previewTab) is
+    // removed from the dock manager, i.e. totalTabCount() just hit 0. The one
+    // type-agnostic signal callers use to react to "the editor area is now
+    // empty" — a new tab kind needs no new signal.
+    void lastTabClosed();
+
     void contextMenuRequestedForEditor(ScintillaNext *editor);
     void titleBarDoubleClicked();
 };

src/MiniAppManager.cpp

@@ -173,12 +173,20 @@ void MiniAppManager::launchApp(const MiniAppDefinition &def)
             instance->dockWidget()->setWindowTitle(title);
     });
 
+    // Snapshot the reusable pristine "New X" scratch tab BEFORE adding the web
+    // tab; close it AFTER so the area never empties mid-flight (which would fire
+    // lastTabClosed and respawn). Same swap-out behaviour as opening a file.
+    ScintillaNext *initialEditor = m_dockedEditor->initialEditor();
+
     // Create tab immediately (shows "Starting..." title)
     QWidget *placeholder = new QWidget();
     ads::CDockWidget *dw = m_dockedEditor->addPreviewTab(
         placeholder, def.name + QStringLiteral(" \xe2\x80\x94 Starting..."), tintedGlobeIcon());
     instance->setDockWidget(dw);
 
+    if (initialEditor)
+        initialEditor->close();
+
     // Wire tab close → destroy instance
     connect(dw, &ads::CDockWidget::closed, this, [this, instance]() {
         instance->destroy();
@@ -395,9 +403,16 @@ void MiniAppManager::launchQuickBrowser(const QUrl &url, bool enableCdp,
     if (!webView)
         return;
 
+    // Snapshot the reusable pristine "New X" scratch tab BEFORE adding the web
+    // tab; close it AFTER so the area never empties mid-flight. See launchApp().
+    ScintillaNext *initialEditor = m_dockedEditor->initialEditor();
+
     ads::CDockWidget *dw = m_dockedEditor->addPreviewTab(
         webView, url.host().isEmpty() ? url.toString() : url.host(), tintedGlobeIcon());
 
+    if (initialEditor)
+        initialEditor->close();
+
     QuickBrowserTab tab;
     tab.webView = webView;
     tab.dockWidget = dw;