@mlightcad/cad-simple-viewer 1.6.1 → 1.6.3

package/lib/app/AcApDocManager.js

@@ -45,6 +45,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -84,7 +95,7 @@ var __values = (this && this.__values) || function(o) {
 import { AcCmEventManager, AcDbDatabase, AcDbFileType, acdbHostApplicationServices, AcDbSysVarManager, AcGeBox2d, log } from '@mlightcad/data-model';
 import { FontManager } from '@mlightcad/mtext-renderer';
 import { AcTrMTextRenderer } from '@mlightcad/three-renderer';
-import { AcApAboutCmd, AcApArcCmd, AcApCacheFontCmd, AcApCircleCmd, AcApClearMarkupsCmd, AcApClearMeasurementsCmd, AcApConvertToDxfCmd, AcApConvertToPngCmd, AcApCopyCmd, AcApDimLinearCmd, AcApEllipseCmd, AcApEntityPreviewCmd, AcApEraseCmd, AcApHatchCmd, AcApHideObjectsCmd, AcApImageAttachCmd, AcApInsertCmd, AcApLayerCloseCmd, AcApLayerCmd, AcApLayerCurCmd, AcApLayerDelCmd, AcApLayerFreezeCmd, AcApLayerIsoCmd, AcApLayerLockCmd, AcApLayerOnCmd, AcApLayerPCmd, AcApLayerThawCmd, AcApLayerUnisoCmd, AcApLayerUnlockCmd, AcApLayoffCmd, AcApLineCmd, AcApLogCmd, AcApMarkupArrowCmd, AcApMarkupCalloutCmd, AcApMarkupCircleCmd, AcApMarkupCloudCmd, AcApMarkupExportCmd, AcApMarkupHighlightCmd, AcApMarkupImportCmd, AcApMarkupLineCmd, AcApMarkupRectCmd, AcApMarkupStampCmd, AcApMarkupTextCmd, AcApMarkupVisibilityCmd, AcApMeasureAngleCmd, AcApMeasureArcCmd, AcApMeasureAreaCmd, AcApMeasureDistanceCmd, AcApMeasurementExportCmd, AcApMeasurementImportCmd, AcApMeasurementVisibilityCmd, AcApMeasurePointCmd, AcApMLineCmd, AcApMoveCmd, AcApMTextCmd, AcApOffsetCmd, AcApOpenCmd, AcApPanCmd, AcApPointCmd, AcApPolygonCmd, AcApPolylineCmd, AcApQNewCmd, AcApRayCmd, AcApRectCmd, AcApRedoCmd, AcApRegenCmd, AcApRevCloudCmd, AcApRotateCmd, AcApSelectCmd, AcApSketchCmd, AcApSplineCmd, AcApSwitchBgCmd, AcApSysVarCmd, AcApUndoCmd, AcApUnisolateObjectsCmd, AcApXAttachCmd, AcApXLineCmd, AcApZoomCmd, resetMarkupSession, resetMeasurementSession } from '../command';
+import { AcApAboutCmd, AcApArcCmd, acapBindMarkupSession, AcApCacheFontCmd, AcApCircleCmd, AcApClearMarkupsCmd, AcApClearMeasurementsCmd, AcApCloseCmd, AcApConvertToDxfCmd, AcApConvertToPngCmd, AcApCopyCmd, AcApDimLinearCmd, acapDisposeMarkupSession, AcApEllipseCmd, AcApEntityPreviewCmd, AcApEraseCmd, AcApHatchCmd, AcApHideObjectsCmd, AcApImageAttachCmd, AcApInsertCmd, AcApLayerCloseCmd, AcApLayerCmd, AcApLayerCurCmd, AcApLayerDelCmd, AcApLayerFreezeCmd, AcApLayerIsoCmd, AcApLayerLockCmd, AcApLayerOnCmd, AcApLayerPCmd, AcApLayerThawCmd, AcApLayerUnisoCmd, AcApLayerUnlockCmd, AcApLayoffCmd, AcApLineCmd, AcApLogCmd, AcApMarkupArrowCmd, AcApMarkupCalloutCmd, AcApMarkupCircleCmd, AcApMarkupCloudCmd, AcApMarkupExportCmd, AcApMarkupHighlightCmd, AcApMarkupImportCmd, AcApMarkupLineCmd, AcApMarkupRectCmd, AcApMarkupStampCmd, AcApMarkupTextCmd, AcApMarkupVisibilityCmd, AcApMeasureAngleCmd, AcApMeasureArcCmd, AcApMeasureAreaCmd, AcApMeasureDistanceCmd, AcApMeasurementExportCmd, AcApMeasurementImportCmd, AcApMeasurementVisibilityCmd, AcApMeasurePointCmd, AcApMLineCmd, AcApMoveCmd, AcApMTextCmd, AcApOffsetCmd, AcApOpenCmd, AcApPanCmd, AcApPointCmd, AcApPolygonCmd, AcApPolylineCmd, AcApQNewCmd, AcApRayCmd, AcApRectCmd, AcApRedoCmd, AcApRegenCmd, AcApRevCloudCmd, AcApRotateCmd, AcApSelectCmd, AcApSketchCmd, AcApSplineCmd, AcApSwitchBgCmd, AcApSysVarCmd, AcApUndoCmd, AcApUnisolateObjectsCmd, AcApXAttachCmd, AcApXLineCmd, AcApZoomCmd, resetMarkupSession, resetMeasurementSession } from '../command';
 import { AcEdCommandStack, AcEdOpenMode } from '../editor';
 import { AcApPluginManager } from '../plugin/AcApPluginManager';
 import { AcApDrawStyleToolbar } from '../ui/AcApDrawStyleToolbar';
@@ -94,6 +105,7 @@ import { AcTrView2d } from '../view';
 import { AcApBusyIndicator } from './AcApBusyIndicator';
 import { acapBindCommandServices } from './AcApCommandServices';
 import { AcApContext } from './AcApContext';
+import { AcApDocSession } from './AcApDocSession';
 import { AcApDocument } from './AcApDocument';
 import { AcApFontLoader } from './AcApFontLoader';
 import { acapInstallOpenFileDialog, acapUninstallOpenFileDialog, acapUpdateOpenFileDialogOptions } from './AcApOpenFileDialog';
@@ -183,12 +195,14 @@ var AcApDocManager = /** @class */ (function () {
         if (options === void 0) { options = {}; }
         var _this = this;
         var _a, _b, _c, _d;
+        /** Open document sessions (MDI). The shared view shows {@link _activeSession}. */
+        this._sessions = [];
+        /** Monotonic id suffix for {@link AcApDocSession.id}. */
+        this._nextSessionId = 1;
         /** Optional OPENPROF session profiler (console stage timings) */
         this._openFileProfiler = new AcApOpenFileProfiler();
         /** Cached worker readiness; null until checked, then true or false */
         this._workersReady = null;
-        /** Loaded overlay (reference/base drawing) state, keyed by overlay id */
-        this._overlays = new Map();
         /** Monotonically increasing counter used to generate overlay ids */
         this._nextOverlayId = 1;
         /** Events fired during document lifecycle */
@@ -199,6 +213,12 @@ var AcApDocManager = /** @class */ (function () {
             documentCreated: new AcCmEventManager(),
             /** Fired when a document becomes active */
             documentActivated: new AcCmEventManager(),
+            /** Fired before a document is activated */
+            documentToBeActivated: new AcCmEventManager(),
+            /** Fired before a document is closed and destroyed */
+            documentToBeDestroyed: new AcCmEventManager(),
+            /** Fired after a document has been closed */
+            documentDestroyed: new AcCmEventManager(),
             /** Fired when a worker readiness check completes */
             workersReady: new AcCmEventManager()
         };
@@ -249,7 +269,11 @@ var AcApDocManager = /** @class */ (function () {
             container: options.container,
             calculateSizeCallback: callback
         });
-        this._context = new AcApContext(view, doc);
+        this._mainView = view;
+        var context = new AcApContext(view, doc);
+        this._activeSession = new AcApDocSession("doc-".concat(this._nextSessionId++), context);
+        this._sessions = [this._activeSession];
+        acapBindMarkupSession(this._activeSession.id);
         this._drawStyleToolbar = new AcApDrawStyleToolbar(view);
         this._fontLoader = new AcApFontLoader();
         var fontsUrl = this.resolveFontsBaseUrl();
@@ -259,10 +283,12 @@ var AcApDocManager = /** @class */ (function () {
         acdbHostApplicationServices().workingDatabase = doc.database;
         this._commandManager = new AcEdCommandStack();
         this.registerCommands();
-        this._pluginManager = new AcApPluginManager(this._context, this._commandManager);
+        this._pluginManager = new AcApPluginManager(this.context, this._commandManager);
         var busyHost = (_d = options.busyIndicatorHost) !== null && _d !== void 0 ? _d : view.container;
+        this._busyIndicatorHost = busyHost;
         this._openFileProgress = new AcApOpenFileProgressController(busyHost);
-        this._openFileProgress.setSceneBusyGate(function () { return _this.curView.isProcessingEntities; });
+        this._openFileProgress.setSceneBusyGate(function () { return _this.openProgressView.isProcessingEntities; });
+        this._openFileProgress.setOnHidden(function () { return _this.onOpenProgressHidden(); });
         this._busyIndicator = new AcApBusyIndicator(busyHost);
         acapBindCommandServices({
             showMessage: function (message, type, msgKey) {
@@ -277,22 +303,10 @@ var AcApDocManager = /** @class */ (function () {
         this.events.documentToBeOpened.addEventListener(function () {
             _this._openFileProgress.reset();
         });
-        doc.database.events.openProgress.addEventListener(function (args) {
-            _this._openFileProgress.handle({
-                database: doc.database,
-                percentage: args.percentage,
-                stage: args.stage,
-                subStage: args.subStage,
-                subStageStatus: args.subStageStatus,
-                data: args.data
-            });
-            // After doc header is loaded, need to set global ltscale and celtscale
-            // It's too late when subStage is 'END'
-            if (args.subStage === 'HEADER') {
-                _this.curView.ltscale = doc.database.ltscale;
-                _this.curView.celtscale = doc.database.celtscale;
-                _this.curView.renderer.showLineWeight = doc.database.lwdisplay;
-            }
+        this.bindOpenProgress(doc);
+        this.events.documentCreated.dispatch({
+            doc: doc,
+            mode: doc.openMode
         });
         if (options.preloadDefaultFonts) {
             void this.loadDefaultFonts();
@@ -355,12 +369,34 @@ var AcApDocManager = /** @class */ (function () {
      */
     AcApDocManager.prototype.destroy = function () {
         return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var _a, _b, session;
+            var e_1, _c;
+            var _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0: return [4 /*yield*/, this._pluginManager.unloadAllPlugins()];
                     case 1:
-                        _a.sent();
-                        this.context.doc.destroy();
+                        _e.sent();
+                        (_d = this._splitView) === null || _d === void 0 ? void 0 : _d.stopAnimationLoop();
+                        this._splitView = undefined;
+                        try {
+                            for (_a = __values(__spreadArray([], __read(this._sessions), false)), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                session = _b.value;
+                                session.context.dispose();
+                                session.doc.destroy();
+                                if (session.viewState) {
+                                    this.curView.disposeSessionState(session.viewState);
+                                }
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        this._sessions = [];
                         acapUninstallOpenFileDialog();
                         AcTrMTextRenderer.resetInstance();
                         resetWebworkerReadinessCache();
@@ -419,19 +455,68 @@ var AcApDocManager = /** @class */ (function () {
          * @returns The current application context
          */
         get: function () {
-            return this._context;
+            return this._activeSession.context;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcApDocManager.prototype, "documents", {
+        /**
+         * Open document sessions in tab order.
+         */
+        get: function () {
+            return this._sessions.map(function (session) { return session.doc; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcApDocManager.prototype, "documentCount", {
+        /**
+         * Number of open documents.
+         */
+        get: function () {
+            return this._sessions.length;
         },
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(AcApDocManager.prototype, "activeSessionId", {
+        /**
+         * Session id of the active document, for host UI tabs.
+         */
+        get: function () {
+            return this._activeSession.id;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Returns the document at `index`, or undefined when out of range.
+     *
+     * @param index - Zero-based tab order.
+     */
+    AcApDocManager.prototype.document = function (index) {
+        var _a;
+        return (_a = this._sessions[index]) === null || _a === void 0 ? void 0 : _a.doc;
+    };
+    /**
+     * Finds the session that owns `doc`.
+     *
+     * @param doc - Document to look up.
+     */
+    AcApDocManager.prototype.sessionFor = function (doc) {
+        return this._sessions.find(function (session) { return session.doc === doc; });
+    };
     Object.defineProperty(AcApDocManager.prototype, "curDocument", {
         /**
          * Gets the currently open CAD document.
          *
+         * Same as {@link mdiActiveDocument} — the document bound to the shared view.
+         *
          * @returns The current document instance
          */
         get: function () {
-            return this._context.doc;
+            return this.context.doc;
         },
         enumerable: false,
         configurable: true
@@ -440,17 +525,232 @@ var AcApDocManager = /** @class */ (function () {
         /**
          * Gets the currently active document.
          *
-         * For now, this is the same as `curDocument` since only one document
-         * can be active at a time.
-         *
          * @returns The current active document
          */
         get: function () {
-            return this._context.doc;
+            return this._activeSession.doc;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Makes `doc` the command target.
+     *
+     * When both documents already have their own canvas (split view), scenes
+     * stay in place. When they share one canvas (tab MDI), the current scene is
+     * parked and the target is restored.
+     *
+     * @param doc - Document to activate.
+     * @returns `false` when `doc` is not an open session.
+     */
+    AcApDocManager.prototype.activateDocument = function (doc) {
+        return __awaiter(this, void 0, void 0, function () {
+            var session, targetView, currentView;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        session = this.sessionFor(doc);
+                        if (!session) {
+                            return [2 /*return*/, false];
+                        }
+                        if (session === this._activeSession) {
+                            return [2 /*return*/, true];
+                        }
+                        targetView = session.context.view;
+                        currentView = this._activeSession.context.view;
+                        if (this._openingSession && targetView === currentView) {
+                            return [2 /*return*/, false];
+                        }
+                        return [4 /*yield*/, this._commandManager.cancelActive()];
+                    case 1:
+                        _a.sent();
+                        this.events.documentToBeActivated.dispatch({
+                            doc: doc,
+                            mode: doc.openMode
+                        });
+                        if (targetView === currentView) {
+                            this.parkActiveSession();
+                            this._activeSession = session;
+                            session.context.resume();
+                            if (session.viewState) {
+                                this.curView.restoreSessionState(session.viewState);
+                                session.viewState = undefined;
+                            }
+                        }
+                        else {
+                            if (this._activeSession !== this._openingSession) {
+                                this._activeSession.context.suspend();
+                            }
+                            this._activeSession = session;
+                            session.context.resume();
+                        }
+                        acapBindMarkupSession(session.id);
+                        acdbHostApplicationServices().workingDatabase = doc.database;
+                        this._pluginManager.setContext(session.context);
+                        this.curView.bindDrawDatabase(doc.database);
+                        this.events.documentActivated.dispatch({
+                            doc: doc,
+                            mode: doc.openMode
+                        });
+                        this.setActiveLayout();
+                        this.curView.syncDisplaySysVars(doc.database);
+                        if (!this._openingSession) {
+                            this.syncProgressOverlayHost();
+                        }
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    Object.defineProperty(AcApDocManager.prototype, "mainView", {
+        /**
+         * Canvas created with {@link createInstance} (left pane in a split layout).
+         */
+        get: function () {
+            return this._mainView;
         },
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(AcApDocManager.prototype, "splitView", {
+        /**
+         * Second canvas created by {@link ensureSplitView}, if any.
+         */
+        get: function () {
+            return this._splitView;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Creates a second WebGL view in `container` for side-by-side comparison.
+     *
+     * Each document is converted into one view and stays there. Use
+     * {@link openDocument}'s `view` argument to open a file into this canvas,
+     * and {@link activateDocument} to choose which side receives commands.
+     *
+     * @param container - Host element for the second canvas.
+     */
+    AcApDocManager.prototype.ensureSplitView = function (container) {
+        if (!this._splitView) {
+            this._splitView = new AcTrView2d({
+                container: container,
+                calculateSizeCallback: function () { return ({
+                    width: Math.max(1, container.clientWidth),
+                    height: Math.max(1, container.clientHeight)
+                }); }
+            });
+        }
+        else if (this._splitView.container !== container) {
+            container.appendChild(this._splitView.container);
+        }
+        return this._splitView;
+    };
+    /**
+     * @deprecated Use {@link ensureSplitView} and open each file into its own view.
+     *
+     * @param container - Host element for the second canvas.
+     */
+    AcApDocManager.prototype.attachSatelliteView = function (container, _doc) {
+        this.ensureSplitView(container);
+        return true;
+    };
+    /**
+     * @deprecated Split canvases keep rendering; there is nothing to detach.
+     */
+    AcApDocManager.prototype.detachSatelliteView = function () {
+        return;
+    };
+    Object.defineProperty(AcApDocManager.prototype, "satelliteDocument", {
+        /**
+         * Document currently shown on the split canvas, if a session is bound to it.
+         */
+        get: function () {
+            var _this = this;
+            var _a;
+            if (!this._splitView) {
+                return undefined;
+            }
+            return (_a = this._sessions.find(function (session) { return session.context.view === _this._splitView; })) === null || _a === void 0 ? void 0 : _a.doc;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Closes `doc`, or the active document when omitted.
+     *
+     * Closing the last document replaces it with a new untitled drawing.
+     *
+     * @param doc - Document to close; defaults to {@link curDocument}.
+     * @returns `false` when `doc` is not an open session.
+     */
+    AcApDocManager.prototype.closeDocument = function (doc) {
+        return __awaiter(this, void 0, void 0, function () {
+            var target, session, wasActive, index, closedView, next;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        target = doc !== null && doc !== void 0 ? doc : this.curDocument;
+                        session = this.sessionFor(target);
+                        if (!session) {
+                            return [2 /*return*/, false];
+                        }
+                        return [4 /*yield*/, this._commandManager.cancelActive()];
+                    case 1:
+                        _a.sent();
+                        this.events.documentToBeDestroyed.dispatch({
+                            doc: target,
+                            mode: target.openMode
+                        });
+                        wasActive = session === this._activeSession;
+                        index = this._sessions.indexOf(session);
+                        if (this._sessions.length === 1) {
+                            this.resetActiveSessionToUntitled(session);
+                            this.events.documentDestroyed.dispatch({
+                                doc: target,
+                                mode: target.openMode
+                            });
+                            this.events.documentCreated.dispatch({
+                                doc: this.curDocument,
+                                mode: this.curDocument.openMode
+                            });
+                            this.events.documentActivated.dispatch({
+                                doc: this.curDocument,
+                                mode: this.curDocument.openMode
+                            });
+                            return [2 /*return*/, true];
+                        }
+                        if (wasActive) {
+                            this.parkActiveSession();
+                        }
+                        session.context.dispose();
+                        target.destroy();
+                        this.clearSessionOverlays(session);
+                        acapDisposeMarkupSession(session.id);
+                        closedView = session.context.view;
+                        if (session.viewState) {
+                            closedView.disposeSessionState(session.viewState);
+                            session.viewState = undefined;
+                        }
+                        else {
+                            closedView.clear();
+                        }
+                        this._sessions.splice(index, 1);
+                        this.events.documentDestroyed.dispatch({
+                            doc: target,
+                            mode: target.openMode
+                        });
+                        if (!wasActive) return [3 /*break*/, 3];
+                        next = this._sessions[Math.min(index, this._sessions.length - 1)];
+                        return [4 /*yield*/, this.activateDocument(next.doc)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [2 /*return*/, true];
+                }
+            });
+        });
+    };
     Object.defineProperty(AcApDocManager.prototype, "curView", {
         /**
          * Gets the current 2D view used to display the drawing.
@@ -458,7 +758,7 @@ var AcApDocManager = /** @class */ (function () {
          * @returns The current 2D view instance
          */
         get: function () {
-            return this._context.view;
+            return this.context.view;
         },
         enumerable: false,
         configurable: true
@@ -470,7 +770,7 @@ var AcApDocManager = /** @class */ (function () {
          * @returns The current editor instance
          */
         get: function () {
-            return this._context.view.editor;
+            return this.context.view.editor;
         },
         enumerable: false,
         configurable: true
@@ -652,8 +952,9 @@ var AcApDocManager = /** @class */ (function () {
     /**
      * Opens a CAD document from a URL.
      *
-     * This method loads a document from the specified URL and replaces the current document.
-     * It handles the complete document lifecycle including before/after open events.
+     * This method loads a document from the specified URL. When the current
+     * drawing is a reusable Untitled, it is replaced; otherwise a new document
+     * session is created and activated.
      *
      * @param url - The URL of the CAD file to open
      * @param options - Optional database opening options. If not provided, default options with font loader will be used
@@ -669,30 +970,42 @@ var AcApDocManager = /** @class */ (function () {
      */
     AcApDocManager.prototype.openUrl = function (url, options) {
         return __awaiter(this, void 0, void 0, function () {
-            var isSuccess, error_1;
+            var created, isSuccess, error_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         options = this.setOptions(options);
-                        this.onBeforeOpenDocument(options);
-                        _a.label = 1;
+                        return [4 /*yield*/, this.ensureOpenSession()];
                     case 1:
-                        _a.trys.push([1, 4, , 5]);
-                        return [4 /*yield*/, this._openFileProgress.beginOpen(this.context.doc.database)
-                            // TODO: The correct way is to create one new context instead of using old context and document
-                        ];
+                        created = _a.sent();
+                        this.beginOpenProgress();
+                        this.onBeforeOpenDocument(options, !created);
+                        _a.label = 2;
                     case 2:
+                        _a.trys.push([2, 7, , 10]);
+                        return [4 /*yield*/, this._openFileProgress.beginOpen(this.context.doc.database)];
+                    case 3:
                         _a.sent();
                         return [4 /*yield*/, this.context.doc.openUri(url, options)];
-                    case 3:
+                    case 4:
                         isSuccess = _a.sent();
                         this.onAfterOpenDocument(isSuccess, options);
-                        return [2 /*return*/, isSuccess];
-                    case 4:
+                        if (!(!isSuccess && created)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this.closeFailedOpenSession()];
+                    case 5:
+                        _a.sent();
+                        _a.label = 6;
+                    case 6: return [2 /*return*/, isSuccess];
+                    case 7:
                         error_1 = _a.sent();
                         this._openFileProfiler.cancel();
-                        throw error_1;
-                    case 5: return [2 /*return*/];
+                        if (!created) return [3 /*break*/, 9];
+                        return [4 /*yield*/, this.closeFailedOpenSession()];
+                    case 8:
+                        _a.sent();
+                        _a.label = 9;
+                    case 9: throw error_1;
+                    case 10: return [2 /*return*/];
                 }
             });
         });
@@ -700,13 +1013,14 @@ var AcApDocManager = /** @class */ (function () {
     /**
      * Opens a CAD document from file content.
      *
-     * This method loads a document from the provided file content (binary data)
-     * and replaces the current document. It handles the complete document lifecycle
-     * including before/after open events.
+     * This method loads a document from the provided file content (binary data).
+     * When the current drawing is a reusable Untitled, it is replaced; otherwise
+     * a new document session is created and activated.
      *
      * @param fileName - The name of the file being opened (used for format detection)
      * @param content - The file content
      * @param options - Database opening options including font loader settings
+     * @param view - Optional canvas to convert into (split view). Defaults to the active view.
      * @returns Promise that resolves to true if the document was successfully opened, false otherwise
      *
      * @example
@@ -715,32 +1029,44 @@ var AcApDocManager = /** @class */ (function () {
      * const success = await docManager.openDocument('drawing.dwg', fileContent, options);
      * ```
      */
-    AcApDocManager.prototype.openDocument = function (fileName, content, options) {
+    AcApDocManager.prototype.openDocument = function (fileName, content, options, view) {
         return __awaiter(this, void 0, void 0, function () {
-            var isSuccess, error_2;
+            var created, isSuccess, error_2;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         options = this.setOptions(options);
-                        this.onBeforeOpenDocument(options);
-                        _a.label = 1;
+                        return [4 /*yield*/, this.ensureOpenSession(view)];
                     case 1:
-                        _a.trys.push([1, 4, , 5]);
-                        return [4 /*yield*/, this._openFileProgress.beginOpen(this.context.doc.database)
-                            // TODO: The correct way is to create one new context instead of using old context and document
-                        ];
+                        created = _a.sent();
+                        this.beginOpenProgress();
+                        this.onBeforeOpenDocument(options, !created);
+                        _a.label = 2;
                     case 2:
+                        _a.trys.push([2, 7, , 10]);
+                        return [4 /*yield*/, this._openFileProgress.beginOpen(this.context.doc.database)];
+                    case 3:
                         _a.sent();
                         return [4 /*yield*/, this.context.doc.openDocument(fileName, content, options)];
-                    case 3:
+                    case 4:
                         isSuccess = _a.sent();
                         this.onAfterOpenDocument(isSuccess, options);
-                        return [2 /*return*/, isSuccess];
-                    case 4:
+                        if (!(!isSuccess && created)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this.closeFailedOpenSession()];
+                    case 5:
+                        _a.sent();
+                        _a.label = 6;
+                    case 6: return [2 /*return*/, isSuccess];
+                    case 7:
                         error_2 = _a.sent();
                         this._openFileProfiler.cancel();
-                        throw error_2;
-                    case 5: return [2 /*return*/];
+                        if (!created) return [3 /*break*/, 9];
+                        return [4 /*yield*/, this.closeFailedOpenSession()];
+                    case 8:
+                        _a.sent();
+                        _a.label = 9;
+                    case 9: throw error_2;
+                    case 10: return [2 /*return*/];
                 }
             });
         });
@@ -773,19 +1099,20 @@ var AcApDocManager = /** @class */ (function () {
      */
     AcApDocManager.prototype.loadOverlay = function (fileName_1, content_1) {
         return __awaiter(this, arguments, void 0, function (fileName, content, options) {
-            var db, fileExtension;
+            var targetView, dbOptions, db, fileExtension;
             var _this = this;
             var _a;
             if (options === void 0) { options = {}; }
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
+                        targetView = options.targetView, dbOptions = __rest(options, ["targetView"]);
                         db = new AcDbDatabase();
                         fileExtension = (_a = fileName.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLocaleLowerCase();
                         return [4 /*yield*/, acapWithSecondaryDatabase(db, function () { return __awaiter(_this, void 0, void 0, function () {
                                 return __generator(this, function (_a) {
                                     switch (_a.label) {
-                                        case 0: return [4 /*yield*/, db.read(content, __assign({ readOnly: true }, options), fileExtension === 'dwg' ? AcDbFileType.DWG : AcDbFileType.DXF)];
+                                        case 0: return [4 /*yield*/, db.read(content, __assign({ readOnly: true }, dbOptions), fileExtension === 'dwg' ? AcDbFileType.DWG : AcDbFileType.DXF)];
                                         case 1:
                                             _a.sent();
                                             return [2 /*return*/];
@@ -794,7 +1121,7 @@ var AcApDocManager = /** @class */ (function () {
                             }); })];
                     case 1:
                         _b.sent();
-                        return [2 /*return*/, this.registerOverlayDatabase(db)];
+                        return [2 /*return*/, this.registerOverlayDatabase(db, { targetView: targetView })];
                 }
             });
         });
@@ -804,19 +1131,25 @@ var AcApDocManager = /** @class */ (function () {
      *
      * Prefer this when the caller already loaded the secondary database (e.g.
      * XATTACH extents preview) to avoid reading the same file twice.
+     *
+     * @param db - Secondary database to draw into the target view.
+     * @param options.targetView - Canvas that receives the overlay (defaults to
+     *   the active view). Used by side-by-side → overlay compare without moving scenes.
      */
-    AcApDocManager.prototype.registerOverlayDatabase = function (db) {
+    AcApDocManager.prototype.registerOverlayDatabase = function (db, options) {
         return __awaiter(this, void 0, void 0, function () {
-            var view, layout, overlayId;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var view, layout, overlayId, session;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
-                        view = this.curView;
+                        view = (_a = options === null || options === void 0 ? void 0 : options.targetView) !== null && _a !== void 0 ? _a : this.curView;
                         return [4 /*yield*/, view.addOverlayEntities(db)];
                     case 1:
-                        layout = _a.sent();
+                        layout = _c.sent();
                         overlayId = "overlay-".concat(this._nextOverlayId++);
-                        this._overlays.set(overlayId, { db: db, layout: layout });
+                        session = (_b = this._sessions.find(function (s) { return s.context.view === view; })) !== null && _b !== void 0 ? _b : this._activeSession;
+                        session.overlays.set(overlayId, { db: db, layout: layout });
                         view.isDirty = true;
                         return [2 /*return*/, overlayId];
                 }
@@ -830,15 +1163,32 @@ var AcApDocManager = /** @class */ (function () {
      * @returns True when an overlay with the given id was found and removed.
      */
     AcApDocManager.prototype.removeOverlay = function (overlayId) {
-        var overlay = this._overlays.get(overlayId);
-        if (!overlay)
-            return false;
-        var view = this.curView;
-        view.cadScene.internalScene.remove(overlay.layout.internalObject);
-        overlay.layout.clear();
-        this._overlays.delete(overlayId);
-        view.isDirty = true;
-        return true;
+        var e_2, _a;
+        try {
+            for (var _b = __values(this._sessions), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var session = _c.value;
+                var overlay = session.overlays.get(overlayId);
+                if (!overlay)
+                    continue;
+                var scene = this.sessionCadScene(session);
+                scene.internalScene.remove(overlay.layout.internalObject);
+                overlay.layout.clear();
+                session.overlays.delete(overlayId);
+                if (!session.viewState) {
+                    ;
+                    session.context.view.isDirty = true;
+                }
+                return true;
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return false;
     };
     /**
      * Shows or hides a previously loaded overlay without removing it.
@@ -848,42 +1198,126 @@ var AcApDocManager = /** @class */ (function () {
      * @returns True when an overlay with the given id was found.
      */
     AcApDocManager.prototype.setOverlayVisible = function (overlayId, visible) {
-        var overlay = this._overlays.get(overlayId);
-        if (!overlay)
-            return false;
-        overlay.layout.visible = visible;
-        this.curView.isDirty = true;
-        return true;
+        var e_3, _a;
+        try {
+            for (var _b = __values(this._sessions), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var session = _c.value;
+                var overlay = session.overlays.get(overlayId);
+                if (!overlay)
+                    continue;
+                overlay.layout.visible = visible;
+                session.context.view.isDirty = true;
+                return true;
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return false;
     };
     /**
      * Removes all loaded overlays and disposes their geometry.
+     *
+     * @param view - When set, only overlays on sessions bound to this canvas are cleared.
      */
-    AcApDocManager.prototype.clearOverlays = function () {
-        var e_1, _a;
+    AcApDocManager.prototype.clearOverlays = function (view) {
+        var e_4, _a, e_5, _b;
+        var sessions = view
+            ? this._sessions.filter(function (s) { return s.context.view === view; })
+            : this._sessions;
         try {
-            for (var _b = __values(__spreadArray([], __read(this._overlays.keys()), false)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var overlayId = _c.value;
-                this.removeOverlay(overlayId);
+            for (var sessions_1 = __values(sessions), sessions_1_1 = sessions_1.next(); !sessions_1_1.done; sessions_1_1 = sessions_1.next()) {
+                var session = sessions_1_1.value;
+                try {
+                    for (var _c = (e_5 = void 0, __values(__spreadArray([], __read(session.overlays.keys()), false))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var overlayId = _d.value;
+                        this.removeOverlay(overlayId);
+                    }
+                }
+                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                    }
+                    finally { if (e_5) throw e_5.error; }
+                }
             }
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
         finally {
             try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                if (sessions_1_1 && !sessions_1_1.done && (_a = sessions_1.return)) _a.call(sessions_1);
             }
-            finally { if (e_1) throw e_1.error; }
+            finally { if (e_4) throw e_4.error; }
+        }
+    };
+    /**
+     * Ids of all currently loaded overlays on the active session (or a view).
+     *
+     * @param view - Optional canvas whose session overlays are listed.
+     */
+    AcApDocManager.prototype.getOverlayIds = function (view) {
+        if (!view) {
+            return Array.from(this._activeSession.overlays.keys());
         }
+        var session = this._sessions.find(function (s) { return s.context.view === view; });
+        return session ? Array.from(session.overlays.keys()) : [];
     };
     Object.defineProperty(AcApDocManager.prototype, "overlayIds", {
-        /**
-         * Ids of all currently loaded overlays.
-         */
+        /** @deprecated Prefer {@link getOverlayIds}. */
         get: function () {
-            return Array.from(this._overlays.keys());
+            return this.getOverlayIds();
         },
         enumerable: false,
         configurable: true
     });
+    /**
+     * Enables compare-display mode on a view (default: current view).
+     * Does not automatically color overlay layouts — use
+     * {@link setOverlayCompareDisplay} for those.
+     *
+     * @param options - Compare colors and per-entity role overrides.
+     * @param view - Target canvas; defaults to {@link curView}.
+     */
+    AcApDocManager.prototype.setCompareDisplay = function (options, view) {
+        var target = view !== null && view !== void 0 ? view : this.curView;
+        target.setCompareDisplay(options);
+    };
+    /**
+     * Applies compare-display coloring to one overlay layout.
+     *
+     * @param overlayId - Id returned by {@link loadOverlay} / {@link registerOverlayDatabase}.
+     * @param options - Compare colors and per-entity role overrides.
+     * @param view - Canvas that owns the overlay; omitted to search all sessions.
+     * @returns `true` when the overlay id was found.
+     */
+    AcApDocManager.prototype.setOverlayCompareDisplay = function (overlayId, options, view) {
+        var e_6, _a;
+        var _b;
+        try {
+            for (var _c = __values(this._sessions), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var session = _d.value;
+                var overlay = session.overlays.get(overlayId);
+                if (!overlay)
+                    continue;
+                var target = (_b = view !== null && view !== void 0 ? view : session.context.view) !== null && _b !== void 0 ? _b : this.curView;
+                target.setCompareDisplay(options, overlay.layout);
+                return true;
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        return false;
+    };
     /**
      * Returns the rendered layout for a loaded overlay, if any.
      *
@@ -891,14 +1325,29 @@ var AcApDocManager = /** @class */ (function () {
      * geometry without registering the layout in {@link AcTrScene}.
      */
     AcApDocManager.prototype.getOverlayLayout = function (overlayId) {
-        var _a;
-        return (_a = this._overlays.get(overlayId)) === null || _a === void 0 ? void 0 : _a.layout;
+        var e_7, _a;
+        try {
+            for (var _b = __values(this._sessions), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var session = _c.value;
+                var overlay = session.overlays.get(overlayId);
+                if (overlay)
+                    return overlay.layout;
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        return undefined;
     };
     /**
      * Creates a new CAD document from the default ISO drawing template.
      *
-     * This method loads the predefined template (`acadiso.dxf`) from {@link baseUrl}
-     * and replaces the current document in write mode with default open options.
+     * Loads `acadiso.dxf` into a new document session (or reuses the current
+     * unused Untitled). The new drawing is presented as unsaved.
      *
      * @param options - Optional database opening options merged with write mode
      * @returns Promise that resolves to true if the document was successfully created
@@ -910,7 +1359,7 @@ var AcApDocManager = /** @class */ (function () {
      */
     AcApDocManager.prototype.newDocument = function (options) {
         return __awaiter(this, void 0, void 0, function () {
-            var baseUrl, templateUrl, openOptions, isSuccess;
+            var baseUrl, templateUrl, openOptions, created, isSuccess;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -919,18 +1368,27 @@ var AcApDocManager = /** @class */ (function () {
                             : "".concat(this.baseUrl, "/");
                         templateUrl = "".concat(baseUrl).concat(DEFAULT_NEW_DRAWING_TEMPLATE);
                         openOptions = this.setOptions(__assign(__assign({}, options), { mode: AcEdOpenMode.Write }));
-                        this.onBeforeOpenDocument(openOptions);
-                        return [4 /*yield*/, this._openFileProgress.beginOpen(this.context.doc.database)];
+                        return [4 /*yield*/, this.ensureOpenSession()];
                     case 1:
+                        created = _a.sent();
+                        this.beginOpenProgress();
+                        this.onBeforeOpenDocument(openOptions, !created);
+                        return [4 /*yield*/, this._openFileProgress.beginOpen(this.context.doc.database)];
+                    case 2:
                         _a.sent();
                         return [4 /*yield*/, this.context.doc.openUri(templateUrl, openOptions)];
-                    case 2:
+                    case 3:
                         isSuccess = _a.sent();
                         if (isSuccess) {
                             this.context.doc.resetNewDocumentIdentity();
                         }
                         this.onAfterOpenDocument(isSuccess, openOptions);
-                        return [2 /*return*/, isSuccess];
+                        if (!(!isSuccess && created)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.closeFailedOpenSession()];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5: return [2 /*return*/, isSuccess];
                 }
             });
         });
@@ -1062,6 +1520,7 @@ var AcApDocManager = /** @class */ (function () {
         addSystemCommand('arc', 'arc', new AcApArcCmd());
         addSystemCommand('cachefont', 'cachefont', new AcApCacheFontCmd());
         addSystemCommand('circle', 'circle', new AcApCircleCmd());
+        addSystemCommand('close', 'close', new AcApCloseCmd());
         addSystemCommand('cdxf', 'cdxf', new AcApConvertToDxfCmd());
         addSystemCommand('pngout', 'pngout', new AcApConvertToPngCmd());
         addSystemCommand('entout', 'entout', new AcApEntityPreviewCmd());
@@ -1407,9 +1866,9 @@ var AcApDocManager = /** @class */ (function () {
      * Sets up the active layout block table record ID and model space block table
      * record ID based on the current document's space configuration.
      */
-    AcApDocManager.prototype.setActiveLayout = function () {
-        var currentView = this.curView;
-        var db = this.curDocument.database;
+    AcApDocManager.prototype.setActiveLayout = function (view, database) {
+        var currentView = view !== null && view !== void 0 ? view : this.curView;
+        var db = database !== null && database !== void 0 ? database : this.curDocument.database;
         currentView.activeLayoutBtrId = db.currentSpaceId;
         currentView.modelSpaceBtrId = db.tables.blockTable.modelSpace.objectId;
     };
@@ -1421,23 +1880,29 @@ var AcApDocManager = /** @class */ (function () {
      *
      * @protected
      */
-    AcApDocManager.prototype.onBeforeOpenDocument = function (options) {
+    AcApDocManager.prototype.onBeforeOpenDocument = function (options, replaceCurrent) {
         var _a, _b;
+        if (replaceCurrent === void 0) { replaceCurrent = true; }
         this.events.documentToBeOpened.dispatch({
             doc: this.context.doc,
             mode: this.getDocumentEventMode(options)
         });
-        // Drop xref sessions first so their overlay ids are removed via unload.
-        AcApXrefManager.instance.clearAll();
-        this.clearOverlays();
-        this.curView.bindDrawDatabase(this.context.doc.database);
-        this.curView.progressiveRendering =
+        if (replaceCurrent) {
+            // Drop xref sessions first so their overlay ids are removed via unload.
+            AcApXrefManager.instance.clearAll();
+            this.clearOverlays();
+            // Drop overlay / markup history before view.clear() disposes HTML.
+            resetMeasurementSession();
+            resetMarkupSession();
+            this.openProgressView.clear();
+        }
+        this.openProgressView.bindDrawDatabase(this.context.doc.database);
+        // Progressive convert/paint is gated by this flag (time-sliced yields in
+        // batchConvert). Camera auto-fit is started separately in onAfter when the
+        // open view mode uses zoom-to-fit — not for restored VPORT/saved views.
+        this.openProgressView.progressiveRendering =
             (_a = options === null || options === void 0 ? void 0 : options.progressiveRendering) !== null && _a !== void 0 ? _a : false;
         this._openFileProgress.setSeeThroughOverlay((_b = options === null || options === void 0 ? void 0 : options.progressiveRendering) !== null && _b !== void 0 ? _b : false);
-        // Drop overlay / markup history before view.clear() disposes HTML.
-        resetMeasurementSession();
-        resetMarkupSession();
-        this.curView.clear();
         // OPENPROF: start stage timings before db.read / entity flush.
         this._openFileProfiler.begin(this.context.doc.database);
     };
@@ -1459,17 +1924,19 @@ var AcApDocManager = /** @class */ (function () {
      * @protected
      */
     AcApDocManager.prototype.onAfterOpenDocument = function (isSuccess, options) {
-        var _a;
+        var _a, _b;
         var recoveredPartialContent = !isSuccess && this.hasRecoverablePartialContent();
         if (isSuccess || recoveredPartialContent) {
-            this.context.doc.destroy();
-            var doc = this.context.doc;
+            var session = (_a = this._openingSession) !== null && _a !== void 0 ? _a : this._activeSession;
+            var view = session.context.view;
+            session.doc.destroy();
+            var doc = session.doc;
             this.events.documentActivated.dispatch({
                 doc: doc,
                 mode: this.getDocumentEventMode(options)
             });
-            this.setActiveLayout();
-            this.curView.syncDisplaySysVars(doc.database);
+            this.setActiveLayout(view, doc.database);
+            view.syncDisplaySysVars(doc.database);
             var db = doc.database;
             // View framing at document open time (see `openViewMode`):
             //
@@ -1502,8 +1969,7 @@ var AcApDocManager = /** @class */ (function () {
             var activeLayout = acdbHostApplicationServices().layoutManager.getActiveLayout(db);
             var layoutLimits = activeLayout === null || activeLayout === void 0 ? void 0 : activeLayout.limits;
             var openViewMode = this.resolveOpenViewMode(options);
-            var view = this.curView;
-            var progressiveRendering = (_a = options === null || options === void 0 ? void 0 : options.progressiveRendering) !== null && _a !== void 0 ? _a : false;
+            var progressiveRendering = (_b = options === null || options === void 0 ? void 0 : options.progressiveRendering) !== null && _b !== void 0 ? _b : false;
             if (isPaperSpaceActive && layoutLimits && !layoutLimits.isEmpty()) {
                 view.zoomTo(layoutLimits);
             }
@@ -1545,14 +2011,13 @@ var AcApDocManager = /** @class */ (function () {
             // state on this layout. Cast is intentional: `setActiveLayout`
             // above relies on `curView` being an `AcTrView2d`, and the
             // markLayoutAsInitialized method is part of that contract.
-            ;
-            this.curView.markLayoutAsInitialized(db.currentSpaceId);
+            view.markLayoutAsInitialized(db.currentSpaceId);
             // OPENPROF: db.read is done; wait for batchConvert to drain, then print.
             this._openFileProfiler.markReadCompleteAndScheduleReport(view);
         }
         else {
             this._openFileProfiler.cancel();
-            this.curView.endProgressiveOpenFit();
+            this.openProgressView.endProgressiveOpenFit();
             this.regen();
         }
     };
@@ -1591,7 +2056,8 @@ var AcApDocManager = /** @class */ (function () {
      * @protected
      */
     AcApDocManager.prototype.hasRecoverablePartialContent = function () {
-        var db = this.context.doc.database;
+        var _a;
+        var db = ((_a = this._openingSession) !== null && _a !== void 0 ? _a : this._activeSession).doc.database;
         // `db.extents` comes from the DWG/DXF header, and some DXF files omit it
         // entirely, leaving it empty even when entities parsed successfully. Check
         // for actual entities in model space first, and only fall back to the
@@ -1685,6 +2151,60 @@ var AcApDocManager = /** @class */ (function () {
     AcApDocManager.prototype.showBusyIndicator = function (message) {
         this._busyIndicator.show(message);
     };
+    /**
+     * Moves busy/open-file overlays onto `host`.
+     *
+     * In split view the host is overridden to the canvas being opened or focused.
+     *
+     * @param host - Default overlay parent when not in split view.
+     */
+    AcApDocManager.prototype.setBusyIndicatorHost = function (host) {
+        this._busyIndicatorHost = host;
+        this.syncProgressOverlayHost();
+    };
+    Object.defineProperty(AcApDocManager.prototype, "openProgressView", {
+        /**
+         * Pins progress overlays to the canvas being opened, or the active canvas
+         * when a split view exists.
+         */
+        get: function () {
+            var _a, _b;
+            return (_b = (_a = this._openingSession) === null || _a === void 0 ? void 0 : _a.context.view) !== null && _b !== void 0 ? _b : this.curView;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Pins the open-file overlay to the session that is currently reading a file.
+     */
+    AcApDocManager.prototype.beginOpenProgress = function () {
+        this._openingSession = this._activeSession;
+        this.syncProgressOverlayHost();
+    };
+    /**
+     * Releases the open-file overlay pin after the spinner hides.
+     */
+    AcApDocManager.prototype.onOpenProgressHidden = function () {
+        var opening = this._openingSession;
+        this._openingSession = undefined;
+        if (opening &&
+            this._sessions.includes(opening) &&
+            opening !== this._activeSession) {
+            opening.context.suspend();
+        }
+        this.syncProgressOverlayHost();
+    };
+    /**
+     * Pins progress overlays to the canvas being opened when a split view exists.
+     *
+     * @param view - Canvas whose container receives the overlay.
+     */
+    AcApDocManager.prototype.syncProgressOverlayHost = function (view) {
+        if (view === void 0) { view = this.openProgressView; }
+        var host = this._splitView ? view.container : this._busyIndicatorHost;
+        this._openFileProgress.setHost(host);
+        this._busyIndicator.setHost(host);
+    };
     /**
      * Hides the spinner overlay shown by {@link showBusyIndicator}.
      *
@@ -1793,6 +2313,172 @@ var AcApDocManager = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Forwards database open-progress events to the overlay and header sysvars.
+     *
+     * @param doc - Document whose `openProgress` events should drive the overlay.
+     */
+    AcApDocManager.prototype.bindOpenProgress = function (doc) {
+        var _this = this;
+        doc.database.events.openProgress.addEventListener(function (args) {
+            var _a;
+            _this._openFileProgress.handle({
+                database: doc.database,
+                percentage: args.percentage,
+                stage: args.stage,
+                subStage: args.subStage,
+                subStageStatus: args.subStageStatus,
+                data: args.data
+            });
+            if (args.subStage !== 'HEADER') {
+                return;
+            }
+            var session = _this._sessions.find(function (item) { return item.doc === doc; });
+            var view = (_a = session === null || session === void 0 ? void 0 : session.context.view) !== null && _a !== void 0 ? _a : _this.curView;
+            view.ltscale = doc.database.ltscale;
+            view.celtscale = doc.database.celtscale;
+            view.renderer.showLineWeight = doc.database.lwdisplay;
+        });
+    };
+    /**
+     * Parks the live view onto the active session so another document can take the canvas.
+     */
+    AcApDocManager.prototype.parkActiveSession = function () {
+        this._activeSession.context.suspend();
+        this._activeSession.viewState = this.curView.captureSessionState();
+    };
+    /**
+     * Reuses an Untitled on `targetView` when it has no file identity and no
+     * entities; otherwise creates a new session on that view.
+     *
+     * When `targetView` is a different canvas (split comparison), the current
+     * view keeps rendering — GPU scenes are never moved between renderers.
+     *
+     * @param targetView - Canvas that will receive the open; defaults to {@link curView}.
+     * @returns True when a new session was created.
+     */
+    AcApDocManager.prototype.ensureOpenSession = function (targetView) {
+        return __awaiter(this, void 0, void 0, function () {
+            var view, occupant, doc, context, session;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        view = targetView !== null && targetView !== void 0 ? targetView : this.curView;
+                        if (view === this.curView && this.curDocument.isReusableUntitled) {
+                            return [2 /*return*/, false];
+                        }
+                        occupant = this._sessions.find(function (session) { return session.context.view === view; });
+                        if (!(occupant === null || occupant === void 0 ? void 0 : occupant.doc.isReusableUntitled)) return [3 /*break*/, 3];
+                        if (!(occupant !== this._activeSession)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.activateDocument(occupant.doc)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/, false];
+                    case 3: return [4 /*yield*/, this._commandManager.cancelActive()];
+                    case 4:
+                        _a.sent();
+                        this._activeSession.context.suspend();
+                        if (view === this.curView) {
+                            this._activeSession.viewState = this.curView.beginNewSession();
+                        }
+                        doc = new AcApDocument();
+                        context = new AcApContext(view, doc);
+                        session = new AcApDocSession("doc-".concat(this._nextSessionId++), context);
+                        this._sessions.push(session);
+                        this._activeSession = session;
+                        acapBindMarkupSession(session.id);
+                        acdbHostApplicationServices().workingDatabase = doc.database;
+                        this._pluginManager.setContext(context);
+                        this.bindOpenProgress(doc);
+                        this.events.documentCreated.dispatch({
+                            doc: doc,
+                            mode: doc.openMode
+                        });
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    /**
+     * Drops a session created for an open that failed before activation completed.
+     */
+    AcApDocManager.prototype.closeFailedOpenSession = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this._sessions.length <= 1) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.closeDocument(this.curDocument)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Replaces the last remaining session with a fresh Untitled drawing.
+     *
+     * @param session - The only remaining session to recycle.
+     */
+    AcApDocManager.prototype.resetActiveSessionToUntitled = function (session) {
+        var oldDoc = session.doc;
+        var oldId = session.id;
+        AcApXrefManager.instance.clearAll();
+        this.clearOverlays();
+        resetMeasurementSession();
+        resetMarkupSession();
+        this.curView.clear();
+        session.context.dispose();
+        oldDoc.destroy();
+        acapDisposeMarkupSession(oldId);
+        var doc = new AcApDocument();
+        var context = new AcApContext(this.curView, doc);
+        var replacement = new AcApDocSession("doc-".concat(this._nextSessionId++), context);
+        this._sessions = [replacement];
+        this._activeSession = replacement;
+        acapBindMarkupSession(replacement.id);
+        acdbHostApplicationServices().workingDatabase = doc.database;
+        this._pluginManager.setContext(context);
+        this.bindOpenProgress(doc);
+        this.curView.bindDrawDatabase(doc.database);
+    };
+    /**
+     * Removes overlay layouts belonging to a session being closed.
+     *
+     * @param session - Session whose overlays should be disposed.
+     */
+    AcApDocManager.prototype.clearSessionOverlays = function (session) {
+        var e_8, _a;
+        var scene = this.sessionCadScene(session);
+        try {
+            for (var _b = __values(session.overlays.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var overlay = _c.value;
+                scene.internalScene.remove(overlay.layout.internalObject);
+                overlay.layout.clear();
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        session.overlays.clear();
+    };
+    /**
+     * Scene that currently owns `session`'s overlay layouts.
+     * Parked sessions keep overlays on {@link AcApDocSession.viewState}; live
+     * split-view sessions keep them on their own canvas, not {@link curView}.
+     */
+    AcApDocManager.prototype.sessionCadScene = function (session) {
+        var _a, _b;
+        return ((_b = (_a = session.viewState) === null || _a === void 0 ? void 0 : _a.scene) !== null && _b !== void 0 ? _b : session.context.view.cadScene);
+    };
     return AcApDocManager;
 }());
 export { AcApDocManager };