@actual-app/api 26.2.0-nightly.20260114 → 26.2.0-nightly.20260115

package/dist/app/bundle.api.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _g, _Stack_constructing, _LRUCache_instances, _LRUCache_max, _LRUCache_maxSize, _LRUCache_dispose, _LRUCache_onInsert, _LRUCache_disposeAfter, _LRUCache_fetchMethod, _LRUCache_memoMethod, _LRUCache_perf, _LRUCache_size, _LRUCache_calculatedSize, _LRUCache_keyMap, _LRUCache_keyList, _LRUCache_valList, _LRUCache_next, _LRUCache_prev, _LRUCache_head, _LRUCache_tail, _LRUCache_free, _LRUCache_disposed, _LRUCache_sizes, _LRUCache_starts, _LRUCache_ttls, _LRUCache_hasDispose, _LRUCache_hasFetchMethod, _LRUCache_hasDisposeAfter, _LRUCache_hasOnInsert, _LRUCache_initializeTTLTracking, _LRUCache_updateItemAge, _LRUCache_statusTTL, _LRUCache_setItemTTL, _LRUCache_isStale, _LRUCache_initializeSizeTracking, _LRUCache_removeItemSize, _LRUCache_addItemSize, _LRUCache_requireSize, _LRUCache_indexes, _LRUCache_rindexes, _LRUCache_isValidIndex, _LRUCache_evict, _LRUCache_backgroundFetch, _LRUCache_isBackgroundFetch, _LRUCache_connect, _LRUCache_moveToTail, _LRUCache_delete, _LRUCache_clear, _h;
+var _g, _Stack_constructing, _LRUCache_instances, _LRUCache_max, _LRUCache_maxSize, _LRUCache_dispose, _LRUCache_onInsert, _LRUCache_disposeAfter, _LRUCache_fetchMethod, _LRUCache_memoMethod, _LRUCache_perf, _LRUCache_size, _LRUCache_calculatedSize, _LRUCache_keyMap, _LRUCache_keyList, _LRUCache_valList, _LRUCache_next, _LRUCache_prev, _LRUCache_head, _LRUCache_tail, _LRUCache_free, _LRUCache_disposed, _LRUCache_sizes, _LRUCache_starts, _LRUCache_ttls, _LRUCache_autopurgeTimers, _LRUCache_hasDispose, _LRUCache_hasFetchMethod, _LRUCache_hasDisposeAfter, _LRUCache_hasOnInsert, _LRUCache_initializeTTLTracking, _LRUCache_updateItemAge, _LRUCache_statusTTL, _LRUCache_setItemTTL, _LRUCache_isStale, _LRUCache_initializeSizeTracking, _LRUCache_removeItemSize, _LRUCache_addItemSize, _LRUCache_requireSize, _LRUCache_indexes, _LRUCache_rindexes, _LRUCache_isValidIndex, _LRUCache_evict, _LRUCache_backgroundFetch, _LRUCache_isBackgroundFetch, _LRUCache_connect, _LRUCache_moveToTail, _LRUCache_delete, _LRUCache_clear, _h;
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const fs$1 = require("fs");
 const path = require("path");
@@ -4272,6 +4272,7 @@ class LRUCache {
             // properties
             starts: __classPrivateFieldGet(c, _LRUCache_starts, "f"),
             ttls: __classPrivateFieldGet(c, _LRUCache_ttls, "f"),
+            autopurgeTimers: __classPrivateFieldGet(c, _LRUCache_autopurgeTimers, "f"),
             sizes: __classPrivateFieldGet(c, _LRUCache_sizes, "f"),
             keyMap: __classPrivateFieldGet(c, _LRUCache_keyMap, "f"),
             keyList: __classPrivateFieldGet(c, _LRUCache_keyList, "f"),
@@ -4372,6 +4373,7 @@ class LRUCache {
         _LRUCache_sizes.set(this, void 0);
         _LRUCache_starts.set(this, void 0);
         _LRUCache_ttls.set(this, void 0);
+        _LRUCache_autopurgeTimers.set(this, void 0);
         _LRUCache_hasDispose.set(this, void 0);
         _LRUCache_hasFetchMethod.set(this, void 0);
         _LRUCache_hasDisposeAfter.set(this, void 0);
@@ -4592,15 +4594,21 @@ class LRUCache {
      * Iterating over the cache itself yields the same results as
      * {@link LRUCache.entries}
      */
-    [(_LRUCache_max = new WeakMap(), _LRUCache_maxSize = new WeakMap(), _LRUCache_dispose = new WeakMap(), _LRUCache_onInsert = new WeakMap(), _LRUCache_disposeAfter = new WeakMap(), _LRUCache_fetchMethod = new WeakMap(), _LRUCache_memoMethod = new WeakMap(), _LRUCache_perf = new WeakMap(), _LRUCache_size = new WeakMap(), _LRUCache_calculatedSize = new WeakMap(), _LRUCache_keyMap = new WeakMap(), _LRUCache_keyList = new WeakMap(), _LRUCache_valList = new WeakMap(), _LRUCache_next = new WeakMap(), _LRUCache_prev = new WeakMap(), _LRUCache_head = new WeakMap(), _LRUCache_tail = new WeakMap(), _LRUCache_free = new WeakMap(), _LRUCache_disposed = new WeakMap(), _LRUCache_sizes = new WeakMap(), _LRUCache_starts = new WeakMap(), _LRUCache_ttls = new WeakMap(), _LRUCache_hasDispose = new WeakMap(), _LRUCache_hasFetchMethod = new WeakMap(), _LRUCache_hasDisposeAfter = new WeakMap(), _LRUCache_hasOnInsert = new WeakMap(), _LRUCache_updateItemAge = new WeakMap(), _LRUCache_statusTTL = new WeakMap(), _LRUCache_setItemTTL = new WeakMap(), _LRUCache_isStale = new WeakMap(), _LRUCache_removeItemSize = new WeakMap(), _LRUCache_addItemSize = new WeakMap(), _LRUCache_requireSize = new WeakMap(), _LRUCache_instances = new WeakSet(), _LRUCache_initializeTTLTracking = function _LRUCache_initializeTTLTracking() {
+    [(_LRUCache_max = new WeakMap(), _LRUCache_maxSize = new WeakMap(), _LRUCache_dispose = new WeakMap(), _LRUCache_onInsert = new WeakMap(), _LRUCache_disposeAfter = new WeakMap(), _LRUCache_fetchMethod = new WeakMap(), _LRUCache_memoMethod = new WeakMap(), _LRUCache_perf = new WeakMap(), _LRUCache_size = new WeakMap(), _LRUCache_calculatedSize = new WeakMap(), _LRUCache_keyMap = new WeakMap(), _LRUCache_keyList = new WeakMap(), _LRUCache_valList = new WeakMap(), _LRUCache_next = new WeakMap(), _LRUCache_prev = new WeakMap(), _LRUCache_head = new WeakMap(), _LRUCache_tail = new WeakMap(), _LRUCache_free = new WeakMap(), _LRUCache_disposed = new WeakMap(), _LRUCache_sizes = new WeakMap(), _LRUCache_starts = new WeakMap(), _LRUCache_ttls = new WeakMap(), _LRUCache_autopurgeTimers = new WeakMap(), _LRUCache_hasDispose = new WeakMap(), _LRUCache_hasFetchMethod = new WeakMap(), _LRUCache_hasDisposeAfter = new WeakMap(), _LRUCache_hasOnInsert = new WeakMap(), _LRUCache_updateItemAge = new WeakMap(), _LRUCache_statusTTL = new WeakMap(), _LRUCache_setItemTTL = new WeakMap(), _LRUCache_isStale = new WeakMap(), _LRUCache_removeItemSize = new WeakMap(), _LRUCache_addItemSize = new WeakMap(), _LRUCache_requireSize = new WeakMap(), _LRUCache_instances = new WeakSet(), _LRUCache_initializeTTLTracking = function _LRUCache_initializeTTLTracking() {
         const ttls = new ZeroArray(__classPrivateFieldGet(this, _LRUCache_max, "f"));
         const starts = new ZeroArray(__classPrivateFieldGet(this, _LRUCache_max, "f"));
         __classPrivateFieldSet(this, _LRUCache_ttls, ttls, "f");
         __classPrivateFieldSet(this, _LRUCache_starts, starts, "f");
+        const purgeTimers = this.ttlAutopurge ? new Array(__classPrivateFieldGet(this, _LRUCache_max, "f")) : void 0;
+        __classPrivateFieldSet(this, _LRUCache_autopurgeTimers, purgeTimers, "f");
         __classPrivateFieldSet(this, _LRUCache_setItemTTL, (index, ttl, start = __classPrivateFieldGet(this, _LRUCache_perf, "f").now()) => {
             starts[index] = ttl !== 0 ? start : 0;
             ttls[index] = ttl;
-            if (ttl !== 0 && this.ttlAutopurge) {
+            if (purgeTimers?.[index]) {
+                clearTimeout(purgeTimers[index]);
+                purgeTimers[index] = void 0;
+            }
+            if (ttl !== 0 && purgeTimers) {
                 const t2 = setTimeout(() => {
                     if (__classPrivateFieldGet(this, _LRUCache_isStale, "f").call(this, index)) {
                         __classPrivateFieldGet(this, _LRUCache_instances, "m", _LRUCache_delete).call(this, __classPrivateFieldGet(this, _LRUCache_keyList, "f")[index], "expire");
@@ -4609,6 +4617,7 @@ class LRUCache {
                 if (t2.unref) {
                     t2.unref();
                 }
+                purgeTimers[index] = t2;
             }
         }, "f");
         __classPrivateFieldSet(this, _LRUCache_updateItemAge, (index) => {
@@ -5280,6 +5289,10 @@ _h = Symbol.toStringTag, _LRUCache_evict = function _LRUCache_evict(free) {
         }
     }
     __classPrivateFieldGet(this, _LRUCache_removeItemSize, "f").call(this, head);
+    if (__classPrivateFieldGet(this, _LRUCache_autopurgeTimers, "f")?.[head]) {
+        clearTimeout(__classPrivateFieldGet(this, _LRUCache_autopurgeTimers, "f")[head]);
+        __classPrivateFieldGet(this, _LRUCache_autopurgeTimers, "f")[head] = void 0;
+    }
     if (free) {
         __classPrivateFieldGet(this, _LRUCache_keyList, "f")[head] = void 0;
         __classPrivateFieldGet(this, _LRUCache_valList, "f")[head] = void 0;
@@ -5433,6 +5446,10 @@ _h = Symbol.toStringTag, _LRUCache_evict = function _LRUCache_evict(free) {
     if (__classPrivateFieldGet(this, _LRUCache_size, "f") !== 0) {
         const index = __classPrivateFieldGet(this, _LRUCache_keyMap, "f").get(k);
         if (index !== void 0) {
+            if (__classPrivateFieldGet(this, _LRUCache_autopurgeTimers, "f")?.[index]) {
+                clearTimeout(__classPrivateFieldGet(this, _LRUCache_autopurgeTimers, "f")?.[index]);
+                __classPrivateFieldGet(this, _LRUCache_autopurgeTimers, "f")[index] = void 0;
+            }
             deleted = true;
             if (__classPrivateFieldGet(this, _LRUCache_size, "f") === 1) {
                 __classPrivateFieldGet(this, _LRUCache_instances, "m", _LRUCache_clear).call(this, reason);
@@ -5501,6 +5518,11 @@ _h = Symbol.toStringTag, _LRUCache_evict = function _LRUCache_evict(free) {
     if (__classPrivateFieldGet(this, _LRUCache_ttls, "f") && __classPrivateFieldGet(this, _LRUCache_starts, "f")) {
         __classPrivateFieldGet(this, _LRUCache_ttls, "f").fill(0);
         __classPrivateFieldGet(this, _LRUCache_starts, "f").fill(0);
+        for (const t2 of __classPrivateFieldGet(this, _LRUCache_autopurgeTimers, "f") ?? []) {
+            if (t2 !== void 0)
+                clearTimeout(t2);
+        }
+        __classPrivateFieldGet(this, _LRUCache_autopurgeTimers, "f")?.fill(void 0);
     }
     if (__classPrivateFieldGet(this, _LRUCache_sizes, "f")) {
         __classPrivateFieldGet(this, _LRUCache_sizes, "f").fill(0);
@@ -5725,7 +5747,7 @@ const millisecondsInDay = 864e5;
 const millisecondsInMinute = 6e4;
 const millisecondsInHour = 36e5;
 const millisecondsInSecond = 1e3;
-const constructFromSymbol = Symbol.for("constructDateFrom");
+const constructFromSymbol = /* @__PURE__ */ Symbol.for("constructDateFrom");
 function constructFrom(date, value) {
     if (typeof date === "function")
         return date(value);
@@ -9879,7 +9901,7 @@ var postProcessor = {
         return value;
     }
 };
-const PATH_KEY = Symbol("i18next/PATH_KEY");
+const PATH_KEY = /* @__PURE__ */ Symbol("i18next/PATH_KEY");
 function createProxy() {
     const state = [];
     const handler = /* @__PURE__ */ Object.create(null);
@@ -10520,9 +10542,6 @@ class PluralResolver {
         this.logger = baseLogger.create("pluralResolver");
         this.pluralRulesCache = {};
     }
-    addRule(lng, obj) {
-        this.rules[lng] = obj;
-    }
     clearCache() {
         this.pluralRulesCache = {};
     }
@@ -11302,6 +11321,9 @@ class I18n extends EventEmitter {
         if (options.nsSeparator !== void 0) {
             this.options.userDefinedNsSeparator = options.nsSeparator;
         }
+        if (typeof this.options.overloadTranslationOptionHandler !== "function") {
+            this.options.overloadTranslationOptionHandler = defOpts.overloadTranslationOptionHandler;
+        }
         const createClassOnDemand = (ClassOrObject) => {
             if (!ClassOrObject)
                 return null;
@@ -11780,6 +11802,19 @@ class I18n extends EventEmitter {
             clone.store = new ResourceStore(clonedData, mergedOptions);
             clone.services.resourceStore = clone.store;
         }
+        if (options.interpolation) {
+            const defOpts = get$4();
+            const mergedInterpolation = {
+                ...defOpts.interpolation,
+                ...this.options.interpolation,
+                ...options.interpolation
+            };
+            const mergedForInterpolator = {
+                ...mergedOptions,
+                interpolation: mergedInterpolation
+            };
+            clone.services.interpolator = new Interpolator(mergedForInterpolator);
+        }
         clone.translator = new Translator(clone.services, mergedOptions);
         clone.translator.on("*", (event, ...args) => {
             clone.emit(event, ...args);
@@ -66138,7 +66173,7 @@ class CellAddress {
         return new CellAddress(this.col, this.row, this.type, sheet);
     }
     isInvalid(baseAddress) {
-        return invalidSimpleCellAddress(this.toSimpleCellAddress(baseAddress));
+        return isColOrRowInvalid(this.toSimpleCellAddress(baseAddress));
     }
     shiftRelativeDimensions(toRight, toBottom) {
         const col = this.isColumnAbsolute() ? this.col : this.col + toRight;
@@ -66169,7 +66204,7 @@ class CellAddress {
     }
     unparse(baseAddress) {
         const simpleAddress = this.toSimpleCellAddress(baseAddress);
-        if (invalidSimpleCellAddress(simpleAddress)) {
+        if (isColOrRowInvalid(simpleAddress)) {
             return void 0;
         }
         const column = columnIndexToLabel(simpleAddress.col);
@@ -66202,17 +66237,18 @@ const addressRegex = new RegExp(`^(${SHEET_NAME_PATTERN})?(\\${ABSOLUTE_OPERATOR
 const columnRegex = new RegExp(`^(${SHEET_NAME_PATTERN})?(\\${ABSOLUTE_OPERATOR}?)([A-Za-z]+)$`);
 const rowRegex = new RegExp(`^(${SHEET_NAME_PATTERN})?(\\${ABSOLUTE_OPERATOR}?)([0-9]+)$`);
 const simpleSheetNameRegex = new RegExp(`^${UNQUOTED_SHEET_NAME_PATTERN}$`);
-const cellAddressFromString = (sheetMapping, stringAddress, baseAddress) => {
+const cellAddressFromString = (stringAddress, baseAddress, resolveSheetReference) => {
     const result = addressRegex.exec(stringAddress);
-    const col = columnLabelToIndex(result[6]);
-    let sheet = extractSheetNumber(result, sheetMapping);
-    if (sheet === void 0) {
+    if (!result) {
         return void 0;
     }
+    const col = columnLabelToIndex(result[6]);
+    const row = Number(result[8]) - 1;
+    const sheetName = extractSheetName(result);
+    const sheet = sheetNameToId(sheetName, resolveSheetReference);
     if (sheet === null) {
-        sheet = void 0;
+        return void 0;
     }
-    const row = Number(result[8]) - 1;
     if (result[5] === ABSOLUTE_OPERATOR && result[7] === ABSOLUTE_OPERATOR) {
         return CellAddress.absolute(col, row, sheet);
     }
@@ -66226,16 +66262,17 @@ const cellAddressFromString = (sheetMapping, stringAddress, baseAddress) => {
         return CellAddress.relative(col - baseAddress.col, row - baseAddress.row, sheet);
     }
 };
-const columnAddressFromString = (sheetMapping, stringAddress, baseAddress) => {
+const columnAddressFromString = (stringAddress, baseAddress, resolveSheetReference) => {
     const result = columnRegex.exec(stringAddress);
-    let sheet = extractSheetNumber(result, sheetMapping);
-    if (sheet === void 0) {
+    if (!result) {
         return void 0;
     }
+    const col = columnLabelToIndex(result[6]);
+    const sheetName = extractSheetName(result);
+    const sheet = sheetNameToId(sheetName, resolveSheetReference);
     if (sheet === null) {
-        sheet = void 0;
+        return void 0;
     }
-    const col = columnLabelToIndex(result[6]);
     if (result[5] === ABSOLUTE_OPERATOR) {
         return ColumnAddress.absolute(col, sheet);
     }
@@ -66243,16 +66280,17 @@ const columnAddressFromString = (sheetMapping, stringAddress, baseAddress) => {
         return ColumnAddress.relative(col - baseAddress.col, sheet);
     }
 };
-const rowAddressFromString = (sheetMapping, stringAddress, baseAddress) => {
+const rowAddressFromString = (stringAddress, baseAddress, resolveSheetReference) => {
     const result = rowRegex.exec(stringAddress);
-    let sheet = extractSheetNumber(result, sheetMapping);
-    if (sheet === void 0) {
+    if (!result) {
         return void 0;
     }
+    const row = Number(result[6]) - 1;
+    const sheetName = extractSheetName(result);
+    const sheet = sheetNameToId(sheetName, resolveSheetReference);
     if (sheet === null) {
-        sheet = void 0;
+        return void 0;
     }
-    const row = Number(result[6]) - 1;
     if (result[5] === ABSOLUTE_OPERATOR) {
         return RowAddress.absolute(row, sheet);
     }
@@ -66260,33 +66298,32 @@ const rowAddressFromString = (sheetMapping, stringAddress, baseAddress) => {
         return RowAddress.relative(row - baseAddress.row, sheet);
     }
 };
-const simpleCellAddressFromString = (sheetMapping, stringAddress, contextSheetId) => {
+const simpleCellAddressFromString = (resolveSheetReference, stringAddress, contextSheetId) => {
     const regExpExecArray = addressRegex.exec(stringAddress);
     if (!regExpExecArray) {
         return void 0;
     }
     const col = columnLabelToIndex(regExpExecArray[6]);
-    let sheet = extractSheetNumber(regExpExecArray, sheetMapping);
-    if (sheet === void 0) {
-        return void 0;
-    }
+    const row = Number(regExpExecArray[8]) - 1;
+    const sheetName = extractSheetName(regExpExecArray);
+    const sheet = sheetNameToId(sheetName, resolveSheetReference);
     if (sheet === null) {
-        sheet = contextSheetId;
+        return void 0;
     }
-    const row = Number(regExpExecArray[8]) - 1;
-    return simpleCellAddress(sheet, col, row);
+    const effectiveSheet = sheet === void 0 ? contextSheetId : sheet;
+    return simpleCellAddress(effectiveSheet, col, row);
 };
-const simpleCellRangeFromString = (sheetMapping, stringAddress, contextSheetId) => {
+const simpleCellRangeFromString = (resolveSheetReference, stringAddress, contextSheetId) => {
     const split2 = stringAddress.split(RANGE_OPERATOR);
     if (split2.length !== 2) {
         return void 0;
     }
     const [startString, endString] = split2;
-    const start = simpleCellAddressFromString(sheetMapping, startString, contextSheetId);
+    const start = simpleCellAddressFromString(resolveSheetReference, startString, contextSheetId);
     if (start === void 0) {
         return void 0;
     }
-    const end = simpleCellAddressFromString(sheetMapping, endString, start.sheet);
+    const end = simpleCellAddressFromString(resolveSheetReference, endString, start.sheet);
     if (end === void 0) {
         return void 0;
     }
@@ -66349,16 +66386,17 @@ function sheetIndexToString(sheetId, sheetMappingFn) {
         return `'${sheetName}'`;
     }
 }
-function extractSheetNumber(regexResult, sheetMapping) {
+function extractSheetName(regexResult) {
     var _a;
-    let maybeSheetName = (_a = regexResult[3]) !== null && _a !== void 0 ? _a : regexResult[2];
-    if (maybeSheetName) {
-        maybeSheetName = maybeSheetName.replace(/''/g, "'");
-        return sheetMapping(maybeSheetName);
-    }
-    else {
-        return null;
+    const maybeSheetName = (_a = regexResult[3]) !== null && _a !== void 0 ? _a : regexResult[2];
+    return maybeSheetName ? maybeSheetName.replace(/''/g, "'") : null;
+}
+function sheetNameToId(sheetName, resolveSheetReference) {
+    if (!sheetName) {
+        return void 0;
     }
+    const sheetId = resolveSheetReference(sheetName);
+    return sheetId === void 0 ? null : sheetId;
 }
 function isEmpty(arr) {
     return arr && arr.length === 0;
@@ -74847,11 +74885,12 @@ const buildLexerConfig = (config2) => {
     };
 };
 class FormulaParser extends EmbeddedActionsParser {
-    constructor(lexerConfig, sheetMapping) {
+    constructor(lexerConfig, resolveSheetReference) {
         super(lexerConfig.allTokens, {
             outputCst: false,
             maxLookahead: 7
         });
+        this.resolveSheetReference = resolveSheetReference;
         this.booleanExpressionOrEmpty = this.RULE("booleanExpressionOrEmpty", () => {
             return this.OR([{
                     ALT: () => this.SUBRULE(this.booleanExpression)
@@ -74902,8 +74941,8 @@ class FormulaParser extends EmbeddedActionsParser {
         this.columnRangeExpression = this.RULE("columnRangeExpression", () => {
             const range2 = this.CONSUME(ColumnRange);
             const [startImage, endImage] = range2.image.split(":");
-            const firstAddress = this.ACTION(() => columnAddressFromString(this.sheetMapping, startImage, this.formulaAddress));
-            const secondAddress = this.ACTION(() => columnAddressFromString(this.sheetMapping, endImage, this.formulaAddress));
+            const firstAddress = this.ACTION(() => columnAddressFromString(startImage, this.formulaAddress, this.resolveSheetReference));
+            const secondAddress = this.ACTION(() => columnAddressFromString(endImage, this.formulaAddress, this.resolveSheetReference));
             if (firstAddress === void 0 || secondAddress === void 0) {
                 return buildCellErrorAst(new CellError(ErrorType.REF));
             }
@@ -74919,8 +74958,8 @@ class FormulaParser extends EmbeddedActionsParser {
         this.rowRangeExpression = this.RULE("rowRangeExpression", () => {
             const range2 = this.CONSUME(RowRange);
             const [startImage, endImage] = range2.image.split(":");
-            const firstAddress = this.ACTION(() => rowAddressFromString(this.sheetMapping, startImage, this.formulaAddress));
-            const secondAddress = this.ACTION(() => rowAddressFromString(this.sheetMapping, endImage, this.formulaAddress));
+            const firstAddress = this.ACTION(() => rowAddressFromString(startImage, this.formulaAddress, this.resolveSheetReference));
+            const secondAddress = this.ACTION(() => rowAddressFromString(endImage, this.formulaAddress, this.resolveSheetReference));
             if (firstAddress === void 0 || secondAddress === void 0) {
                 return buildCellErrorAst(new CellError(ErrorType.REF));
             }
@@ -74936,7 +74975,7 @@ class FormulaParser extends EmbeddedActionsParser {
         this.cellReference = this.RULE("cellReference", () => {
             const cell = this.CONSUME(CellReference);
             const address = this.ACTION(() => {
-                return cellAddressFromString(this.sheetMapping, cell.image, this.formulaAddress);
+                return cellAddressFromString(cell.image, this.formulaAddress, this.resolveSheetReference);
             });
             if (address === void 0) {
                 return buildErrorWithRawInputAst(cell.image, new CellError(ErrorType.REF), cell.leadingWhitespace);
@@ -74952,10 +74991,10 @@ class FormulaParser extends EmbeddedActionsParser {
             var _a;
             const end = this.CONSUME(CellReference);
             const startAddress = this.ACTION(() => {
-                return cellAddressFromString(this.sheetMapping, start.image, this.formulaAddress);
+                return cellAddressFromString(start.image, this.formulaAddress, this.resolveSheetReference);
             });
             const endAddress = this.ACTION(() => {
-                return cellAddressFromString(this.sheetMapping, end.image, this.formulaAddress);
+                return cellAddressFromString(end.image, this.formulaAddress, this.resolveSheetReference);
             });
             if (startAddress === void 0 || endAddress === void 0) {
                 return this.ACTION(() => {
@@ -74981,7 +75020,7 @@ class FormulaParser extends EmbeddedActionsParser {
                         var _a;
                         const offsetProcedure = this.SUBRULE(this.offsetProcedureExpression);
                         const startAddress = this.ACTION(() => {
-                            return cellAddressFromString(this.sheetMapping, start.image, this.formulaAddress);
+                            return cellAddressFromString(start.image, this.formulaAddress, this.resolveSheetReference);
                         });
                         if (startAddress === void 0) {
                             return buildCellErrorAst(new CellError(ErrorType.REF));
@@ -75005,7 +75044,7 @@ class FormulaParser extends EmbeddedActionsParser {
         this.endRangeWithOffsetStartReference = this.RULE("endRangeWithOffsetStartReference", (start) => {
             const end = this.CONSUME(CellReference);
             const endAddress = this.ACTION(() => {
-                return cellAddressFromString(this.sheetMapping, end.image, this.formulaAddress);
+                return cellAddressFromString(end.image, this.formulaAddress, this.resolveSheetReference);
             });
             if (endAddress === void 0) {
                 return this.ACTION(() => {
@@ -75264,7 +75303,6 @@ class FormulaParser extends EmbeddedActionsParser {
             return this.SUBRULE(this.booleanExpression);
         });
         this.lexerConfig = lexerConfig;
-        this.sheetMapping = sheetMapping;
         this.formulaAddress = simpleCellAddress(0, 0, 0);
         this.performSelfAnalysis();
     }
@@ -75486,10 +75524,9 @@ class FormulaLexer {
     }
 }
 class Unparser {
-    constructor(config2, lexerConfig, sheetMappingFn, namedExpressions) {
+    constructor(config2, sheetMapping, namedExpressions) {
         this.config = config2;
-        this.lexerConfig = lexerConfig;
-        this.sheetMappingFn = sheetMappingFn;
+        this.sheetMapping = sheetMapping;
         this.namedExpressions = namedExpressions;
     }
     unparse(ast, address) {
@@ -75567,8 +75604,15 @@ class Unparser {
             }
         }
     }
+    /**
+     * Unparses a sheet name.
+     * @param {number} sheetId - the ID of the sheet
+     * @returns {string} the unparsed sheet name
+     */
     unparseSheetName(sheetId) {
-        const sheetName = sheetIndexToString(sheetId, this.sheetMappingFn);
+        const sheetName = sheetIndexToString(sheetId, (id2) => this.sheetMapping.getSheetNameOrThrowError(id2, {
+            includePlaceholders: true
+        }));
         if (sheetName === void 0) {
             throw new NoSheetWithIdError(sheetId);
         }
@@ -75596,14 +75640,14 @@ function formatNumber(number2, decimalSeparator) {
     return numericString.replace(".", decimalSeparator);
 }
 class ParserWithCaching {
-    constructor(config2, functionRegistry, sheetMapping) {
+    constructor(config2, functionRegistry, resolveSheetReference) {
         this.config = config2;
         this.functionRegistry = functionRegistry;
-        this.sheetMapping = sheetMapping;
+        this.resolveSheetReference = resolveSheetReference;
         this.statsCacheUsed = 0;
         this.lexerConfig = buildLexerConfig(config2);
         this.lexer = new FormulaLexer(this.lexerConfig);
-        this.formulaParser = new FormulaParser(this.lexerConfig, this.sheetMapping);
+        this.formulaParser = new FormulaParser(this.lexerConfig, this.resolveSheetReference);
         this.cache = new Cache(this.functionRegistry);
     }
     /**
@@ -75799,7 +75843,7 @@ class ParserWithCaching {
         while (idx < tokens.length) {
             const token = tokens[idx];
             if (tokenMatcher(token, CellReference)) {
-                const cellAddress = cellAddressFromString(this.sheetMapping, token.image, baseAddress);
+                const cellAddress = cellAddressFromString(token.image, baseAddress, this.resolveSheetReference);
                 if (cellAddress === void 0) {
                     hash = hash.concat(token.image);
                 }
@@ -75814,8 +75858,8 @@ class ParserWithCaching {
             }
             else if (tokenMatcher(token, ColumnRange)) {
                 const [start, end] = token.image.split(":");
-                const startAddress = columnAddressFromString(this.sheetMapping, start, baseAddress);
-                const endAddress = columnAddressFromString(this.sheetMapping, end, baseAddress);
+                const startAddress = columnAddressFromString(start, baseAddress, this.resolveSheetReference);
+                const endAddress = columnAddressFromString(end, baseAddress, this.resolveSheetReference);
                 if (startAddress === void 0 || endAddress === void 0) {
                     hash = hash.concat("!REF");
                 }
@@ -75825,8 +75869,8 @@ class ParserWithCaching {
             }
             else if (tokenMatcher(token, RowRange)) {
                 const [start, end] = token.image.split(":");
-                const startAddress = rowAddressFromString(this.sheetMapping, start, baseAddress);
-                const endAddress = rowAddressFromString(this.sheetMapping, end, baseAddress);
+                const startAddress = rowAddressFromString(start, baseAddress, this.resolveSheetReference);
+                const endAddress = rowAddressFromString(end, baseAddress, this.resolveSheetReference);
                 if (startAddress === void 0 || endAddress === void 0) {
                     hash = hash.concat("!REF");
                 }
@@ -76059,14 +76103,14 @@ const filterDependenciesOutOfScope = (deps) => {
             return true;
         }
         if (dep instanceof AbsoluteCellRange) {
-            return !(invalidSimpleCellAddress(dep.start) || invalidSimpleCellAddress(dep.end));
+            return !(isColOrRowInvalid(dep.start) || isColOrRowInvalid(dep.end));
         }
         else {
-            return !invalidSimpleCellAddress(dep);
+            return !isColOrRowInvalid(dep);
         }
     });
 };
-const EmptyValue = Symbol("Empty value");
+const EmptyValue = /* @__PURE__ */ Symbol("Empty value");
 function getRawValue(num2) {
     if (num2 instanceof RichNumber) {
         return num2.val;
@@ -76393,6 +76437,299 @@ class ContentChanges {
         });
     }
 }
+class InternalNamedExpression {
+    constructor(displayName, address, added, options) {
+        this.displayName = displayName;
+        this.address = address;
+        this.added = added;
+        this.options = options;
+    }
+    normalizeExpressionName() {
+        return this.displayName.toLowerCase();
+    }
+    copy() {
+        return new InternalNamedExpression(this.displayName, this.address, this.added, this.options);
+    }
+}
+class WorkbookStore {
+    constructor() {
+        this.mapping = /* @__PURE__ */ new Map();
+    }
+    has(expressionName) {
+        return this.mapping.has(this.normalizeExpressionName(expressionName));
+    }
+    isNameAvailable(expressionName) {
+        const normalizedExpressionName = this.normalizeExpressionName(expressionName);
+        const namedExpression = this.mapping.get(normalizedExpressionName);
+        return !(namedExpression && namedExpression.added);
+    }
+    add(namedExpression) {
+        this.mapping.set(namedExpression.normalizeExpressionName(), namedExpression);
+    }
+    get(expressionName) {
+        return this.mapping.get(this.normalizeExpressionName(expressionName));
+    }
+    getExisting(expressionName) {
+        const namedExpression = this.mapping.get(this.normalizeExpressionName(expressionName));
+        if (namedExpression && namedExpression.added) {
+            return namedExpression;
+        }
+        else {
+            return void 0;
+        }
+    }
+    remove(expressionName) {
+        const normalizedExpressionName = this.normalizeExpressionName(expressionName);
+        const namedExpression = this.mapping.get(normalizedExpressionName);
+        if (namedExpression) {
+            namedExpression.added = false;
+        }
+    }
+    getAllNamedExpressions() {
+        return Array.from(this.mapping.values()).filter((ne) => ne.added);
+    }
+    normalizeExpressionName(expressionName) {
+        return expressionName.toLowerCase();
+    }
+}
+class WorksheetStore {
+    constructor() {
+        this.mapping = /* @__PURE__ */ new Map();
+    }
+    add(namedExpression) {
+        this.mapping.set(this.normalizeExpressionName(namedExpression.displayName), namedExpression);
+    }
+    get(expressionName) {
+        return this.mapping.get(this.normalizeExpressionName(expressionName));
+    }
+    has(expressionName) {
+        return this.mapping.has(this.normalizeExpressionName(expressionName));
+    }
+    getAllNamedExpressions() {
+        return Array.from(this.mapping.values()).filter((ne) => ne.added);
+    }
+    isNameAvailable(expressionName) {
+        const normalizedExpressionName = this.normalizeExpressionName(expressionName);
+        return !this.mapping.has(normalizedExpressionName);
+    }
+    remove(expressionName) {
+        const normalizedExpressionName = this.normalizeExpressionName(expressionName);
+        const namedExpression = this.mapping.get(normalizedExpressionName);
+        if (namedExpression) {
+            this.mapping.delete(normalizedExpressionName);
+        }
+    }
+    normalizeExpressionName(expressionName) {
+        return expressionName.toLowerCase();
+    }
+}
+class NamedExpressions {
+    constructor() {
+        this.nextNamedExpressionRow = 0;
+        this.workbookStore = new WorkbookStore();
+        this.worksheetStores = /* @__PURE__ */ new Map();
+        this.addressCache = /* @__PURE__ */ new Map();
+    }
+    isNameAvailable(expressionName, sheetId) {
+        var _a, _b;
+        if (sheetId === void 0) {
+            return this.workbookStore.isNameAvailable(expressionName);
+        }
+        else {
+            return (_b = (_a = this.worksheetStore(sheetId)) === null || _a === void 0 ? void 0 : _a.isNameAvailable(expressionName)) !== null && _b !== void 0 ? _b : true;
+        }
+    }
+    namedExpressionInAddress(row) {
+        const namedExpression = this.addressCache.get(row);
+        if (namedExpression && namedExpression.added) {
+            return namedExpression;
+        }
+        else {
+            return void 0;
+        }
+    }
+    namedExpressionForScope(expressionName, sheetId) {
+        var _a;
+        if (sheetId === void 0) {
+            return this.workbookStore.getExisting(expressionName);
+        }
+        else {
+            return (_a = this.worksheetStore(sheetId)) === null || _a === void 0 ? void 0 : _a.get(expressionName);
+        }
+    }
+    nearestNamedExpression(expressionName, sheetId) {
+        var _a, _b;
+        return (_b = (_a = this.worksheetStore(sheetId)) === null || _a === void 0 ? void 0 : _a.get(expressionName)) !== null && _b !== void 0 ? _b : this.workbookStore.getExisting(expressionName);
+    }
+    isExpressionInScope(expressionName, sheetId) {
+        var _a, _b;
+        return (_b = (_a = this.worksheetStore(sheetId)) === null || _a === void 0 ? void 0 : _a.has(expressionName)) !== null && _b !== void 0 ? _b : false;
+    }
+    /**
+     * Checks the validity of a named-expression's name.
+     *
+     * The name:
+     * - Must start with a Unicode letter or with an underscore (`_`).
+     * - Can contain only Unicode letters, numbers, underscores, and periods (`.`).
+     * - Can't be the same as any possible reference in the A1 notation (`[A-Za-z]+[0-9]+`).
+     * - Can't be the same as any possible reference in the R1C1 notation (`[rR][0-9]*[cC][0-9]*`).
+     *
+     * The naming rules follow the [OpenDocument](https://docs.oasis-open.org/office/OpenDocument/v1.3/os/part4-formula/OpenDocument-v1.3-os-part4-formula.html#__RefHeading__1017964_715980110) standard.
+     */
+    isNameValid(expressionName) {
+        const a1CellRefRegexp = new RegExp(`^${CELL_REFERENCE_PATTERN}$`);
+        const r1c1CellRefRegexp = new RegExp(`^${R1C1_CELL_REFERENCE_PATTERN}$`);
+        const namedExpRegexp = new RegExp(`^${NAMED_EXPRESSION_PATTERN}$`);
+        if (a1CellRefRegexp.test(expressionName) || r1c1CellRefRegexp.test(expressionName)) {
+            return false;
+        }
+        return namedExpRegexp.test(expressionName);
+    }
+    addNamedExpression(expressionName, sheetId, options) {
+        const store2 = sheetId === void 0 ? this.workbookStore : this.worksheetStoreOrCreate(sheetId);
+        let namedExpression = store2.get(expressionName);
+        if (namedExpression !== void 0) {
+            namedExpression.added = true;
+            namedExpression.displayName = expressionName;
+            namedExpression.options = options;
+        }
+        else {
+            namedExpression = new InternalNamedExpression(expressionName, this.nextAddress(), true, options);
+            store2.add(namedExpression);
+        }
+        this.addressCache.set(namedExpression.address.row, namedExpression);
+        return namedExpression;
+    }
+    restoreNamedExpression(namedExpression, sheetId) {
+        const store2 = sheetId === void 0 ? this.workbookStore : this.worksheetStoreOrCreate(sheetId);
+        namedExpression.added = true;
+        store2.add(namedExpression);
+        this.addressCache.set(namedExpression.address.row, namedExpression);
+        return namedExpression;
+    }
+    namedExpressionOrPlaceholder(expressionName, sheetId) {
+        var _a;
+        return (_a = this.worksheetStoreOrCreate(sheetId).get(expressionName)) !== null && _a !== void 0 ? _a : this.workbookNamedExpressionOrPlaceholder(expressionName);
+    }
+    workbookNamedExpressionOrPlaceholder(expressionName) {
+        let namedExpression = this.workbookStore.get(expressionName);
+        if (namedExpression === void 0) {
+            namedExpression = new InternalNamedExpression(expressionName, this.nextAddress(), false);
+            this.workbookStore.add(namedExpression);
+        }
+        return namedExpression;
+    }
+    remove(expressionName, sheetId) {
+        let store2;
+        if (sheetId === void 0) {
+            store2 = this.workbookStore;
+        }
+        else {
+            store2 = this.worksheetStore(sheetId);
+        }
+        const namedExpression = store2 === null || store2 === void 0 ? void 0 : store2.get(expressionName);
+        if (store2 === void 0 || namedExpression === void 0 || !namedExpression.added) {
+            throw Error("Named expression does not exist");
+        }
+        store2.remove(expressionName);
+        if (store2 instanceof WorksheetStore && store2.mapping.size === 0) {
+            this.worksheetStores.delete(sheetId);
+        }
+        this.addressCache.delete(namedExpression.address.row);
+    }
+    getAllNamedExpressionsNamesInScope(sheetId) {
+        return this.getAllNamedExpressions().filter(({ scope }) => scope === sheetId).map((ne) => ne.expression.displayName);
+    }
+    getAllNamedExpressionsNames() {
+        return this.getAllNamedExpressions().map((ne) => ne.expression.displayName);
+    }
+    getAllNamedExpressions() {
+        const storedNamedExpressions = [];
+        this.workbookStore.getAllNamedExpressions().forEach((expr) => {
+            storedNamedExpressions.push({
+                expression: expr,
+                scope: void 0
+            });
+        });
+        this.worksheetStores.forEach((store2, sheetNum) => {
+            store2.getAllNamedExpressions().forEach((expr) => {
+                storedNamedExpressions.push({
+                    expression: expr,
+                    scope: sheetNum
+                });
+            });
+        });
+        return storedNamedExpressions;
+    }
+    getAllNamedExpressionsForScope(scope) {
+        var _a, _b;
+        if (scope === void 0) {
+            return this.workbookStore.getAllNamedExpressions();
+        }
+        else {
+            return (_b = (_a = this.worksheetStores.get(scope)) === null || _a === void 0 ? void 0 : _a.getAllNamedExpressions()) !== null && _b !== void 0 ? _b : [];
+        }
+    }
+    worksheetStoreOrCreate(sheetId) {
+        let store2 = this.worksheetStores.get(sheetId);
+        if (!store2) {
+            store2 = new WorksheetStore();
+            this.worksheetStores.set(sheetId, store2);
+        }
+        return store2;
+    }
+    worksheetStore(sheetId) {
+        return this.worksheetStores.get(sheetId);
+    }
+    nextAddress() {
+        return simpleCellAddress(NamedExpressions.SHEET_FOR_WORKBOOK_EXPRESSIONS, 0, this.nextNamedExpressionRow++);
+    }
+}
+NamedExpressions.SHEET_FOR_WORKBOOK_EXPRESSIONS = -1;
+const doesContainRelativeReferences = (ast) => {
+    switch (ast.type) {
+        case AstNodeType.EMPTY:
+        case AstNodeType.NUMBER:
+        case AstNodeType.STRING:
+        case AstNodeType.ERROR:
+        case AstNodeType.ERROR_WITH_RAW_INPUT:
+            return false;
+        case AstNodeType.CELL_REFERENCE:
+            return !ast.reference.isAbsolute();
+        case AstNodeType.CELL_RANGE:
+        case AstNodeType.COLUMN_RANGE:
+        case AstNodeType.ROW_RANGE:
+            return !ast.start.isAbsolute();
+        case AstNodeType.NAMED_EXPRESSION:
+            return false;
+        case AstNodeType.PERCENT_OP:
+        case AstNodeType.PLUS_UNARY_OP:
+        case AstNodeType.MINUS_UNARY_OP: {
+            return doesContainRelativeReferences(ast.value);
+        }
+        case AstNodeType.CONCATENATE_OP:
+        case AstNodeType.EQUALS_OP:
+        case AstNodeType.NOT_EQUAL_OP:
+        case AstNodeType.LESS_THAN_OP:
+        case AstNodeType.GREATER_THAN_OP:
+        case AstNodeType.LESS_THAN_OR_EQUAL_OP:
+        case AstNodeType.GREATER_THAN_OR_EQUAL_OP:
+        case AstNodeType.MINUS_OP:
+        case AstNodeType.PLUS_OP:
+        case AstNodeType.TIMES_OP:
+        case AstNodeType.DIV_OP:
+        case AstNodeType.POWER_OP:
+            return doesContainRelativeReferences(ast.left) || doesContainRelativeReferences(ast.right);
+        case AstNodeType.PARENTHESIS:
+            return doesContainRelativeReferences(ast.expression);
+        case AstNodeType.FUNCTION_CALL: {
+            return ast.args.some((arg) => doesContainRelativeReferences(arg));
+        }
+        case AstNodeType.ARRAY: {
+            return ast.args.some((row) => row.some((arg) => doesContainRelativeReferences(arg)));
+        }
+    }
+};
 class RowsSpan {
     constructor(sheet, rowStart, rowEnd) {
         this.sheet = sheet;
@@ -76784,68 +77121,164 @@ class AddressMapping {
         this.policy = policy;
         this.mapping = /* @__PURE__ */ new Map();
     }
-    /** @inheritDoc */
-    getCell(address) {
+    /**
+     * Gets the cell vertex at the specified address.
+     */
+    getCell(address, options = {}) {
         const sheetMapping = this.mapping.get(address.sheet);
-        if (sheetMapping === void 0) {
-            throw new NoSheetWithIdError(address.sheet);
+        if (!sheetMapping) {
+            if (options.throwIfSheetNotExists) {
+                throw new NoSheetWithIdError(address.sheet);
+            }
+            return void 0;
+        }
+        const cell = sheetMapping.getCell(address);
+        if (!cell && options.throwIfCellNotExists) {
+            throw Error("Vertex for address missing in AddressMapping");
         }
-        return sheetMapping.getCell(address);
+        return cell;
     }
-    fetchCell(address) {
+    /**
+     * Gets the cell vertex at the specified address or throws if it doesn't exist.
+     * @throws {NoSheetWithIdError} if sheet doesn't exist
+     * @throws {Error} if cell doesn't exist
+     */
+    getCellOrThrow(address) {
         const sheetMapping = this.mapping.get(address.sheet);
-        if (sheetMapping === void 0) {
+        if (!sheetMapping) {
             throw new NoSheetWithIdError(address.sheet);
         }
-        const vertex = sheetMapping.getCell(address);
-        if (!vertex) {
+        const cell = sheetMapping.getCell(address);
+        if (!cell) {
             throw Error("Vertex for address missing in AddressMapping");
         }
-        return vertex;
+        return cell;
     }
-    strategyFor(sheetId) {
+    /**
+     * Gets the address mapping strategy for the specified sheet.
+     * @throws {NoSheetWithIdError} if sheet doesn't exist
+     */
+    getStrategyForSheetOrThrow(sheetId) {
         const strategy = this.mapping.get(sheetId);
         if (strategy === void 0) {
             throw new NoSheetWithIdError(sheetId);
         }
         return strategy;
     }
-    addSheet(sheetId, strategy) {
-        if (this.mapping.has(sheetId)) {
-            throw Error("Sheet already added");
+    /**
+     * Adds a new sheet with the specified strategy.
+     * @throws {Error} if sheet is already added and throwIfSheetAlreadyExists is true
+     */
+    addSheetWithStrategy(sheetId, strategy, options = {
+        throwIfSheetAlreadyExists: true
+    }) {
+        const strategyFound = this.mapping.get(sheetId);
+        if (strategyFound) {
+            if (options.throwIfSheetAlreadyExists) {
+                throw Error("Sheet already added");
+            }
+            return strategyFound;
         }
         this.mapping.set(sheetId, strategy);
+        return strategy;
+    }
+    /**
+     * Adds a sheet or changes the strategy for an existing sheet.
+     * Designed for the purpose of exchanging the placeholder strategy for a real strategy.
+     */
+    addSheetOrChangeStrategy(sheetId, sheetBoundaries) {
+        const newStrategy = this.createStrategyBasedOnBoundaries(sheetBoundaries);
+        const strategyPlaceholder = this.mapping.get(sheetId);
+        if (!strategyPlaceholder) {
+            this.mapping.set(sheetId, newStrategy);
+            return newStrategy;
+        }
+        if (newStrategy instanceof DenseStrategy) {
+            return strategyPlaceholder;
+        }
+        this.moveStrategyContent(strategyPlaceholder, newStrategy, sheetId);
+        this.mapping.set(sheetId, newStrategy);
+        return newStrategy;
     }
-    autoAddSheet(sheetId, sheetBoundaries) {
+    /**
+     * Moves the content of the source strategy to the target strategy.
+     */
+    moveStrategyContent(sourceStrategy, targetStrategy, sheetContext) {
+        const sourceVertices = sourceStrategy.getEntries(sheetContext);
+        for (const [address, vertex] of sourceVertices) {
+            targetStrategy.setCell(address, vertex);
+        }
+    }
+    /**
+     * Adds a sheet and sets the strategy based on the sheet boundaries.
+     * @throws {Error} if sheet already exists and throwIfSheetAlreadyExists is true
+     */
+    addSheetAndSetStrategyBasedOnBoundaries(sheetId, sheetBoundaries, options = {
+        throwIfSheetAlreadyExists: true
+    }) {
+        this.addSheetWithStrategy(sheetId, this.createStrategyBasedOnBoundaries(sheetBoundaries), options);
+    }
+    /**
+     * Creates a strategy based on the sheet boundaries.
+     */
+    createStrategyBasedOnBoundaries(sheetBoundaries) {
         const { height, width, fill } = sheetBoundaries;
         const strategyConstructor = this.policy.call(fill);
-        this.addSheet(sheetId, new strategyConstructor(width, height));
+        return new strategyConstructor(width, height);
     }
+    /**
+     * Adds a placeholder strategy (DenseStrategy) for a sheet. If the sheet already exists, does nothing.
+     */
+    addSheetStrategyPlaceholderIfNotExists(sheetId) {
+        if (this.mapping.has(sheetId)) {
+            return;
+        }
+        this.mapping.set(sheetId, new DenseStrategy(0, 0));
+    }
+    /**
+     * Removes a sheet from the address mapping.
+     * If sheet does not exist, does nothing.
+     * @returns {boolean} true if sheet was removed, false if it did not exist.
+     */
+    removeSheetIfExists(sheetId) {
+        return this.mapping.delete(sheetId);
+    }
+    /**
+     * Gets the interpreter value of a cell at the specified address.
+     * @returns {InterpreterValue} The interpreter value (returns EmptyValue if cell doesn't exist)
+     */
     getCellValue(address) {
         const vertex = this.getCell(address);
         if (vertex === void 0) {
             return EmptyValue;
         }
-        else if (vertex instanceof ArrayVertex) {
+        else if (vertex instanceof ArrayFormulaVertex) {
             return vertex.getArrayCellValue(address);
         }
         else {
             return vertex.getCellValue();
         }
     }
+    /**
+     * Gets the raw cell content at the specified address.
+     * @returns {RawCellContent} The raw cell content or null if cell doesn't exist or is not a value cell
+     */
     getRawValue(address) {
         const vertex = this.getCell(address);
         if (vertex instanceof ValueCellVertex) {
             return vertex.getValues().rawValue;
         }
-        else if (vertex instanceof ArrayVertex) {
+        else if (vertex instanceof ArrayFormulaVertex) {
             return vertex.getArrayCellRawValue(address);
         }
         else {
             return null;
         }
     }
-    /** @inheritDoc */
+    /**
+     * Sets a cell vertex at the specified address.
+     * @throws {Error} if sheet not initialized
+     */
     setCell(address, newVertex) {
         const sheetMapping = this.mapping.get(address.sheet);
         if (!sheetMapping) {
@@ -76853,15 +77286,19 @@ class AddressMapping {
         }
         sheetMapping.setCell(address, newVertex);
     }
+    /**
+     * Moves a cell from source address to destination address.
+     * Supports cross-sheet moves (used for placeholder sheet merging).
+     * @throws {Error} if source sheet not initialized
+     * @throws {Error} if destination occupied
+     * @throws {Error} if source cell doesn't exist
+     */
     moveCell(source, destination) {
         const sheetMapping = this.mapping.get(source.sheet);
         if (!sheetMapping) {
             throw Error("Sheet not initialized.");
         }
-        if (source.sheet !== destination.sheet) {
-            throw Error("Cannot move cells between sheets.");
-        }
-        if (sheetMapping.has(destination)) {
+        if (this.has(destination)) {
             throw new Error("Cannot move cell. Destination already occupied.");
         }
         const vertex = sheetMapping.getCell(source);
@@ -76871,6 +77308,10 @@ class AddressMapping {
         this.setCell(destination, vertex);
         this.removeCell(source);
     }
+    /**
+     * Removes a cell at the specified address.
+     * @throws Error if sheet not initialized
+     */
     removeCell(address) {
         const sheetMapping = this.mapping.get(address.sheet);
         if (!sheetMapping) {
@@ -76878,7 +77319,9 @@ class AddressMapping {
         }
         sheetMapping.removeCell(address);
     }
-    /** @inheritDoc */
+    /**
+     * Checks if a cell exists at the specified address.
+     */
     has(address) {
         const sheetMapping = this.mapping.get(address.sheet);
         if (sheetMapping === void 0) {
@@ -76886,78 +77329,99 @@ class AddressMapping {
         }
         return sheetMapping.has(address);
     }
-    /** @inheritDoc */
-    getHeight(sheetId) {
-        const sheetMapping = this.mapping.get(sheetId);
-        if (sheetMapping === void 0) {
-            throw new NoSheetWithIdError(sheetId);
-        }
+    /**
+     * Gets the height of the specified sheet.
+     */
+    getSheetHeight(sheetId) {
+        const sheetMapping = this.getStrategyForSheetOrThrow(sheetId);
         return sheetMapping.getHeight();
     }
-    /** @inheritDoc */
-    getWidth(sheetId) {
-        const sheetMapping = this.mapping.get(sheetId);
-        if (!sheetMapping) {
-            throw new NoSheetWithIdError(sheetId);
-        }
+    /**
+     * Gets the width of the specified sheet.
+     */
+    getSheetWidth(sheetId) {
+        const sheetMapping = this.getStrategyForSheetOrThrow(sheetId);
         return sheetMapping.getWidth();
     }
-    addRows(sheet, row, numberOfRows) {
-        const sheetMapping = this.mapping.get(sheet);
-        if (sheetMapping === void 0) {
-            throw new NoSheetWithIdError(sheet);
-        }
+    /**
+     * Adds rows to a sheet.
+     */
+    addRows(sheetId, row, numberOfRows) {
+        const sheetMapping = this.getStrategyForSheetOrThrow(sheetId);
         sheetMapping.addRows(row, numberOfRows);
     }
+    /**
+     * Removes rows from a sheet.
+     */
     removeRows(removedRows) {
-        const sheetMapping = this.mapping.get(removedRows.sheet);
-        if (sheetMapping === void 0) {
-            throw new NoSheetWithIdError(removedRows.sheet);
-        }
+        const sheetMapping = this.getStrategyForSheetOrThrow(removedRows.sheet);
         sheetMapping.removeRows(removedRows);
     }
-    removeSheet(sheetId) {
-        this.mapping.delete(sheetId);
-    }
-    addColumns(sheet, column, numberOfColumns) {
-        const sheetMapping = this.mapping.get(sheet);
-        if (sheetMapping === void 0) {
-            throw new NoSheetWithIdError(sheet);
-        }
+    /**
+     * Adds columns to a sheet starting at the specified column index.
+     */
+    addColumns(sheetId, column, numberOfColumns) {
+        const sheetMapping = this.getStrategyForSheetOrThrow(sheetId);
         sheetMapping.addColumns(column, numberOfColumns);
     }
+    /**
+     * Removes columns from a sheet.
+     */
     removeColumns(removedColumns) {
-        const sheetMapping = this.mapping.get(removedColumns.sheet);
-        if (sheetMapping === void 0) {
-            throw new NoSheetWithIdError(removedColumns.sheet);
-        }
+        const sheetMapping = this.getStrategyForSheetOrThrow(removedColumns.sheet);
         sheetMapping.removeColumns(removedColumns);
     }
+    /**
+     * Returns an iterator of cell vertices within the specified rows span.
+     */
     *verticesFromRowsSpan(rowsSpan) {
         yield* this.mapping.get(rowsSpan.sheet).verticesFromRowsSpan(rowsSpan);
     }
+    /**
+     * Returns an iterator of cell vertices within the specified columns span.
+     */
     *verticesFromColumnsSpan(columnsSpan) {
         yield* this.mapping.get(columnsSpan.sheet).verticesFromColumnsSpan(columnsSpan);
     }
+    /**
+     * Returns an iterator of address-vertex pairs within the specified rows span.
+     */
     *entriesFromRowsSpan(rowsSpan) {
-        yield* this.mapping.get(rowsSpan.sheet).entriesFromRowsSpan(rowsSpan);
+        const sheetMapping = this.getStrategyForSheetOrThrow(rowsSpan.sheet);
+        yield* sheetMapping.entriesFromRowsSpan(rowsSpan);
     }
+    /**
+     * Returns an iterator of address-vertex pairs within the specified columns span.
+     */
     *entriesFromColumnsSpan(columnsSpan) {
-        yield* this.mapping.get(columnsSpan.sheet).entriesFromColumnsSpan(columnsSpan);
+        const sheetMapping = this.getStrategyForSheetOrThrow(columnsSpan.sheet);
+        yield* sheetMapping.entriesFromColumnsSpan(columnsSpan);
     }
+    /**
+     * Returns an iterator of all address-vertex pairs across all sheets.
+     * @returns {IterableIterator<[SimpleCellAddress, Maybe<CellVertex>]>} Iterator of [address, vertex] tuples
+     */
     *entries() {
         for (const [sheet, mapping] of this.mapping.entries()) {
             yield* mapping.getEntries(sheet);
         }
     }
-    *sheetEntries(sheet) {
-        const sheetMapping = this.mapping.get(sheet);
-        if (sheetMapping !== void 0) {
-            yield* sheetMapping.getEntries(sheet);
-        }
-        else {
-            throw new NoSheetWithIdError(sheet);
-        }
+    /**
+     * Returns an iterator of address-vertex pairs for a specific sheet.
+     * @returns {IterableIterator<[SimpleCellAddress, CellVertex]>} Iterator of [address, vertex] tuples
+     * @throws {NoSheetWithIdError} if sheet doesn't exist
+     */
+    *sheetEntries(sheetId) {
+        const sheetMapping = this.getStrategyForSheetOrThrow(sheetId);
+        yield* sheetMapping.getEntries(sheetId);
+    }
+    /**
+     * Checks if a sheet has any entries.
+     * @throws {NoSheetWithIdError} if sheet doesn't exist
+     */
+    hasAnyEntries(sheetId) {
+        const iterator = this.sheetEntries(sheetId);
+        return !iterator.next().done;
     }
 }
 class ArrayMapping {
@@ -77225,10 +77689,10 @@ class FormulaVertex {
     }
     static fromAst(formula, address, size2, version) {
         if (size2.isScalar()) {
-            return new FormulaCellVertex(formula, address, version);
+            return new ScalarFormulaVertex(formula, address, version);
         }
         else {
-            return new ArrayVertex(formula, address, size2, version);
+            return new ArrayFormulaVertex(formula, address, size2, version);
         }
     }
     /**
@@ -77254,7 +77718,7 @@ class FormulaVertex {
         return this.cellAddress;
     }
 }
-class ArrayVertex extends FormulaVertex {
+class ArrayFormulaVertex extends FormulaVertex {
     constructor(formula, cellAddress, size2, version = 0) {
         super(formula, cellAddress, version);
         if (size2.isRef) {
@@ -77367,7 +77831,7 @@ class ArrayVertex extends FormulaVertex {
         this.array = new ErroredArray(error, this.array.size);
     }
 }
-class FormulaCellVertex extends FormulaVertex {
+class ScalarFormulaVertex extends FormulaVertex {
     constructor(formula, address, version) {
         super(formula, address, version);
     }
@@ -77472,18 +77936,6 @@ class RangeVertex {
         this.dependentCacheRanges.forEach((range2) => range2.criterionFunctionCache.clear());
         this.dependentCacheRanges.clear();
     }
-    /**
-     * Returns start of the range (it's top-left corner)
-     */
-    getStart() {
-        return this.start;
-    }
-    /**
-     * Returns end of the range (it's bottom-right corner)
-     */
-    getEnd() {
-        return this.end;
-    }
 }
 const collectAddressesDependentToRange = (functionRegistry, vertex, range2, lazilyTransformingAstService, dependencyGraph) => {
     if (vertex instanceof RangeVertex) {
@@ -77964,38 +78416,42 @@ class Graph {
      * Returns error for missing node.
      */
     missingNodeError(node2) {
-        return new Error(`Unknown node ${node2}`);
+        return new Error(`Unknown node ${JSON.stringify(node2)}`);
     }
 }
 class RangeMapping {
     constructor() {
         this.rangeMapping = /* @__PURE__ */ new Map();
     }
-    getMappingSize(sheet) {
+    /**
+     * Returns number of ranges in the sheet or 0 if the sheet does not exist
+     */
+    getNumberOfRangesInSheet(sheet) {
         var _a, _b;
         return (_b = (_a = this.rangeMapping.get(sheet)) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0;
     }
     /**
-     * Saves range vertex
-     *
-     * @param vertex - vertex to save
+     * Adds or updates vertex in the mapping
      */
-    setRange(vertex) {
-        let sheetMap = this.rangeMapping.get(vertex.getStart().sheet);
+    addOrUpdateVertex(vertex) {
+        let sheetMap = this.rangeMapping.get(vertex.sheet);
         if (sheetMap === void 0) {
             sheetMap = /* @__PURE__ */ new Map();
-            this.rangeMapping.set(vertex.getStart().sheet, sheetMap);
+            this.rangeMapping.set(vertex.sheet, sheetMap);
         }
-        const key = keyFromAddresses(vertex.getStart(), vertex.getEnd());
+        const key = RangeMapping.calculateRangeKey(vertex.start, vertex.end);
         sheetMap.set(key, vertex);
     }
-    removeRange(vertex) {
-        const sheet = vertex.getStart().sheet;
+    /**
+     * Removes vertex from the mapping if it exists
+     */
+    removeVertexIfExists(vertex) {
+        const sheet = vertex.sheet;
         const sheetMap = this.rangeMapping.get(sheet);
         if (sheetMap === void 0) {
             return;
         }
-        const key = keyFromAddresses(vertex.getStart(), vertex.getEnd());
+        const key = RangeMapping.calculateRangeKey(vertex.start, vertex.end);
         sheetMap.delete(key);
         if (sheetMap.size === 0) {
             this.rangeMapping.delete(sheet);
@@ -78003,17 +78459,17 @@ class RangeMapping {
     }
     /**
      * Returns associated vertex for given range
-     *
-     * @param start - top-left corner of the range
-     * @param end - bottom-right corner of the range
      */
-    getRange(start, end) {
+    getRangeVertex(start, end) {
         const sheetMap = this.rangeMapping.get(start.sheet);
-        const key = keyFromAddresses(start, end);
+        const key = RangeMapping.calculateRangeKey(start, end);
         return sheetMap === null || sheetMap === void 0 ? void 0 : sheetMap.get(key);
     }
-    fetchRange(start, end) {
-        const maybeRange = this.getRange(start, end);
+    /**
+     * Returns associated vertex for given range or throws an error if not found
+     */
+    getVertexOrThrow(start, end) {
+        const maybeRange = this.getRangeVertex(start, end);
         if (!maybeRange) {
             throw Error("Range does not exist");
         }
@@ -78039,9 +78495,9 @@ class RangeMapping {
             }
         }
         const verticesToMerge = [];
-        updated.sort((left, right) => compareBy(left[1], right[1], coordinate));
+        updated.sort((left, right) => RangeMapping.compareBy(left[1], right[1], coordinate));
         for (const [oldKey, vertex] of updated) {
-            const newKey = keyFromRange(vertex.range);
+            const newKey = RangeMapping.calculateRangeKey(vertex.range.start, vertex.range.end);
             if (newKey === oldKey) {
                 continue;
             }
@@ -78051,7 +78507,7 @@ class RangeMapping {
                 verticesToMerge.push([existingVertex, vertex]);
             }
             else {
-                this.setRange(vertex);
+                this.addOrUpdateVertex(vertex);
             }
         }
         return {
@@ -78060,7 +78516,7 @@ class RangeMapping {
             verticesWithChangedSize
         };
     }
-    moveAllRangesInSheetAfterRowByRows(sheet, row, numberOfRows) {
+    moveAllRangesInSheetAfterAddingRows(sheet, row, numberOfRows) {
         return this.updateVerticesFromSheet(sheet, (key, vertex) => {
             if (row <= vertex.start.row) {
                 vertex.range.shiftByRows(numberOfRows);
@@ -78081,7 +78537,7 @@ class RangeMapping {
             }
         });
     }
-    moveAllRangesInSheetAfterColumnByColumns(sheet, column, numberOfColumns) {
+    moveAllRangesInSheetAfterAddingColumns(sheet, column, numberOfColumns) {
         return this.updateVerticesFromSheet(sheet, (key, vertex) => {
             if (column <= vertex.start.col) {
                 vertex.range.shiftByColumns(numberOfColumns);
@@ -78118,14 +78574,6 @@ class RangeMapping {
             }
         });
     }
-    removeRangesInSheet(sheet) {
-        if (this.rangeMapping.has(sheet)) {
-            const ranges = this.rangeMapping.get(sheet).values();
-            this.rangeMapping.delete(sheet);
-            return ranges;
-        }
-        return [][Symbol.iterator]();
-    }
     *rangesInSheet(sheet) {
         const sheetMap = this.rangeMapping.get(sheet);
         if (!sheetMap) {
@@ -78141,14 +78589,12 @@ class RangeMapping {
         }
     }
     /**
-     * Finds smaller range does have own vertex.
-     *
-     * @param range
+     * Finds smaller range if exists.
      */
     findSmallerRange(range2) {
         if (range2.height() > 1 && Number.isFinite(range2.height())) {
             const valuesRangeEndRowLess = simpleCellAddress(range2.end.sheet, range2.end.col, range2.end.row - 1);
-            const rowLessVertex = this.getRange(range2.start, valuesRangeEndRowLess);
+            const rowLessVertex = this.getRangeVertex(range2.start, valuesRangeEndRowLess);
             if (rowLessVertex !== void 0) {
                 const restRange = AbsoluteCellRange.fromSimpleCellAddresses(simpleCellAddress(range2.start.sheet, range2.start.col, range2.end.row), range2.end);
                 return {
@@ -78161,6 +78607,27 @@ class RangeMapping {
             restRange: range2
         };
     }
+    /**
+     * Calculates a string key from start and end addresses
+     */
+    static calculateRangeKey(start, end) {
+        return `${start.col},${start.row},${end.col},${end.row}`;
+    }
+    /**
+     * Compares two range vertices by their start and end addresses using the provided coordinate function
+     */
+    static compareBy(left, right, coordinate) {
+        const leftStart = coordinate(left.range.start);
+        const rightStart = coordinate(right.range.start);
+        if (leftStart === rightStart) {
+            const leftEnd = coordinate(left.range.end);
+            const rightEnd = coordinate(right.range.end);
+            return leftEnd - rightEnd;
+        }
+        else {
+            return leftStart - rightStart;
+        }
+    }
     *entriesFromSheet(sheet) {
         const sheetMap = this.rangeMapping.get(sheet);
         if (!sheetMap) {
@@ -78169,7 +78636,11 @@ class RangeMapping {
         yield* sheetMap.entries();
     }
     removeByKey(sheet, key) {
-        this.rangeMapping.get(sheet).delete(key);
+        const sheetMap = this.rangeMapping.get(sheet);
+        if (!sheetMap) {
+            throw new Error(`Sheet ${sheet} not found`);
+        }
+        sheetMap.delete(key);
     }
     getByKey(sheet, key) {
         var _a;
@@ -78185,31 +78656,13 @@ class RangeMapping {
             }
         }
         updated.forEach((entry) => {
-            this.setRange(entry.vertex);
+            this.addOrUpdateVertex(entry.vertex);
         });
         return {
             verticesWithChangedSize: updated.filter((entry) => entry.changedSize).map((entry) => entry.vertex)
         };
     }
 }
-function keyFromAddresses(start, end) {
-    return `${start.col},${start.row},${end.col},${end.row}`;
-}
-function keyFromRange(range2) {
-    return keyFromAddresses(range2.start, range2.end);
-}
-const compareBy = (left, right, coordinate) => {
-    const leftStart = coordinate(left.range.start);
-    const rightStart = coordinate(left.range.start);
-    if (leftStart === rightStart) {
-        const leftEnd = coordinate(left.range.end);
-        const rightEnd = coordinate(right.range.end);
-        return leftEnd - rightEnd;
-    }
-    else {
-        return leftStart - rightStart;
-    }
-};
 class TranslationPackage {
     constructor(functions, errors2, ui) {
         this.functions = functions;
@@ -78314,107 +78767,361 @@ var UIElement;
 (function (UIElement2) {
     UIElement2["NEW_SHEET_PREFIX"] = "NEW_SHEET_PREFIX";
 })(UIElement || (UIElement = {}));
-function canonicalize(sheetDisplayName) {
-    return sheetDisplayName.toLowerCase();
-}
 class Sheet {
-    constructor(id2, displayName) {
+    constructor(id2, displayName, isPlaceholder = false) {
         this.id = id2;
         this.displayName = displayName;
+        this.isPlaceholder = isPlaceholder;
     }
+    /**
+     * Returns the canonical (normalized) name of the sheet.
+     */
     get canonicalName() {
-        return canonicalize(this.displayName);
+        return SheetMapping.canonicalizeSheetName(this.displayName);
     }
 }
 class SheetMapping {
     constructor(languages) {
-        this.languages = languages;
-        this.mappingFromCanonicalName = /* @__PURE__ */ new Map();
-        this.mappingFromId = /* @__PURE__ */ new Map();
         this.lastSheetId = -1;
-        this.fetch = (sheetName) => {
-            const sheet = this.mappingFromCanonicalName.get(canonicalize(sheetName));
-            if (sheet === void 0) {
-                throw new NoSheetWithNameError(sheetName);
-            }
-            return sheet.id;
-        };
-        this.get = (sheetName) => {
-            var _a;
-            return (_a = this.mappingFromCanonicalName.get(canonicalize(sheetName))) === null || _a === void 0 ? void 0 : _a.id;
-        };
-        this.fetchDisplayName = (sheetId) => {
-            return this.fetchSheetById(sheetId).displayName;
-        };
+        this.mappingFromCanonicalNameToId = /* @__PURE__ */ new Map();
+        this.allSheets = /* @__PURE__ */ new Map();
         this.sheetNamePrefix = languages.getUITranslation(UIElement.NEW_SHEET_PREFIX);
     }
+    /**
+     * Converts sheet name to canonical/normalized form.
+     * @static
+     */
+    static canonicalizeSheetName(sheetDisplayName) {
+        return sheetDisplayName.toLowerCase();
+    }
+    /**
+     * Returns sheet ID for the given name. By default excludes placeholders.
+     */
+    getSheetId(sheetName, options = {}) {
+        var _a;
+        return (_a = this._getSheetByName(sheetName, options)) === null || _a === void 0 ? void 0 : _a.id;
+    }
+    /**
+     * Returns sheet ID for the given name. Excludes placeholders.
+     *
+     * @throws {NoSheetWithNameError} if the sheet with the given name does not exist.
+     */
+    getSheetIdOrThrowError(sheetName) {
+        const sheet = this._getSheetByName(sheetName, {});
+        if (sheet === void 0) {
+            throw new NoSheetWithNameError(sheetName);
+        }
+        return sheet.id;
+    }
+    /**
+     * Returns display name for the given sheet ID. Excludes placeholders.
+     *
+     * @returns {Maybe<string>} the display name, or undefined if the sheet with the given ID does not exist.
+     */
+    getSheetName(sheetId) {
+        var _a;
+        return (_a = this._getSheet(sheetId, {})) === null || _a === void 0 ? void 0 : _a.displayName;
+    }
+    /**
+     * Returns display name for the given sheet ID. Excludes placeholders.
+     *
+     * @throws {NoSheetWithIdError} if the sheet with the given ID does not exist.
+     */
+    getSheetNameOrThrowError(sheetId, options = {}) {
+        return this._getSheetOrThrowError(sheetId, options).displayName;
+    }
+    /**
+     * Iterates over all sheet display names. By default excludes placeholders.
+     */
+    *iterateSheetNames(options = {}) {
+        for (const sheet of this.allSheets.values()) {
+            if (options.includePlaceholders || !sheet.isPlaceholder) {
+                yield sheet.displayName;
+            }
+        }
+    }
+    /**
+     * Returns array of all sheet display names. By default excludes placeholders.
+     */
+    getSheetNames(options = {}) {
+        return Array.from(this.iterateSheetNames(options));
+    }
+    /**
+     * Returns total count of sheets. By default excludes placeholders.
+     */
+    numberOfSheets(options = {}) {
+        return this.getSheetNames(options).length;
+    }
+    /**
+     * Checks if sheet with given ID exists. By default excludes placeholders.
+     */
+    hasSheetWithId(sheetId, options = {}) {
+        return this._getSheet(sheetId, options) !== void 0;
+    }
+    /**
+     * Checks if sheet with given name exists (case-insensitive). Excludes placeholders.
+     */
+    hasSheetWithName(sheetName) {
+        return this._getSheetByName(sheetName, {}) !== void 0;
+    }
+    /**
+     * Adds new sheet with optional name and returns its ID.
+     * If called with a name of an existing placeholder sheet, converts the placeholder sheet to a real sheet.
+     *
+     * @throws {SheetNameAlreadyTakenError} if the sheet with the given name already exists.
+     */
     addSheet(newSheetDisplayName = `${this.sheetNamePrefix}${this.lastSheetId + 2}`) {
-        const newSheetCanonicalName = canonicalize(newSheetDisplayName);
-        if (this.mappingFromCanonicalName.has(newSheetCanonicalName)) {
-            throw new SheetNameAlreadyTakenError(newSheetDisplayName);
+        const sheetWithConflictingName = this._getSheetByName(newSheetDisplayName, {
+            includePlaceholders: true
+        });
+        if (sheetWithConflictingName) {
+            if (!sheetWithConflictingName.isPlaceholder) {
+                throw new SheetNameAlreadyTakenError(newSheetDisplayName);
+            }
+            sheetWithConflictingName.isPlaceholder = false;
+            return sheetWithConflictingName.id;
         }
         this.lastSheetId++;
         const sheet = new Sheet(this.lastSheetId, newSheetDisplayName);
-        this.store(sheet);
+        this._storeSheetInMappings(sheet);
         return sheet.id;
     }
-    removeSheet(sheetId) {
-        const sheet = this.fetchSheetById(sheetId);
-        if (sheetId == this.lastSheetId) {
-            --this.lastSheetId;
+    /**
+     * Adds a sheet with a specific ID and name. Used for redo operations.
+     * If called with a name of an existing placeholder sheet, converts the placeholder sheet to a real sheet.
+     *
+     * @throws {SheetNameAlreadyTakenError} if the sheet with the given name already exists.
+     */
+    addSheetWithId(sheetId, sheetDisplayName) {
+        const sheetWithConflictingName = this._getSheetByName(sheetDisplayName, {
+            includePlaceholders: true
+        });
+        if (sheetWithConflictingName) {
+            if (sheetWithConflictingName.id !== sheetId) {
+                throw new SheetNameAlreadyTakenError(sheetDisplayName);
+            }
+            if (!sheetWithConflictingName.isPlaceholder) {
+                throw new SheetNameAlreadyTakenError(sheetDisplayName);
+            }
+            sheetWithConflictingName.isPlaceholder = false;
+            return;
         }
-        this.mappingFromCanonicalName.delete(sheet.canonicalName);
-        this.mappingFromId.delete(sheet.id);
-    }
-    getDisplayName(sheetId) {
-        var _a;
-        return (_a = this.mappingFromId.get(sheetId)) === null || _a === void 0 ? void 0 : _a.displayName;
+        if (sheetId > this.lastSheetId) {
+            this.lastSheetId = sheetId;
+        }
+        const sheet = new Sheet(sheetId, sheetDisplayName);
+        this._storeSheetInMappings(sheet);
     }
-    *displayNames() {
-        for (const sheet of this.mappingFromCanonicalName.values()) {
-            yield sheet.displayName;
+    /**
+     * Adds a placeholder sheet with the given name if it does not exist yet
+     */
+    addPlaceholderIfNotExists(sheetName) {
+        const sheetWithConflictingName = this._getSheetByName(sheetName, {
+            includePlaceholders: true
+        });
+        if (sheetWithConflictingName) {
+            return sheetWithConflictingName.id;
         }
+        this.lastSheetId++;
+        const sheet = new Sheet(this.lastSheetId, sheetName, true);
+        this._storeSheetInMappings(sheet);
+        return sheet.id;
     }
-    numberOfSheets() {
-        return this.mappingFromCanonicalName.size;
+    /**
+     * Adds a placeholder sheet with a specific ID and name.
+     * Used for undo operations to restore previously merged placeholder sheets.
+     *
+     * @throws {SheetNameAlreadyTakenError} if the sheet with the given name already exists.
+     */
+    addPlaceholderWithId(sheetId, sheetDisplayName) {
+        const sheetWithConflictingName = this._getSheetByName(sheetDisplayName, {
+            includePlaceholders: true
+        });
+        if (sheetWithConflictingName) {
+            throw new SheetNameAlreadyTakenError(sheetDisplayName);
+        }
+        if (this.hasSheetWithId(sheetId, {
+            includePlaceholders: true
+        })) {
+            throw new Error(`Sheet with id ${sheetId} already exists`);
+        }
+        if (sheetId > this.lastSheetId) {
+            this.lastSheetId = sheetId;
+        }
+        const sheet = new Sheet(sheetId, sheetDisplayName, true);
+        this._storeSheetInMappings(sheet);
     }
-    hasSheetWithId(sheetId) {
-        return this.mappingFromId.has(sheetId);
+    /**
+     *
+     * Removes sheet with given ID.
+     * If sheet does not exist, does nothing.
+     * @returns {boolean} true if sheet was removed, false if it did not exist.
+     */
+    removeSheetIfExists(sheetId, options = {}) {
+        const sheet = this._getSheet(sheetId, options);
+        if (!sheet) {
+            return false;
+        }
+        this.allSheets.delete(sheetId);
+        this.mappingFromCanonicalNameToId.delete(sheet.canonicalName);
+        if (sheetId === this.lastSheetId) {
+            this.lastSheetId--;
+        }
+        return true;
     }
-    hasSheetWithName(sheetName) {
-        return this.mappingFromCanonicalName.has(canonicalize(sheetName));
+    /**
+     * Marks sheet with given ID as a placeholder.
+     * @throws {NoSheetWithIdError} if the sheet with the given ID does not exist
+     */
+    markSheetAsPlaceholder(sheetId) {
+        const sheet = this._getSheetOrThrowError(sheetId, {});
+        sheet.isPlaceholder = true;
     }
+    /**
+     * Renames sheet.
+     * - If called with sheetId of a placeholder sheet, throws {NoSheetWithIdError}.
+     * - If newDisplayName is conflicting with an existing sheet, throws {SheetNameAlreadyTakenError}.
+     * - If newDisplayName is conflicting with a placeholder sheet name, deletes the placeholder sheet and returns its id as mergedWithPlaceholderSheet.
+     *
+     * @throws {SheetNameAlreadyTakenError} if the sheet with the given name already exists.
+     * @throws {NoSheetWithIdError} if the sheet with the given ID does not exist.
+     */
     renameSheet(sheetId, newDisplayName) {
-        const sheet = this.fetchSheetById(sheetId);
+        const sheet = this._getSheetOrThrowError(sheetId, {});
         const currentDisplayName = sheet.displayName;
         if (currentDisplayName === newDisplayName) {
-            return void 0;
+            return {
+                previousDisplayName: void 0
+            };
         }
-        const sheetWithThisCanonicalName = this.mappingFromCanonicalName.get(canonicalize(newDisplayName));
-        if (sheetWithThisCanonicalName !== void 0 && sheetWithThisCanonicalName.id !== sheet.id) {
-            throw new SheetNameAlreadyTakenError(newDisplayName);
+        const sheetWithConflictingName = this._getSheetByName(newDisplayName, {
+            includePlaceholders: true
+        });
+        let mergedWithPlaceholderSheet = void 0;
+        if (sheetWithConflictingName !== void 0 && sheetWithConflictingName.id !== sheet.id) {
+            if (!sheetWithConflictingName.isPlaceholder) {
+                throw new SheetNameAlreadyTakenError(newDisplayName);
+            }
+            else {
+                this.mappingFromCanonicalNameToId.delete(sheetWithConflictingName.canonicalName);
+                this.allSheets.delete(sheetWithConflictingName.id);
+                if (sheetWithConflictingName.id === this.lastSheetId) {
+                    this.lastSheetId--;
+                }
+                mergedWithPlaceholderSheet = sheetWithConflictingName.id;
+            }
         }
         const currentCanonicalName = sheet.canonicalName;
-        this.mappingFromCanonicalName.delete(currentCanonicalName);
+        this.mappingFromCanonicalNameToId.delete(currentCanonicalName);
         sheet.displayName = newDisplayName;
-        this.store(sheet);
-        return currentDisplayName;
+        this._storeSheetInMappings(sheet);
+        return {
+            previousDisplayName: currentDisplayName,
+            mergedWithPlaceholderSheet
+        };
+    }
+    /**
+     * Stores sheet in both internal mappings.
+     * - If ID exists, it is updated. If not, it is added.
+     * - If canonical name exists, it is updated. If not, it is added.
+     *
+     * @internal
+     */
+    _storeSheetInMappings(sheet) {
+        this.allSheets.set(sheet.id, sheet);
+        this.mappingFromCanonicalNameToId.set(sheet.canonicalName, sheet.id);
     }
-    sheetNames() {
-        return Array.from(this.mappingFromId.values()).map((s) => s.displayName);
+    /**
+     * Returns sheet by ID
+     *
+     * @returns {Maybe<Sheet>} the sheet, or undefined if not found.
+     * @internal
+     */
+    _getSheet(sheetId, options) {
+        const retrievedSheet = this.allSheets.get(sheetId);
+        if (retrievedSheet === void 0) {
+            return void 0;
+        }
+        return options.includePlaceholders || !retrievedSheet.isPlaceholder ? retrievedSheet : void 0;
     }
-    store(sheet) {
-        this.mappingFromId.set(sheet.id, sheet);
-        this.mappingFromCanonicalName.set(sheet.canonicalName, sheet);
+    /**
+     * Returns sheet by name
+     *
+     * @returns {Maybe<Sheet>} the sheet, or undefined if not found.
+     * @internal
+     */
+    _getSheetByName(sheetName, options) {
+        const sheetId = this.mappingFromCanonicalNameToId.get(SheetMapping.canonicalizeSheetName(sheetName));
+        if (sheetId === void 0) {
+            return void 0;
+        }
+        return this._getSheet(sheetId, options);
     }
-    fetchSheetById(sheetId) {
-        const sheet = this.mappingFromId.get(sheetId);
+    /**
+     * Returns sheet by ID
+     *
+     * @throws {NoSheetWithIdError} if the sheet with the given ID does not exist.
+     * @internal
+     */
+    _getSheetOrThrowError(sheetId, options) {
+        const sheet = this._getSheet(sheetId, options);
         if (sheet === void 0) {
             throw new NoSheetWithIdError(sheetId);
         }
         return sheet;
     }
 }
+class SheetReferenceRegistrar {
+    constructor(sheetMapping, addressMapping) {
+        this.sheetMapping = sheetMapping;
+        this.addressMapping = addressMapping;
+    }
+    /**
+     * Adds placeholder sheet if it doesn't exist and adds placeholder strategy to address mapping.
+     * @returns {number} sheet id
+     */
+    ensureSheetRegistered(sheetName) {
+        const sheetId = this.sheetMapping.addPlaceholderIfNotExists(sheetName);
+        this.addressMapping.addSheetStrategyPlaceholderIfNotExists(sheetId);
+        return sheetId;
+    }
+}
+function validateAsSheet(sheet) {
+    if (!Array.isArray(sheet)) {
+        throw new InvalidArgumentsError("an array of arrays.");
+    }
+    for (let i = 0; i < sheet.length; i++) {
+        if (!Array.isArray(sheet[i])) {
+            throw new InvalidArgumentsError("an array of arrays.");
+        }
+    }
+}
+function findBoundaries(sheet) {
+    let width = 0;
+    let height = 0;
+    let cellsCount = 0;
+    for (let currentRow = 0; currentRow < sheet.length; currentRow++) {
+        let currentRowWidth = 0;
+        for (let currentCol = 0; currentCol < sheet[currentRow].length; currentCol++) {
+            const currentValue = sheet[currentRow][currentCol];
+            if (currentValue === void 0 || currentValue === null) {
+                continue;
+            }
+            currentRowWidth = currentCol + 1;
+            ++cellsCount;
+        }
+        width = Math.max(width, currentRowWidth);
+        if (currentRowWidth > 0) {
+            height = currentRow + 1;
+        }
+    }
+    const sheetSize = width * height;
+    return {
+        height,
+        width,
+        fill: sheetSize === 0 ? 0 : cellsCount / sheetSize
+    };
+}
 class DependencyGraph {
     constructor(addressMapping, rangeMapping, sheetMapping, arrayMapping, stats, lazilyTransformingAstService, functionRegistry, namedExpressions) {
         this.addressMapping = addressMapping;
@@ -78461,14 +79168,14 @@ class DependencyGraph {
                     const [address, dependencies] = dependenciesResult;
                     return dependencies.map((dependency) => {
                         if (dependency instanceof AbsoluteCellRange) {
-                            return [dependency.start, this.rangeMapping.fetchRange(dependency.start, dependency.end)];
+                            return [dependency.start, this.rangeMapping.getVertexOrThrow(dependency.start, dependency.end)];
                         }
                         else if (dependency instanceof NamedExpressionDependency) {
                             const namedExpression = this.namedExpressions.namedExpressionOrPlaceholder(dependency.name, address.sheet);
-                            return [namedExpression.address, this.addressMapping.fetchCell(namedExpression.address)];
+                            return [namedExpression.address, this.addressMapping.getCellOrThrow(namedExpression.address)];
                         }
                         else {
-                            return [dependency, this.addressMapping.fetchCell(dependency)];
+                            return [dependency, this.addressMapping.getCellOrThrow(dependency)];
                         }
                     });
                 }
@@ -78510,6 +79217,7 @@ class DependencyGraph {
             return [address, absolutizeDependencies(deps, address)];
         };
         this.graph = new Graph(this.dependencyQueryVertices);
+        this.sheetReferenceRegistrar = new SheetReferenceRegistrar(sheetMapping, addressMapping);
     }
     /**
      * Invariants:
@@ -78542,7 +79250,7 @@ class DependencyGraph {
     }
     setValueToCell(address, value) {
         const vertex = this.shrinkPossibleArrayAndGetCell(address);
-        if (vertex instanceof ArrayVertex) {
+        if (vertex instanceof ArrayFormulaVertex) {
             this.arrayMapping.removeArray(vertex.getRange());
         }
         if (vertex instanceof ValueCellVertex) {
@@ -78561,6 +79269,11 @@ class DependencyGraph {
         this.correctInfiniteRangesDependency(address);
         return this.getAndClearContentChanges();
     }
+    /**
+     * Sets a cell empty.
+     * - if vertex has no dependents, removes it from graph, address mapping and range mapping and cleans up its dependencies
+     * - if vertex has dependents, exchanges it for an EmptyCellVertex and marks it as dirty
+     */
     setCellEmpty(address) {
         const vertex = this.shrinkPossibleArrayAndGetCell(address);
         if (vertex === void 0) {
@@ -78592,16 +79305,22 @@ class DependencyGraph {
     }
     processCellDependencies(cellDependencies, endVertex) {
         const endVertexId = this.graph.getNodeId(endVertex);
+        if (endVertexId === void 0) {
+            throw new Error("End vertex not found");
+        }
         cellDependencies.forEach((dep) => {
             if (dep instanceof AbsoluteCellRange) {
                 const range2 = dep;
                 let rangeVertex = this.getRange(range2.start, range2.end);
                 if (rangeVertex === void 0) {
                     rangeVertex = new RangeVertex(range2);
-                    this.rangeMapping.setRange(rangeVertex);
+                    this.rangeMapping.addOrUpdateVertex(rangeVertex);
                 }
                 this.graph.addNodeAndReturnId(rangeVertex);
                 const rangeVertexId = this.graph.getNodeId(rangeVertex);
+                if (rangeVertexId === void 0) {
+                    throw new Error("Range vertex not found");
+                }
                 if (!range2.isFinite()) {
                     this.graph.markNodeAsInfiniteRange(rangeVertexId);
                 }
@@ -78676,7 +79395,7 @@ class DependencyGraph {
                 for (const adjacentNode of this.graph.adjacentNodes(vertex)) {
                     this.graph.markNodeAsDirty(adjacentNode);
                 }
-                if (vertex instanceof ArrayVertex) {
+                if (vertex instanceof ArrayFormulaVertex) {
                     if (vertex.isLeftCorner(address)) {
                         this.shrinkArrayToCorner(vertex);
                         this.arrayMapping.removeArray(vertex.getRange());
@@ -78704,29 +79423,64 @@ class DependencyGraph {
             contentChanges: this.getAndClearContentChanges()
         };
     }
-    removeSheet(removedSheetId) {
-        this.clearSheet(removedSheetId);
-        for (const [adr, vertex] of this.addressMapping.sheetEntries(removedSheetId)) {
-            for (const adjacentNode of this.graph.adjacentNodes(vertex)) {
-                this.graph.markNodeAsDirty(adjacentNode);
-            }
-            this.removeVertex(vertex);
-            this.addressMapping.removeCell(adr);
-        }
+    /**
+     * Adds a new sheet to the graph.
+     * If the sheetId was a placeholder sheet, marks its vertices as dirty.
+     */
+    addSheet(sheetId) {
+        this.addressMapping.addSheetOrChangeStrategy(sheetId, findBoundaries([]));
+        this.stats.measure(StatType.ADJUSTING_ADDRESS_MAPPING, () => {
+            this.markAllCellsAsDirtyInSheet(sheetId);
+        });
         this.stats.measure(StatType.ADJUSTING_RANGES, () => {
-            const rangesToRemove = this.rangeMapping.removeRangesInSheet(removedSheetId);
-            for (const range2 of rangesToRemove) {
-                this.removeVertex(range2);
-            }
-            this.stats.measure(StatType.ADJUSTING_ADDRESS_MAPPING, () => {
-                this.addressMapping.removeSheet(removedSheetId);
-            });
+            this.markAllRangesAsDirtyInSheet(sheetId);
         });
     }
+    /**
+     * Removes all vertices without dependents in other sheets from address mapping, range mapping and array mapping.
+     * - If nothing is left, removes the sheet from sheet mapping and address mapping.
+     * - Otherwise, marks it as placeholder.
+     */
+    removeSheet(sheetId) {
+        this.clearSheet(sheetId);
+        const addressMappingCleared = !this.addressMapping.hasAnyEntries(sheetId);
+        const rangeMappingCleared = this.rangeMapping.getNumberOfRangesInSheet(sheetId) === 0;
+        if (addressMappingCleared && rangeMappingCleared) {
+            this.sheetMapping.removeSheetIfExists(sheetId);
+            this.addressMapping.removeSheetIfExists(sheetId);
+        }
+        else {
+            this.sheetMapping.markSheetAsPlaceholder(sheetId);
+        }
+    }
+    /**
+     * Removes placeholderSheetToDelete and reroutes edges to the corresponding vertices in sheetToKeep
+     *
+     * Assumptions about placeholderSheetToDelete:
+     * - is empty (contains only empty cell vertices and range vertices),
+     * - empty cell vertices have no dependencies,
+     * - range vertices have dependencies only in placeholderSheetToDelete,
+     * - vertices may have dependents in placeholderSheetToDelete and other sheets,
+     */
+    mergeSheets(sheetToKeep, placeholderSheetToDelete) {
+        if (!this.isPlaceholder(placeholderSheetToDelete)) {
+            throw new Error(`Cannot merge sheets: sheet ${placeholderSheetToDelete} is not a placeholder`);
+        }
+        this.mergeRangeVertices(sheetToKeep, placeholderSheetToDelete);
+        this.mergeCellVertices(sheetToKeep, placeholderSheetToDelete);
+        this.addressMapping.removeSheetIfExists(placeholderSheetToDelete);
+        this.addStructuralNodesToChangeSet();
+    }
+    /**
+     * Clears the sheet content.
+     * - removes all cell vertices without dependents
+     * - removes all array vertices
+     * - for vertices with dependents, exchanges them for EmptyCellVertex and marks them as dirty
+     */
     clearSheet(sheetId) {
         const arrays = /* @__PURE__ */ new Set();
         for (const [address, vertex] of this.addressMapping.sheetEntries(sheetId)) {
-            if (vertex instanceof ArrayVertex) {
+            if (vertex instanceof ArrayFormulaVertex) {
                 arrays.add(vertex);
             }
             else {
@@ -78744,7 +79498,7 @@ class DependencyGraph {
                 for (const adjacentNode of this.graph.adjacentNodes(vertex)) {
                     this.graph.markNodeAsDirty(adjacentNode);
                 }
-                if (vertex instanceof ArrayVertex) {
+                if (vertex instanceof ArrayFormulaVertex) {
                     if (vertex.isLeftCorner(address)) {
                         this.shrinkArrayToCorner(vertex);
                         this.arrayMapping.removeArray(vertex.getRange());
@@ -78777,7 +79531,7 @@ class DependencyGraph {
             this.addressMapping.addRows(addedRows.sheet, addedRows.rowStart, addedRows.numberOfRows);
         });
         const affectedArrays = this.stats.measure(StatType.ADJUSTING_RANGES, () => {
-            const result = this.rangeMapping.moveAllRangesInSheetAfterRowByRows(addedRows.sheet, addedRows.rowStart, addedRows.numberOfRows);
+            const result = this.rangeMapping.moveAllRangesInSheetAfterAddingRows(addedRows.sheet, addedRows.rowStart, addedRows.numberOfRows);
             this.fixRangesWhenAddingRows(addedRows.sheet, addedRows.rowStart, addedRows.numberOfRows);
             return this.getArrayVerticesRelatedToRanges(result.verticesWithChangedSize);
         });
@@ -78797,7 +79551,7 @@ class DependencyGraph {
             this.addressMapping.addColumns(addedColumns.sheet, addedColumns.columnStart, addedColumns.numberOfColumns);
         });
         const affectedArrays = this.stats.measure(StatType.ADJUSTING_RANGES, () => {
-            const result = this.rangeMapping.moveAllRangesInSheetAfterColumnByColumns(addedColumns.sheet, addedColumns.columnStart, addedColumns.numberOfColumns);
+            const result = this.rangeMapping.moveAllRangesInSheetAfterAddingColumns(addedColumns.sheet, addedColumns.columnStart, addedColumns.numberOfColumns);
             this.fixRangesWhenAddingColumns(addedColumns.sheet, addedColumns.columnStart, addedColumns.numberOfColumns);
             return this.getArrayVerticesRelatedToRanges(result.verticesWithChangedSize);
         });
@@ -78875,13 +79629,20 @@ class DependencyGraph {
         }
         this.rangeMapping.moveRangesInsideSourceRange(sourceRange, toRight, toBottom, toSheet);
     }
+    /**
+     * Sets an array empty.
+     * - removes all corresponding entries from address mapping
+     * - reroutes the edges
+     * - removes vertex from graph and cleans up its dependencies
+     * - removes vertex from range mapping and array mapping
+     */
     setArrayEmpty(arrayVertex) {
         const arrayRange = AbsoluteCellRange.spanFrom(arrayVertex.getAddress(this.lazilyTransformingAstService), arrayVertex.width, arrayVertex.height);
-        const adjacentNodes = this.graph.adjacentNodes(arrayVertex);
+        const dependentVertices = this.graph.adjacentNodes(arrayVertex);
         for (const address of arrayRange.addresses(this)) {
             this.addressMapping.removeCell(address);
         }
-        for (const adjacentNode of adjacentNodes.values()) {
+        for (const adjacentNode of dependentVertices.values()) {
             const nodeDependencies = collectAddressesDependentToRange(this.functionRegistry, adjacentNode, arrayVertex.getRange(), this.lazilyTransformingAstService, this);
             for (const address of nodeDependencies) {
                 const { vertex, id: id2 } = this.fetchCellOrCreateEmpty(address);
@@ -78902,9 +79663,12 @@ class DependencyGraph {
         this.graph.addNodeAndReturnId(vertex);
         this.setAddressMappingForArrayVertex(vertex, address);
     }
+    /**
+     * Iterator over all array formula nodes in the graph.
+     */
     *arrayFormulaNodes() {
         for (const vertex of this.graph.getNodes()) {
-            if (vertex instanceof ArrayVertex) {
+            if (vertex instanceof ArrayFormulaVertex) {
                 yield vertex;
             }
         }
@@ -78916,18 +79680,33 @@ class DependencyGraph {
         yield* this.addressMapping.entriesFromColumnsSpan(columnsSpan);
     }
     fetchCell(address) {
-        return this.addressMapping.fetchCell(address);
+        return this.addressMapping.getCellOrThrow(address);
     }
+    /**
+     * Gets the cell vertex at the specified address.
+     * @throws {NoSheetWithIdError} if sheet doesn't exist
+     */
     getCell(address) {
-        return this.addressMapping.getCell(address);
+        return this.addressMapping.getCell(address, {
+            throwIfSheetNotExists: true
+        });
     }
     getCellValue(address) {
+        if (this.isPlaceholder(address.sheet)) {
+            return new CellError(ErrorType.REF, ErrorMessage.SheetRef);
+        }
         return this.addressMapping.getCellValue(address);
     }
     getRawValue(address) {
+        if (this.isPlaceholder(address.sheet)) {
+            return null;
+        }
         return this.addressMapping.getRawValue(address);
     }
     getScalarValue(address) {
+        if (this.isPlaceholder(address.sheet)) {
+            return new CellError(ErrorType.REF, ErrorMessage.SheetRef);
+        }
         const value = this.addressMapping.getCellValue(address);
         if (value instanceof SimpleRangeValue) {
             return new CellError(ErrorType.VALUE, ErrorMessage.ScalarExpected);
@@ -78938,19 +79717,19 @@ class DependencyGraph {
         return this.graph.existsEdge(fromNode, toNode);
     }
     getSheetId(sheetName) {
-        return this.sheetMapping.fetch(sheetName);
+        return this.sheetMapping.getSheetIdOrThrowError(sheetName);
     }
     getSheetHeight(sheet) {
-        return this.addressMapping.getHeight(sheet);
+        return this.addressMapping.getSheetHeight(sheet);
     }
     getSheetWidth(sheet) {
-        return this.addressMapping.getWidth(sheet);
+        return this.addressMapping.getSheetWidth(sheet);
     }
     getArray(range2) {
         return this.arrayMapping.getArray(range2);
     }
     getRange(start, end) {
-        return this.rangeMapping.getRange(start, end);
+        return this.rangeMapping.getRangeVertex(start, end);
     }
     topSortWithScc() {
         return this.graph.topSortWithScc();
@@ -78963,7 +79742,7 @@ class DependencyGraph {
     }
     forceApplyPostponedTransformations() {
         for (const vertex of this.graph.getNodes()) {
-            if (vertex instanceof FormulaCellVertex) {
+            if (vertex instanceof ScalarFormulaVertex) {
                 vertex.ensureRecentData(this.lazilyTransformingAstService);
             }
         }
@@ -79010,7 +79789,7 @@ class DependencyGraph {
     }
     isArrayInternalCell(address) {
         const vertex = this.getCell(address);
-        return vertex instanceof ArrayVertex && !vertex.isLeftCorner(address);
+        return vertex instanceof ArrayFormulaVertex && !vertex.isLeftCorner(address);
     }
     getAndClearContentChanges() {
         const changes = this.changes;
@@ -79021,16 +79800,98 @@ class DependencyGraph {
         const deps = this.graph.adjacentNodes(inputVertex);
         const ret = [];
         deps.forEach((vertex) => {
-            const castVertex = vertex;
-            if (castVertex instanceof RangeVertex) {
-                ret.push(simpleCellRange(castVertex.start, castVertex.end));
+            if (vertex instanceof RangeVertex) {
+                ret.push(simpleCellRange(vertex.start, vertex.end));
             }
-            else {
-                ret.push(castVertex.getAddress(this.lazilyTransformingAstService));
+            else if (vertex instanceof FormulaVertex) {
+                ret.push(vertex.getAddress(this.lazilyTransformingAstService));
             }
         });
         return ret;
     }
+    /**
+     * Marks all cell vertices in the sheet as dirty.
+     */
+    markAllCellsAsDirtyInSheet(sheetId) {
+        const sheetCells = this.addressMapping.sheetEntries(sheetId);
+        for (const [, vertex] of sheetCells) {
+            this.graph.markNodeAsDirty(vertex);
+        }
+    }
+    /**
+     * Marks all range vertices in the sheet as dirty.
+     */
+    markAllRangesAsDirtyInSheet(sheetId) {
+        const sheetRanges = this.rangeMapping.rangesInSheet(sheetId);
+        for (const vertex of sheetRanges) {
+            this.graph.markNodeAsDirty(vertex);
+        }
+    }
+    /**
+     * For each range vertex in placeholderSheetToDelete:
+     * - reroutes dependencies and dependents of range vertex to the corresponding vertex in sheetToKeep
+     * - removes range vertex from graph and range mapping
+     * - cleans up dependencies of the removed vertex
+     */
+    mergeRangeVertices(sheetToKeep, placeholderSheetToDelete) {
+        const rangeVertices = Array.from(this.rangeMapping.rangesInSheet(placeholderSheetToDelete));
+        for (const vertexToDelete of rangeVertices) {
+            if (!this.graph.hasNode(vertexToDelete)) {
+                continue;
+            }
+            const start = vertexToDelete.start;
+            const end = vertexToDelete.end;
+            if (start.sheet !== placeholderSheetToDelete && end.sheet !== placeholderSheetToDelete) {
+                continue;
+            }
+            const targetStart = simpleCellAddress(sheetToKeep, start.col, start.row);
+            const targetEnd = simpleCellAddress(sheetToKeep, end.col, end.row);
+            const vertexToKeep = this.rangeMapping.getRangeVertex(targetStart, targetEnd);
+            if (vertexToKeep) {
+                this.rerouteDependents(vertexToDelete, vertexToKeep);
+                this.removeVertexAndRerouteDependencies(vertexToDelete, vertexToKeep);
+                this.rangeMapping.removeVertexIfExists(vertexToDelete);
+                this.graph.markNodeAsDirty(vertexToKeep);
+            }
+            else {
+                this.rangeMapping.removeVertexIfExists(vertexToDelete);
+                vertexToDelete.range.moveToSheet(sheetToKeep);
+                this.rangeMapping.addOrUpdateVertex(vertexToDelete);
+                this.graph.markNodeAsDirty(vertexToDelete);
+            }
+        }
+    }
+    /**
+     * For each cell vertex in placeholderSheetToDelete:
+     * - reroutes dependents of cell vertex to the corresponding vertex in sheetToKeep
+     * - removes cell vertex from graph and address mapping
+     * - cleans up dependencies of the removed vertex
+     */
+    mergeCellVertices(sheetToKeep, placeholderSheetToDelete) {
+        const cellVertices = Array.from(this.addressMapping.sheetEntries(placeholderSheetToDelete));
+        for (const [addressToDelete, vertexToDelete] of cellVertices) {
+            const addressToKeep = simpleCellAddress(sheetToKeep, addressToDelete.col, addressToDelete.row);
+            const vertexToKeep = this.getCell(addressToKeep);
+            if (vertexToKeep) {
+                this.rerouteDependents(vertexToDelete, vertexToKeep);
+                this.removeVertexAndCleanupDependencies(vertexToDelete);
+                this.addressMapping.removeCell(addressToDelete);
+                this.graph.markNodeAsDirty(vertexToKeep);
+            }
+            else {
+                this.addressMapping.moveCell(addressToDelete, addressToKeep);
+                this.graph.markNodeAsDirty(vertexToDelete);
+            }
+        }
+    }
+    /**
+     * Checks if the given sheet ID refers to a placeholder sheet (doesn't exist but is referenced by other sheets)
+     */
+    isPlaceholder(sheetId) {
+        return sheetId !== NamedExpressions.SHEET_FOR_WORKBOOK_EXPRESSIONS && !this.sheetMapping.hasSheetWithId(sheetId, {
+            includePlaceholders: false
+        });
+    }
     exchangeGraphNode(oldNode, newNode) {
         this.graph.addNodeAndReturnId(newNode);
         const adjNodesStored = this.graph.adjacentNodes(oldNode);
@@ -79051,6 +79912,9 @@ class DependencyGraph {
         }
         const { vertex, id: maybeVertexId } = this.fetchCellOrCreateEmpty(address);
         const vertexId = maybeVertexId !== null && maybeVertexId !== void 0 ? maybeVertexId : this.graph.getNodeId(vertex);
+        if (vertexId === void 0) {
+            throw new Error("Vertex not found");
+        }
         relevantInfiniteRanges.forEach(({ id: id2 }) => {
             this.graph.addEdge(vertexId, id2);
         });
@@ -79070,7 +79934,7 @@ class DependencyGraph {
                 return;
             }
             this.graph.adjacentNodes(range2).forEach((adjacentVertex) => {
-                if (adjacentVertex instanceof ArrayVertex) {
+                if (adjacentVertex instanceof ArrayFormulaVertex) {
                     arrayVertices.add(adjacentVertex);
                 }
             });
@@ -79162,7 +80026,7 @@ class DependencyGraph {
                     }
                     while (find2.smallerRangeVertex === void 0) {
                         const newRangeVertex = new RangeVertex(AbsoluteCellRange.spanFrom(currentRangeVertex.range.start, currentRangeVertex.range.width(), currentRangeVertex.range.height() - 1));
-                        this.rangeMapping.setRange(newRangeVertex);
+                        this.rangeMapping.addOrUpdateVertex(newRangeVertex);
                         this.graph.addNodeAndReturnId(newRangeVertex);
                         const restRange = new AbsoluteCellRange(simpleCellAddress(currentRangeVertex.range.start.sheet, currentRangeVertex.range.start.col, currentRangeVertex.range.end.row), currentRangeVertex.range.end);
                         this.addAllFromRange(restRange, currentRangeVertex);
@@ -79204,12 +80068,12 @@ class DependencyGraph {
         const address = vertex.getAddress(this.lazilyTransformingAstService);
         const range2 = AbsoluteCellRange.spanFrom(address, vertex.width, vertex.height);
         const oldNode = this.shrinkPossibleArrayAndGetCell(address);
-        if (vertex instanceof ArrayVertex) {
+        if (vertex instanceof ArrayFormulaVertex) {
             this.setArray(range2, vertex);
         }
         this.exchangeOrAddGraphNode(oldNode, vertex);
         this.addressMapping.setCell(address, vertex);
-        if (vertex instanceof ArrayVertex) {
+        if (vertex instanceof ArrayFormulaVertex) {
             if (!this.isThereSpaceForArray(vertex)) {
                 return;
             }
@@ -79227,7 +80091,7 @@ class DependencyGraph {
     }
     setAddressMappingForArrayVertex(vertex, formulaAddress) {
         this.addressMapping.setCell(formulaAddress, vertex);
-        if (!(vertex instanceof ArrayVertex)) {
+        if (!(vertex instanceof ArrayFormulaVertex)) {
             return;
         }
         const range2 = AbsoluteCellRange.spanFromOrUndef(formulaAddress, vertex.width, vertex.height);
@@ -79245,7 +80109,8 @@ class DependencyGraph {
     truncateRanges(span, coordinate) {
         const { verticesToRemove, verticesToMerge, verticesWithChangedSize } = this.rangeMapping.truncateRanges(span, coordinate);
         for (const [existingVertex, mergedVertex] of verticesToMerge) {
-            this.mergeRangeVertices(existingVertex, mergedVertex);
+            this.rerouteDependents(mergedVertex, existingVertex);
+            this.removeVertexAndCleanupDependencies(mergedVertex);
         }
         for (const rangeVertex of verticesToRemove) {
             this.removeVertexAndCleanupDependencies(rangeVertex);
@@ -79322,36 +80187,59 @@ class DependencyGraph {
     }
     shrinkPossibleArrayAndGetCell(address) {
         const vertex = this.getCell(address);
-        if (!(vertex instanceof ArrayVertex)) {
+        if (!(vertex instanceof ArrayFormulaVertex)) {
             return vertex;
         }
         this.setNoSpaceIfArray(vertex);
         return this.getCell(address);
     }
     setNoSpaceIfArray(vertex) {
-        if (vertex instanceof ArrayVertex) {
+        if (vertex instanceof ArrayFormulaVertex) {
             this.shrinkArrayToCorner(vertex);
             vertex.setNoSpace();
         }
     }
+    /**
+     * Removes a vertex from the graph and range mapping and cleans up its dependencies.
+     */
     removeVertex(vertex) {
         this.removeVertexAndCleanupDependencies(vertex);
         if (vertex instanceof RangeVertex) {
-            this.rangeMapping.removeRange(vertex);
+            this.rangeMapping.removeVertexIfExists(vertex);
         }
     }
-    mergeRangeVertices(existingVertex, newVertex) {
-        const adjNodesStored = this.graph.adjacentNodes(newVertex);
-        this.removeVertexAndCleanupDependencies(newVertex);
-        this.graph.removeEdgeIfExists(existingVertex, newVertex);
-        adjNodesStored.forEach((adjacentNode) => {
+    /**
+     * Reroutes dependent vertices of source to target. Also removes the edge target -> source if it exists.
+     */
+    rerouteDependents(source, target) {
+        const dependents = this.graph.adjacentNodes(source);
+        this.graph.removeEdgeIfExists(target, source);
+        dependents.forEach((adjacentNode) => {
             if (this.graph.hasNode(adjacentNode)) {
-                this.graph.addEdge(existingVertex, adjacentNode);
+                this.graph.addEdge(target, adjacentNode);
+            }
+        });
+    }
+    /**
+     * Removes a vertex from graph and reroutes its dependencies to other vertex. Also removes the edge vertexToKeep -> vertexToDelete if it exists.
+     */
+    removeVertexAndRerouteDependencies(vertexToDelete, vertexToKeep) {
+        const dependencies = this.graph.removeNode(vertexToDelete);
+        this.graph.removeEdgeIfExists(vertexToKeep, vertexToDelete);
+        dependencies.forEach(([_, dependency]) => {
+            if (this.graph.hasNode(dependency)) {
+                this.graph.addEdge(dependency, vertexToKeep);
             }
         });
     }
+    /**
+     * Removes a vertex from graph and cleans up its dependencies.
+     * Dependency clean up = remove all RangeVertex and EmptyCellVertex dependencies if no other vertex depends on them.
+     * Also cleans up placeholder sheets that have no remaining vertices (not needed anymore)
+     */
     removeVertexAndCleanupDependencies(inputVertex) {
         const dependencies = new Set(this.graph.removeNode(inputVertex));
+        const affectedSheets = /* @__PURE__ */ new Set();
         while (dependencies.size > 0) {
             const dependency = dependencies.values().next().value;
             dependencies.delete(dependency);
@@ -79361,13 +80249,29 @@ class DependencyGraph {
                     this.graph.removeNode(vertex).forEach((candidate) => dependencies.add(candidate));
                 }
                 if (vertex instanceof RangeVertex) {
-                    this.rangeMapping.removeRange(vertex);
+                    this.rangeMapping.removeVertexIfExists(vertex);
+                    affectedSheets.add(vertex.sheet);
                 }
-                else if (vertex instanceof EmptyCellVertex) {
+                else if (vertex instanceof EmptyCellVertex && isSimpleCellAddress(address)) {
                     this.addressMapping.removeCell(address);
+                    affectedSheets.add(address.sheet);
                 }
             }
         }
+        this.cleanupPlaceholderSheets(affectedSheets);
+    }
+    /**
+     * Removes placeholder sheets that have no remaining vertices.
+     */
+    cleanupPlaceholderSheets(sheetIds) {
+        for (const sheetId of sheetIds) {
+            if (this.isPlaceholder(sheetId) && !this.addressMapping.hasAnyEntries(sheetId) && this.rangeMapping.getNumberOfRangesInSheet(sheetId) === 0) {
+                this.sheetMapping.removeSheetIfExists(sheetId, {
+                    includePlaceholders: true
+                });
+                this.addressMapping.removeSheetIfExists(sheetId);
+            }
+        }
     }
 }
 class EmptyCellVertex {
@@ -79786,7 +80690,7 @@ var CellType;
     CellType2["ARRAYFORMULA"] = "ARRAYFORMULA";
 })(CellType || (CellType = {}));
 const getCellType = (vertex, address) => {
-    if (vertex instanceof ArrayVertex) {
+    if (vertex instanceof ArrayFormulaVertex) {
         if (vertex.isLeftCorner(address)) {
             return CellType.ARRAYFORMULA;
         }
@@ -79794,7 +80698,7 @@ const getCellType = (vertex, address) => {
             return CellType.ARRAY;
         }
     }
-    if (vertex instanceof FormulaCellVertex || vertex instanceof ParsingErrorVertex) {
+    if (vertex instanceof ScalarFormulaVertex || vertex instanceof ParsingErrorVertex) {
         return CellType.FORMULA;
     }
     if (vertex instanceof ValueCellVertex) {
@@ -79902,7 +80806,7 @@ const simpleCellAddress = (sheet, col, row) => ({
     col,
     row
 });
-const invalidSimpleCellAddress = (address) => address.col < 0 || address.row < 0;
+const isColOrRowInvalid = (address) => address.col < 0 || address.row < 0;
 const movedSimpleCellAddress = (address, toSheet, toRight, toBottom) => {
     return simpleCellAddress(toSheet, address.col + toRight, address.row + toBottom);
 };
@@ -82438,7 +83342,7 @@ function checkLicenseKeyValidity(licenseKey) {
         messageDescriptor.template = "valid";
     }
     else if (typeof licenseKey === "string" && checkKeySchema(licenseKey)) {
-        const [day, month, year] = "14/10/2025".split("/");
+        const [day, month, year] = "18/12/2025".split("/");
         const releaseDays = Math.floor(( /* @__PURE__ */new Date(`${month}/${day}/${year}`)).getTime() / 864e5);
         const keyValidityDays = extractTime(licenseKey);
         messageDescriptor.vars.keyValidityDate = formatDate(new Date((keyValidityDays + 1) * 864e5));
@@ -82696,7 +83600,7 @@ class ClipboardOperations {
         if (this.clipboard === void 0) {
             return;
         }
-        if (invalidSimpleCellAddress(destinationLeftCorner) || !this.dependencyGraph.sheetMapping.hasSheetWithId(destinationLeftCorner.sheet)) {
+        if (isColOrRowInvalid(destinationLeftCorner) || !this.dependencyGraph.sheetMapping.hasSheetWithId(destinationLeftCorner.sheet)) {
             throw new InvalidArgumentsError("a valid target address.");
         }
         const targetRange = AbsoluteCellRange.spanFrom(destinationLeftCorner, this.clipboard.width, this.clipboard.height);
@@ -82714,299 +83618,6 @@ class ClipboardOperations {
         return this.clipboard !== void 0 && this.clipboard.type === ClipboardOperationType.COPY;
     }
 }
-class InternalNamedExpression {
-    constructor(displayName, address, added, options) {
-        this.displayName = displayName;
-        this.address = address;
-        this.added = added;
-        this.options = options;
-    }
-    normalizeExpressionName() {
-        return this.displayName.toLowerCase();
-    }
-    copy() {
-        return new InternalNamedExpression(this.displayName, this.address, this.added, this.options);
-    }
-}
-class WorkbookStore {
-    constructor() {
-        this.mapping = /* @__PURE__ */ new Map();
-    }
-    has(expressionName) {
-        return this.mapping.has(this.normalizeExpressionName(expressionName));
-    }
-    isNameAvailable(expressionName) {
-        const normalizedExpressionName = this.normalizeExpressionName(expressionName);
-        const namedExpression = this.mapping.get(normalizedExpressionName);
-        return !(namedExpression && namedExpression.added);
-    }
-    add(namedExpression) {
-        this.mapping.set(namedExpression.normalizeExpressionName(), namedExpression);
-    }
-    get(expressionName) {
-        return this.mapping.get(this.normalizeExpressionName(expressionName));
-    }
-    getExisting(expressionName) {
-        const namedExpression = this.mapping.get(this.normalizeExpressionName(expressionName));
-        if (namedExpression && namedExpression.added) {
-            return namedExpression;
-        }
-        else {
-            return void 0;
-        }
-    }
-    remove(expressionName) {
-        const normalizedExpressionName = this.normalizeExpressionName(expressionName);
-        const namedExpression = this.mapping.get(normalizedExpressionName);
-        if (namedExpression) {
-            namedExpression.added = false;
-        }
-    }
-    getAllNamedExpressions() {
-        return Array.from(this.mapping.values()).filter((ne) => ne.added);
-    }
-    normalizeExpressionName(expressionName) {
-        return expressionName.toLowerCase();
-    }
-}
-class WorksheetStore {
-    constructor() {
-        this.mapping = /* @__PURE__ */ new Map();
-    }
-    add(namedExpression) {
-        this.mapping.set(this.normalizeExpressionName(namedExpression.displayName), namedExpression);
-    }
-    get(expressionName) {
-        return this.mapping.get(this.normalizeExpressionName(expressionName));
-    }
-    has(expressionName) {
-        return this.mapping.has(this.normalizeExpressionName(expressionName));
-    }
-    getAllNamedExpressions() {
-        return Array.from(this.mapping.values()).filter((ne) => ne.added);
-    }
-    isNameAvailable(expressionName) {
-        const normalizedExpressionName = this.normalizeExpressionName(expressionName);
-        return !this.mapping.has(normalizedExpressionName);
-    }
-    remove(expressionName) {
-        const normalizedExpressionName = this.normalizeExpressionName(expressionName);
-        const namedExpression = this.mapping.get(normalizedExpressionName);
-        if (namedExpression) {
-            this.mapping.delete(normalizedExpressionName);
-        }
-    }
-    normalizeExpressionName(expressionName) {
-        return expressionName.toLowerCase();
-    }
-}
-class NamedExpressions {
-    constructor() {
-        this.nextNamedExpressionRow = 0;
-        this.workbookStore = new WorkbookStore();
-        this.worksheetStores = /* @__PURE__ */ new Map();
-        this.addressCache = /* @__PURE__ */ new Map();
-    }
-    isNameAvailable(expressionName, sheetId) {
-        var _a, _b;
-        if (sheetId === void 0) {
-            return this.workbookStore.isNameAvailable(expressionName);
-        }
-        else {
-            return (_b = (_a = this.worksheetStore(sheetId)) === null || _a === void 0 ? void 0 : _a.isNameAvailable(expressionName)) !== null && _b !== void 0 ? _b : true;
-        }
-    }
-    namedExpressionInAddress(row) {
-        const namedExpression = this.addressCache.get(row);
-        if (namedExpression && namedExpression.added) {
-            return namedExpression;
-        }
-        else {
-            return void 0;
-        }
-    }
-    namedExpressionForScope(expressionName, sheetId) {
-        var _a;
-        if (sheetId === void 0) {
-            return this.workbookStore.getExisting(expressionName);
-        }
-        else {
-            return (_a = this.worksheetStore(sheetId)) === null || _a === void 0 ? void 0 : _a.get(expressionName);
-        }
-    }
-    nearestNamedExpression(expressionName, sheetId) {
-        var _a, _b;
-        return (_b = (_a = this.worksheetStore(sheetId)) === null || _a === void 0 ? void 0 : _a.get(expressionName)) !== null && _b !== void 0 ? _b : this.workbookStore.getExisting(expressionName);
-    }
-    isExpressionInScope(expressionName, sheetId) {
-        var _a, _b;
-        return (_b = (_a = this.worksheetStore(sheetId)) === null || _a === void 0 ? void 0 : _a.has(expressionName)) !== null && _b !== void 0 ? _b : false;
-    }
-    /**
-     * Checks the validity of a named-expression's name.
-     *
-     * The name:
-     * - Must start with a Unicode letter or with an underscore (`_`).
-     * - Can contain only Unicode letters, numbers, underscores, and periods (`.`).
-     * - Can't be the same as any possible reference in the A1 notation (`[A-Za-z]+[0-9]+`).
-     * - Can't be the same as any possible reference in the R1C1 notation (`[rR][0-9]*[cC][0-9]*`).
-     *
-     * The naming rules follow the [OpenDocument](https://docs.oasis-open.org/office/OpenDocument/v1.3/os/part4-formula/OpenDocument-v1.3-os-part4-formula.html#__RefHeading__1017964_715980110) standard.
-     */
-    isNameValid(expressionName) {
-        const a1CellRefRegexp = new RegExp(`^${CELL_REFERENCE_PATTERN}$`);
-        const r1c1CellRefRegexp = new RegExp(`^${R1C1_CELL_REFERENCE_PATTERN}$`);
-        const namedExpRegexp = new RegExp(`^${NAMED_EXPRESSION_PATTERN}$`);
-        if (a1CellRefRegexp.test(expressionName) || r1c1CellRefRegexp.test(expressionName)) {
-            return false;
-        }
-        return namedExpRegexp.test(expressionName);
-    }
-    addNamedExpression(expressionName, sheetId, options) {
-        const store2 = sheetId === void 0 ? this.workbookStore : this.worksheetStoreOrCreate(sheetId);
-        let namedExpression = store2.get(expressionName);
-        if (namedExpression !== void 0) {
-            namedExpression.added = true;
-            namedExpression.displayName = expressionName;
-            namedExpression.options = options;
-        }
-        else {
-            namedExpression = new InternalNamedExpression(expressionName, this.nextAddress(), true, options);
-            store2.add(namedExpression);
-        }
-        this.addressCache.set(namedExpression.address.row, namedExpression);
-        return namedExpression;
-    }
-    restoreNamedExpression(namedExpression, sheetId) {
-        const store2 = sheetId === void 0 ? this.workbookStore : this.worksheetStoreOrCreate(sheetId);
-        namedExpression.added = true;
-        store2.add(namedExpression);
-        this.addressCache.set(namedExpression.address.row, namedExpression);
-        return namedExpression;
-    }
-    namedExpressionOrPlaceholder(expressionName, sheetId) {
-        var _a;
-        return (_a = this.worksheetStoreOrCreate(sheetId).get(expressionName)) !== null && _a !== void 0 ? _a : this.workbookNamedExpressionOrPlaceholder(expressionName);
-    }
-    workbookNamedExpressionOrPlaceholder(expressionName) {
-        let namedExpression = this.workbookStore.get(expressionName);
-        if (namedExpression === void 0) {
-            namedExpression = new InternalNamedExpression(expressionName, this.nextAddress(), false);
-            this.workbookStore.add(namedExpression);
-        }
-        return namedExpression;
-    }
-    remove(expressionName, sheetId) {
-        let store2;
-        if (sheetId === void 0) {
-            store2 = this.workbookStore;
-        }
-        else {
-            store2 = this.worksheetStore(sheetId);
-        }
-        const namedExpression = store2 === null || store2 === void 0 ? void 0 : store2.get(expressionName);
-        if (store2 === void 0 || namedExpression === void 0 || !namedExpression.added) {
-            throw Error("Named expression does not exist");
-        }
-        store2.remove(expressionName);
-        if (store2 instanceof WorksheetStore && store2.mapping.size === 0) {
-            this.worksheetStores.delete(sheetId);
-        }
-        this.addressCache.delete(namedExpression.address.row);
-    }
-    getAllNamedExpressionsNamesInScope(sheetId) {
-        return this.getAllNamedExpressions().filter(({ scope }) => scope === sheetId).map((ne) => ne.expression.displayName);
-    }
-    getAllNamedExpressionsNames() {
-        return this.getAllNamedExpressions().map((ne) => ne.expression.displayName);
-    }
-    getAllNamedExpressions() {
-        const storedNamedExpressions = [];
-        this.workbookStore.getAllNamedExpressions().forEach((expr) => {
-            storedNamedExpressions.push({
-                expression: expr,
-                scope: void 0
-            });
-        });
-        this.worksheetStores.forEach((store2, sheetNum) => {
-            store2.getAllNamedExpressions().forEach((expr) => {
-                storedNamedExpressions.push({
-                    expression: expr,
-                    scope: sheetNum
-                });
-            });
-        });
-        return storedNamedExpressions;
-    }
-    getAllNamedExpressionsForScope(scope) {
-        var _a, _b;
-        if (scope === void 0) {
-            return this.workbookStore.getAllNamedExpressions();
-        }
-        else {
-            return (_b = (_a = this.worksheetStores.get(scope)) === null || _a === void 0 ? void 0 : _a.getAllNamedExpressions()) !== null && _b !== void 0 ? _b : [];
-        }
-    }
-    worksheetStoreOrCreate(sheetId) {
-        let store2 = this.worksheetStores.get(sheetId);
-        if (!store2) {
-            store2 = new WorksheetStore();
-            this.worksheetStores.set(sheetId, store2);
-        }
-        return store2;
-    }
-    worksheetStore(sheetId) {
-        return this.worksheetStores.get(sheetId);
-    }
-    nextAddress() {
-        return simpleCellAddress(NamedExpressions.SHEET_FOR_WORKBOOK_EXPRESSIONS, 0, this.nextNamedExpressionRow++);
-    }
-}
-NamedExpressions.SHEET_FOR_WORKBOOK_EXPRESSIONS = -1;
-const doesContainRelativeReferences = (ast) => {
-    switch (ast.type) {
-        case AstNodeType.EMPTY:
-        case AstNodeType.NUMBER:
-        case AstNodeType.STRING:
-        case AstNodeType.ERROR:
-        case AstNodeType.ERROR_WITH_RAW_INPUT:
-            return false;
-        case AstNodeType.CELL_REFERENCE:
-            return !ast.reference.isAbsolute();
-        case AstNodeType.CELL_RANGE:
-        case AstNodeType.COLUMN_RANGE:
-        case AstNodeType.ROW_RANGE:
-            return !ast.start.isAbsolute();
-        case AstNodeType.NAMED_EXPRESSION:
-            return false;
-        case AstNodeType.PERCENT_OP:
-        case AstNodeType.PLUS_UNARY_OP:
-        case AstNodeType.MINUS_UNARY_OP: {
-            return doesContainRelativeReferences(ast.value);
-        }
-        case AstNodeType.CONCATENATE_OP:
-        case AstNodeType.EQUALS_OP:
-        case AstNodeType.NOT_EQUAL_OP:
-        case AstNodeType.LESS_THAN_OP:
-        case AstNodeType.GREATER_THAN_OP:
-        case AstNodeType.LESS_THAN_OR_EQUAL_OP:
-        case AstNodeType.GREATER_THAN_OR_EQUAL_OP:
-        case AstNodeType.MINUS_OP:
-        case AstNodeType.PLUS_OP:
-        case AstNodeType.TIMES_OP:
-        case AstNodeType.DIV_OP:
-        case AstNodeType.POWER_OP:
-            return doesContainRelativeReferences(ast.left) || doesContainRelativeReferences(ast.right);
-        case AstNodeType.PARENTHESIS:
-            return doesContainRelativeReferences(ast.expression);
-        case AstNodeType.FUNCTION_CALL: {
-            return ast.args.some((arg) => doesContainRelativeReferences(arg));
-        }
-        case AstNodeType.ARRAY: {
-            return ast.args.some((row) => row.some((arg) => doesContainRelativeReferences(arg)));
-        }
-    }
-};
 class Transformer {
     performEagerTransformations(graph, parser2) {
         for (const node2 of graph.arrayFormulaNodes()) {
@@ -83708,77 +84319,107 @@ class RemoveRowsTransformer extends Transformer {
         }
     }
 }
-class RemoveSheetTransformer extends Transformer {
-    constructor(sheet) {
+class RenameSheetTransformer extends Transformer {
+    constructor(sheetIdToKeep, sheetBeingMerged) {
         super();
-        this.sheet = sheet;
+        this.sheetIdToKeep = sheetIdToKeep;
+        this.sheetBeingMerged = sheetBeingMerged;
+    }
+    /**
+     * Returns id of sheet that survives merge operation.
+     *
+     * @returns {number} sheet identifier.
+     */
+    get sheet() {
+        return this.sheetIdToKeep;
     }
+    /**
+     * Sheet merge cannot be undone because original sheet id is lost.
+     *
+     * @returns {boolean} always true to indicate transformation irreversibility.
+     */
     isIrreversible() {
         return true;
     }
-    performEagerTransformations(graph, _parser) {
-        for (const node2 of graph.arrayFormulaNodes()) {
-            const [newAst] = this.transformSingleAst(node2.getFormula(graph.lazilyTransformingAstService), node2.getAddress(graph.lazilyTransformingAstService));
-            node2.setFormula(newAst);
-        }
-    }
-    fixNodeAddress(address) {
-        return address;
-    }
+    /**
+     * Updates cell address sheet when it points to merged sheet.
+     *
+     * @param {T} dependencyAddress - dependency address needing sheet update.
+     * @param {SimpleCellAddress} _formulaAddress - location of formula (unused but required by base class).
+     * @returns {T | false} updated address or false when nothing changes.
+     */
     transformCellAddress(dependencyAddress, _formulaAddress) {
-        return this.transformAddress(dependencyAddress);
+        return this.updateSheetInAddress(dependencyAddress);
     }
-    transformCellRange(start, _end, _formulaAddress) {
-        return this.transformAddress(start);
-    }
-    transformColumnRange(start, _end, _formulaAddress) {
-        return this.transformAddress(start);
+    /**
+     * Updates sheet for both ends of cell range.
+     *
+     * @param {CellAddress} start - start address of range.
+     * @param {CellAddress} end - end address of range.
+     * @param {SimpleCellAddress} _formulaAddress - formula location (unused).
+     * @returns {[CellAddress, CellAddress] | false} updated range tuple or false when unchanged.
+     */
+    transformCellRange(start, end, _formulaAddress) {
+        return this.transformRange(start, end);
     }
-    transformRowRange(start, _end, _formulaAddress) {
-        return this.transformAddress(start);
+    /**
+     * Updates sheet for both ends of column range.
+     *
+     * @param {ColumnAddress} start - beginning column of range.
+     * @param {ColumnAddress} end - ending column of range.
+     * @param {SimpleCellAddress} _formulaAddress - formula location (unused).
+     * @returns {[ColumnAddress, ColumnAddress] | false} updated column range or false.
+     */
+    transformColumnRange(start, end, _formulaAddress) {
+        return this.transformRange(start, end);
     }
-    transformAddress(address) {
-        if (address.sheet === this.sheet) {
-            return ErrorType.REF;
-        }
-        return false;
+    /**
+     * Updates sheet for both ends of row range.
+     *
+     * @param {RowAddress} start - beginning row address.
+     * @param {RowAddress} end - ending row address.
+     * @param {SimpleCellAddress} _formulaAddress - formula location (unused).
+     * @returns {[RowAddress, RowAddress] | false} updated row range or false.
+     */
+    transformRowRange(start, end, _formulaAddress) {
+        return this.transformRange(start, end);
     }
-}
-function validateAsSheet(sheet) {
-    if (!Array.isArray(sheet)) {
-        throw new InvalidArgumentsError("an array of arrays.");
+    /**
+     * Node addresses are already absolute, so no change is needed.
+     *
+     * @param {SimpleCellAddress} address - node address to inspect.
+     * @returns {SimpleCellAddress} original address unchanged.
+     */
+    fixNodeAddress(address) {
+        return address;
     }
-    for (let i = 0; i < sheet.length; i++) {
-        if (!Array.isArray(sheet[i])) {
-            throw new InvalidArgumentsError("an array of arrays.");
+    /**
+     * Updates sheet identifier for both range ends if needed.
+     *
+     * @param {T} start - range start address.
+     * @param {T} end - range end address.
+     * @returns {[T, T] | false} tuple with updated addresses or false when no updates happen.
+     */
+    transformRange(start, end) {
+        const newStart = this.updateSheetInAddress(start);
+        const newEnd = this.updateSheetInAddress(end);
+        if (newStart || newEnd) {
+            return [newStart || start, newEnd || end];
         }
+        return false;
     }
-}
-function findBoundaries(sheet) {
-    let width = 0;
-    let height = 0;
-    let cellsCount = 0;
-    for (let currentRow = 0; currentRow < sheet.length; currentRow++) {
-        let currentRowWidth = 0;
-        for (let currentCol = 0; currentCol < sheet[currentRow].length; currentCol++) {
-            const currentValue = sheet[currentRow][currentCol];
-            if (currentValue === void 0 || currentValue === null) {
-                continue;
-            }
-            currentRowWidth = currentCol + 1;
-            ++cellsCount;
-        }
-        width = Math.max(width, currentRowWidth);
-        if (currentRowWidth > 0) {
-            height = currentRow + 1;
+    /**
+     * Replaces sheet id in address when it points to merged sheet.
+     *
+     * @param {T} address - address to update.
+     * @returns {T | false} address with new sheet id or false when no change occurs.
+     */
+    updateSheetInAddress(address) {
+        if (address.sheet === this.sheetBeingMerged) {
+            return address.withSheet(this.sheetIdToKeep);
         }
+        return false;
     }
-    const sheetSize = width * height;
-    return {
-        height,
-        width,
-        fill: sheetSize === 0 ? 0 : cellsCount / sheetSize
-    };
 }
 class RemoveRowsCommand {
     constructor(sheet, indexes) {
@@ -83879,38 +84520,78 @@ class Operations {
         }
         return columnsRemovals;
     }
-    removeSheet(sheetId) {
-        this.dependencyGraph.removeSheet(sheetId);
-        let version = 0;
-        this.stats.measure(StatType.TRANSFORM_ASTS, () => {
-            const transformation = new RemoveSheetTransformer(sheetId);
-            transformation.performEagerTransformations(this.dependencyGraph, this.parser);
-            version = this.lazilyTransformingAstService.addTransformation(transformation);
-        });
-        this.sheetMapping.removeSheet(sheetId);
+    /**
+     * Clears the sheet content.
+     */
+    clearSheet(sheetId) {
+        this.dependencyGraph.clearSheet(sheetId);
         this.columnSearch.removeSheet(sheetId);
-        const scopedNamedExpressions = this.namedExpressions.getAllNamedExpressionsForScope(sheetId).map((namedExpression) => this.removeNamedExpression(namedExpression.normalizeExpressionName(), sheetId));
+    }
+    /**
+     * Adds a new sheet to the workbook.
+     */
+    addSheet(name) {
+        const sheetId = this.sheetMapping.addSheet(name);
+        this.dependencyGraph.addSheet(sheetId);
         return {
-            version,
-            scopedNamedExpressions
+            sheetName: this.sheetMapping.getSheetNameOrThrowError(sheetId),
+            sheetId
         };
     }
-    removeSheetByName(sheetName) {
-        const sheetId = this.sheetMapping.fetch(sheetName);
-        return this.removeSheet(sheetId);
+    /**
+     * Adds a sheet with a specific ID for redo operations.
+     */
+    addSheetWithId(sheetId, name) {
+        this.sheetMapping.addSheetWithId(sheetId, name);
+        this.dependencyGraph.addSheet(sheetId);
     }
-    clearSheet(sheetId) {
-        this.dependencyGraph.clearSheet(sheetId);
+    /**
+     * Adds a placeholder sheet with a specific ID for undo operations.
+     * Used to restore previously merged placeholder sheets.
+     *
+     * Note: Unlike `addSheetWithId`, this does NOT call `dependencyGraph.addSheet()`
+     * because placeholders don't need dirty marking or strategy changes - they only
+     * need to exist in the mappings so formulas can reference them again.
+     */
+    addPlaceholderSheetWithId(sheetId, name) {
+        this.sheetMapping.addPlaceholderWithId(sheetId, name);
+        this.addressMapping.addSheetStrategyPlaceholderIfNotExists(sheetId);
+    }
+    /**
+     * Removes a sheet from the workbook.
+     */
+    removeSheet(sheetId) {
+        this.dependencyGraph.removeSheet(sheetId);
         this.columnSearch.removeSheet(sheetId);
+        const scopedNamedExpressions = this.namedExpressions.getAllNamedExpressionsForScope(sheetId).map((namedExpression) => this.removeNamedExpression(namedExpression.normalizeExpressionName(), sheetId));
+        return scopedNamedExpressions;
     }
-    addSheet(name) {
-        const sheetId = this.sheetMapping.addSheet(name);
-        const sheet = [];
-        this.dependencyGraph.addressMapping.autoAddSheet(sheetId, findBoundaries(sheet));
-        return this.sheetMapping.fetchDisplayName(sheetId);
+    /**
+     * Removes a sheet from the workbook by name.
+     */
+    removeSheetByName(sheetName) {
+        const sheetId = this.sheetMapping.getSheetIdOrThrowError(sheetName);
+        return this.removeSheet(sheetId);
     }
+    /**
+     * Renames a sheet in the workbook.
+     */
     renameSheet(sheetId, newName) {
-        return this.sheetMapping.renameSheet(sheetId, newName);
+        const { previousDisplayName, mergedWithPlaceholderSheet } = this.sheetMapping.renameSheet(sheetId, newName);
+        let version;
+        if (mergedWithPlaceholderSheet !== void 0) {
+            this.dependencyGraph.mergeSheets(sheetId, mergedWithPlaceholderSheet);
+            this.stats.measure(StatType.TRANSFORM_ASTS, () => {
+                const transformation = new RenameSheetTransformer(sheetId, mergedWithPlaceholderSheet);
+                transformation.performEagerTransformations(this.dependencyGraph, this.parser);
+                version = this.lazilyTransformingAstService.addTransformation(transformation);
+            });
+        }
+        return {
+            previousDisplayName,
+            version,
+            mergedPlaceholderSheetId: mergedWithPlaceholderSheet
+        };
     }
     moveRows(sheet, startRow, numberOfRows, targetRow) {
         const rowsToAdd = RowsSpan.fromNumberOfRows(sheet, targetRow, numberOfRows);
@@ -84049,7 +84730,7 @@ class Operations {
         return [namedExpression, content];
     }
     ensureItIsPossibleToMoveCells(sourceLeftCorner, width, height, destinationLeftCorner) {
-        if (invalidSimpleCellAddress(sourceLeftCorner) || !(isPositiveInteger$1(width) && isPositiveInteger$1(height) || isRowOrColumnRange(sourceLeftCorner, width, height)) || invalidSimpleCellAddress(destinationLeftCorner) || !this.sheetMapping.hasSheetWithId(sourceLeftCorner.sheet) || !this.sheetMapping.hasSheetWithId(destinationLeftCorner.sheet)) {
+        if (isColOrRowInvalid(sourceLeftCorner) || !(isPositiveInteger$1(width) && isPositiveInteger$1(height) || isRowOrColumnRange(sourceLeftCorner, width, height)) || isColOrRowInvalid(destinationLeftCorner) || !this.sheetMapping.hasSheetWithId(sourceLeftCorner.sheet) || !this.sheetMapping.hasSheetWithId(destinationLeftCorner.sheet)) {
             throw new InvalidArgumentsError("a valid range of cells to move.");
         }
         const sourceRange = AbsoluteCellRange.spanFrom(sourceLeftCorner, width, height);
@@ -84077,8 +84758,6 @@ class Operations {
     }
     /**
      * Restores a single cell.
-     * @param {SimpleCellAddress} address
-     * @param {ClipboardCell} clipboardCell
      */
     restoreCell(address, clipboardCell) {
         switch (clipboardCell.type) {
@@ -84139,7 +84818,7 @@ class Operations {
                 type: ClipboardCellType.VALUE
             }, vertex.getValues());
         }
-        else if (vertex instanceof ArrayVertex) {
+        else if (vertex instanceof ArrayFormulaVertex) {
             const val2 = vertex.getArrayCellValue(address);
             if (val2 === EmptyValue) {
                 return {
@@ -84152,7 +84831,7 @@ class Operations {
                 rawValue: vertex.getArrayCellRawValue(address)
             };
         }
-        else if (vertex instanceof FormulaCellVertex) {
+        else if (vertex instanceof ScalarFormulaVertex) {
             return {
                 type: ClipboardCellType.FORMULA,
                 hash: this.parser.computeHashFromAst(vertex.getFormula(this.lazilyTransformingAstService))
@@ -84236,37 +84915,49 @@ class Operations {
             }
         }
     }
+    /**
+     * Sets cell content to an instance of parsing error.
+     * Creates a ParsingErrorVertex and updates the dependency graph and column search index.
+     */
     setParsingErrorToCell(rawInput, errors2, address) {
-        const oldValue = this.dependencyGraph.getCellValue(address);
+        this.removeCellValueFromColumnSearch(address);
         const vertex = new ParsingErrorVertex(errors2, rawInput);
         const arrayChanges = this.dependencyGraph.setParsingErrorToCell(address, vertex);
-        this.columnSearch.remove(getRawValue(oldValue), address);
         this.columnSearch.applyChanges(arrayChanges.getChanges());
         this.changes.addAll(arrayChanges);
         this.changes.addChange(vertex.getCellValue(), address);
     }
+    /**
+     * Sets cell content to a formula.
+     * Creates a ScalarFormulaVertex and updates the dependency graph and column search index.
+     */
     setFormulaToCell(address, size2, { ast, hasVolatileFunction, hasStructuralChangeFunction, dependencies }) {
-        const oldValue = this.dependencyGraph.getCellValue(address);
+        this.removeCellValueFromColumnSearch(address);
         const arrayChanges = this.dependencyGraph.setFormulaToCell(address, ast, absolutizeDependencies(dependencies, address), size2, hasVolatileFunction, hasStructuralChangeFunction);
-        this.columnSearch.remove(getRawValue(oldValue), address);
         this.columnSearch.applyChanges(arrayChanges.getChanges());
         this.changes.addAll(arrayChanges);
     }
+    /**
+     * Sets cell content to a value.
+     * Creates a ValueCellVertex and updates the dependency graph and column search index.
+     */
     setValueToCell(value, address) {
-        const oldValue = this.dependencyGraph.getCellValue(address);
+        this.changeCellValueInColumnSearch(address, value.parsedValue);
         const arrayChanges = this.dependencyGraph.setValueToCell(address, value);
-        this.columnSearch.change(getRawValue(oldValue), getRawValue(value.parsedValue), address);
         this.columnSearch.applyChanges(arrayChanges.getChanges().filter((change) => !equalSimpleCellAddress(change.address, address)));
         this.changes.addAll(arrayChanges);
         this.changes.addChange(value.parsedValue, address);
     }
+    /**
+     * Sets cell content to an empty value.
+     * Creates an EmptyCellVertex and updates the dependency graph and column search index.
+     */
     setCellEmpty(address) {
         if (this.dependencyGraph.isArrayInternalCell(address)) {
             return;
         }
-        const oldValue = this.dependencyGraph.getCellValue(address);
+        this.removeCellValueFromColumnSearch(address);
         const arrayChanges = this.dependencyGraph.setCellEmpty(address);
-        this.columnSearch.remove(getRawValue(oldValue), address);
         this.columnSearch.applyChanges(arrayChanges.getChanges());
         this.changes.addAll(arrayChanges);
         this.changes.addChange(EmptyValue, address);
@@ -84286,7 +84977,7 @@ class Operations {
      * @param {number} sheet - sheet ID number
      */
     rowEffectivelyNotInSheet(row, sheet) {
-        const height = this.dependencyGraph.addressMapping.getHeight(sheet);
+        const height = this.dependencyGraph.addressMapping.getSheetHeight(sheet);
         return row >= height;
     }
     getAndClearContentChanges() {
@@ -84415,7 +85106,7 @@ class Operations {
      * @param {number} sheet - sheet ID number
      */
     columnEffectivelyNotInSheet(column, sheet) {
-        const width = this.dependencyGraph.addressMapping.getWidth(sheet);
+        const width = this.dependencyGraph.addressMapping.getSheetWidth(sheet);
         return column >= width;
     }
     adjustNamedExpressionEdges(namedExpression, expressionName, sheetId) {
@@ -84428,7 +85119,7 @@ class Operations {
         const { vertex: globalVertex, id: maybeGlobalVertexId } = this.dependencyGraph.fetchCellOrCreateEmpty(globalNamedExpression.address);
         const globalVertexId = maybeGlobalVertexId !== null && maybeGlobalVertexId !== void 0 ? maybeGlobalVertexId : this.dependencyGraph.graph.getNodeId(globalVertex);
         for (const adjacentNode of this.dependencyGraph.graph.adjacentNodes(globalVertex)) {
-            if (adjacentNode instanceof FormulaCellVertex && adjacentNode.getAddress(this.lazilyTransformingAstService).sheet === sheetId) {
+            if (adjacentNode instanceof ScalarFormulaVertex && adjacentNode.getAddress(this.lazilyTransformingAstService).sheet === sheetId) {
                 const ast = adjacentNode.getFormula(this.lazilyTransformingAstService);
                 const formulaAddress = adjacentNode.getAddress(this.lazilyTransformingAstService);
                 const { dependencies } = this.parser.fetchCachedResultForAst(ast);
@@ -84468,8 +85159,10 @@ class Operations {
         const addedGlobalNamedExpressions = [];
         const targetRange = AbsoluteCellRange.spanFrom(destinationLeftCorner, width, height);
         for (const formulaAddress of targetRange.addresses(this.dependencyGraph)) {
-            const vertex = this.addressMapping.fetchCell(formulaAddress);
-            if (vertex instanceof FormulaCellVertex && formulaAddress.sheet !== sourceLeftCorner.sheet) {
+            const vertex = this.addressMapping.getCell(formulaAddress, {
+                throwIfCellNotExists: true
+            });
+            if (vertex instanceof ScalarFormulaVertex && formulaAddress.sheet !== sourceLeftCorner.sheet) {
                 const ast = vertex.getFormula(this.lazilyTransformingAstService);
                 const { dependencies } = this.parser.fetchCachedResultForAst(ast);
                 addedGlobalNamedExpressions.push(...this.updateNamedExpressionsForTargetAddress(sourceLeftCorner.sheet, formulaAddress, dependencies));
@@ -84482,7 +85175,7 @@ class Operations {
             return [];
         }
         const addedGlobalNamedExpressions = [];
-        const vertex = this.addressMapping.fetchCell(targetAddress);
+        const vertex = this.addressMapping.getCellOrThrow(targetAddress);
         for (const namedExpressionDependency of absolutizeDependencies(dependencies, targetAddress)) {
             if (!(namedExpressionDependency instanceof NamedExpressionDependency)) {
                 continue;
@@ -84499,14 +85192,14 @@ class Operations {
         return addedGlobalNamedExpressions;
     }
     allocateNamedExpressionAddressSpace() {
-        this.dependencyGraph.addressMapping.addSheet(NamedExpressions.SHEET_FOR_WORKBOOK_EXPRESSIONS, new SparseStrategy(0, 0));
+        this.dependencyGraph.addressMapping.addSheetWithStrategy(NamedExpressions.SHEET_FOR_WORKBOOK_EXPRESSIONS, new SparseStrategy(0, 0));
     }
     copyOrFetchGlobalNamedExpressionVertex(expressionName, sourceVertex, addedNamedExpressions) {
         let expression = this.namedExpressions.namedExpressionForScope(expressionName);
         if (expression === void 0) {
             expression = this.namedExpressions.addNamedExpression(expressionName);
             addedNamedExpressions.push(expression.normalizeExpressionName());
-            if (sourceVertex instanceof FormulaCellVertex) {
+            if (sourceVertex instanceof ScalarFormulaVertex) {
                 const parsingResult = this.parser.fetchCachedResultForAst(sourceVertex.getFormula(this.lazilyTransformingAstService));
                 const { ast, hasVolatileFunction, hasStructuralChangeFunction, dependencies } = parsingResult;
                 this.dependencyGraph.setFormulaToCell(expression.address, ast, absolutizeDependencies(dependencies, expression.address), ArraySize.scalar(), hasVolatileFunction, hasStructuralChangeFunction);
@@ -84520,6 +85213,38 @@ class Operations {
         }
         return this.dependencyGraph.fetchCellOrCreateEmpty(expression.address).vertex;
     }
+    /**
+     * Removes a cell value from the columnSearch index.
+     * Ignores the non-computed formula vertices.
+     */
+    removeCellValueFromColumnSearch(address) {
+        if (this.isNotComputed(address)) {
+            return;
+        }
+        const oldValue = this.dependencyGraph.getCellValue(address);
+        this.columnSearch.remove(getRawValue(oldValue), address);
+    }
+    /**
+     * Changes a cell value in the columnSearch index.
+     * Ignores the non-computed formula vertices.
+     */
+    changeCellValueInColumnSearch(address, newValue) {
+        if (this.isNotComputed(address)) {
+            return;
+        }
+        const oldValue = this.dependencyGraph.getCellValue(address);
+        this.columnSearch.change(getRawValue(oldValue), getRawValue(newValue), address);
+    }
+    /**
+     * Checks if the ScalarFormulaVertex or ArrayFormulaVertex at the given address is not computed.
+     */
+    isNotComputed(address) {
+        const vertex = this.dependencyGraph.getCell(address);
+        if (!vertex) {
+            return false;
+        }
+        return "isComputed" in vertex && !vertex.isComputed();
+    }
 }
 function normalizeRemovedIndexes(indexes) {
     if (indexes.length <= 1) {
@@ -84721,9 +85446,10 @@ class RemoveColumnsUndoEntry extends BaseUndoEntry {
     }
 }
 class AddSheetUndoEntry extends BaseUndoEntry {
-    constructor(sheetName) {
+    constructor(sheetName, sheetId) {
         super();
         this.sheetName = sheetName;
+        this.sheetId = sheetId;
     }
     doUndo(undoRedo) {
         undoRedo.undoAddSheet(this);
@@ -84733,13 +85459,12 @@ class AddSheetUndoEntry extends BaseUndoEntry {
     }
 }
 class RemoveSheetUndoEntry extends BaseUndoEntry {
-    constructor(sheetName, sheetId, oldSheetContent, scopedNamedExpressions, version) {
+    constructor(sheetName, sheetId, oldSheetContent, scopedNamedExpressions) {
         super();
         this.sheetName = sheetName;
         this.sheetId = sheetId;
         this.oldSheetContent = oldSheetContent;
         this.scopedNamedExpressions = scopedNamedExpressions;
-        this.version = version;
     }
     doUndo(undoRedo) {
         undoRedo.undoRemoveSheet(this);
@@ -84749,11 +85474,13 @@ class RemoveSheetUndoEntry extends BaseUndoEntry {
     }
 }
 class RenameSheetUndoEntry extends BaseUndoEntry {
-    constructor(sheetId, oldName, newName) {
+    constructor(sheetId, oldName, newName, version, mergedPlaceholderSheetId) {
         super();
         this.sheetId = sheetId;
         this.oldName = oldName;
         this.newName = newName;
+        this.version = version;
+        this.mergedPlaceholderSheetId = mergedPlaceholderSheetId;
     }
     doUndo(undoRedo) {
         undoRedo.undoRenameSheet(this);
@@ -85004,8 +85731,8 @@ class UndoRedo {
     }
     undoRemoveSheet(operation) {
         this.operations.forceApplyPostponedTransformations();
-        const { oldSheetContent, sheetId } = operation;
-        this.operations.addSheet(operation.sheetName);
+        const { oldSheetContent, sheetId, scopedNamedExpressions, sheetName } = operation;
+        this.operations.addSheetWithId(sheetId, sheetName);
         for (let rowIndex = 0; rowIndex < oldSheetContent.length; rowIndex++) {
             const row = oldSheetContent[rowIndex];
             for (let col = 0; col < row.length; col++) {
@@ -85014,13 +85741,17 @@ class UndoRedo {
                 this.operations.restoreCell(address, cellType);
             }
         }
-        for (const [namedexpression, content] of operation.scopedNamedExpressions) {
+        for (const [namedexpression, content] of scopedNamedExpressions) {
             this.operations.restoreNamedExpression(namedexpression, content, sheetId);
         }
-        this.restoreOldDataFromVersion(operation.version - 1);
     }
     undoRenameSheet(operation) {
+        this.operations.forceApplyPostponedTransformations();
         this.operations.renameSheet(operation.sheetId, operation.oldName);
+        if (operation.mergedPlaceholderSheetId !== void 0 && operation.version !== void 0) {
+            this.operations.addPlaceholderSheetWithId(operation.mergedPlaceholderSheetId, operation.newName);
+            this.restoreOldDataFromVersion(operation.version - 1);
+        }
     }
     undoClearSheet(operation) {
         const { oldSheetContent, sheetId } = operation;
@@ -85108,7 +85839,7 @@ class UndoRedo {
         this.operations.removeSheetByName(operation.sheetName);
     }
     redoAddSheet(operation) {
-        this.operations.addSheet(operation.sheetName);
+        this.operations.addSheetWithId(operation.sheetId, operation.sheetName);
     }
     redoRenameSheet(operation) {
         this.operations.renameSheet(operation.sheetId, operation.newName);
@@ -85281,27 +86012,27 @@ class CrudOperations {
             this.ensureItIsPossibleToAddSheet(name);
         }
         this.undoRedo.clearRedoStack();
-        const addedSheetName = this.operations.addSheet(name);
-        this.undoRedo.saveOperation(new AddSheetUndoEntry(addedSheetName));
-        return addedSheetName;
+        const { sheetName, sheetId } = this.operations.addSheet(name);
+        this.undoRedo.saveOperation(new AddSheetUndoEntry(sheetName, sheetId));
+        return sheetName;
     }
     removeSheet(sheetId) {
         this.ensureScopeIdIsValid(sheetId);
         this.undoRedo.clearRedoStack();
         this.clipboardOperations.abortCut();
-        const originalName = this.sheetMapping.fetchDisplayName(sheetId);
+        const originalName = this.sheetMapping.getSheetNameOrThrowError(sheetId);
         const oldSheetContent = this.operations.getSheetClipboardCells(sheetId);
-        const { version, scopedNamedExpressions } = this.operations.removeSheet(sheetId);
-        this.undoRedo.saveOperation(new RemoveSheetUndoEntry(originalName, sheetId, oldSheetContent, scopedNamedExpressions, version));
+        const scopedNamedExpressions = this.operations.removeSheet(sheetId);
+        this.undoRedo.saveOperation(new RemoveSheetUndoEntry(originalName, sheetId, oldSheetContent, scopedNamedExpressions));
     }
     renameSheet(sheetId, newName) {
         this.ensureItIsPossibleToRenameSheet(sheetId, newName);
-        const oldName = this.operations.renameSheet(sheetId, newName);
-        if (oldName !== void 0) {
+        const { previousDisplayName, version, mergedPlaceholderSheetId } = this.operations.renameSheet(sheetId, newName);
+        if (previousDisplayName !== void 0) {
             this.undoRedo.clearRedoStack();
-            this.undoRedo.saveOperation(new RenameSheetUndoEntry(sheetId, oldName, newName));
+            this.undoRedo.saveOperation(new RenameSheetUndoEntry(sheetId, previousDisplayName, newName, version, mergedPlaceholderSheetId));
         }
-        return oldName;
+        return previousDisplayName;
     }
     clearSheet(sheetId) {
         this.ensureScopeIdIsValid(sheetId);
@@ -85542,7 +86273,7 @@ class CrudOperations {
         this.ensureItIsPossibleToAddRows(sheet, [targetRow, numberOfRows]);
         const sourceStart = simpleCellAddress(sheet, 0, startRow);
         const targetStart = simpleCellAddress(sheet, 0, targetRow);
-        if (!this.sheetMapping.hasSheetWithId(sheet) || invalidSimpleCellAddress(sourceStart) || invalidSimpleCellAddress(targetStart) || !isPositiveInteger(numberOfRows) || targetRow <= startRow + numberOfRows && targetRow >= startRow) {
+        if (!this.sheetMapping.hasSheetWithId(sheet) || isColOrRowInvalid(sourceStart) || isColOrRowInvalid(targetStart) || !isPositiveInteger(numberOfRows) || targetRow <= startRow + numberOfRows && targetRow >= startRow) {
             throw new InvalidArgumentsError("a valid range of rows to move.");
         }
         const width = this.dependencyGraph.getSheetWidth(sheet);
@@ -85558,7 +86289,7 @@ class CrudOperations {
         this.ensureItIsPossibleToAddColumns(sheet, [targetColumn, numberOfColumns]);
         const sourceStart = simpleCellAddress(sheet, startColumn, 0);
         const targetStart = simpleCellAddress(sheet, targetColumn, 0);
-        if (!this.sheetMapping.hasSheetWithId(sheet) || invalidSimpleCellAddress(sourceStart) || invalidSimpleCellAddress(targetStart) || !isPositiveInteger(numberOfColumns) || targetColumn <= startColumn + numberOfColumns && targetColumn >= startColumn) {
+        if (!this.sheetMapping.hasSheetWithId(sheet) || isColOrRowInvalid(sourceStart) || isColOrRowInvalid(targetStart) || !isPositiveInteger(numberOfColumns) || targetColumn <= startColumn + numberOfColumns && targetColumn >= startColumn) {
             throw new InvalidArgumentsError("a valid range of columns to move.");
         }
         const sheetHeight = this.dependencyGraph.getSheetHeight(sheet);
@@ -85579,13 +86310,13 @@ class CrudOperations {
         if (!this.sheetMapping.hasSheetWithId(sheetId)) {
             throw new NoSheetWithIdError(sheetId);
         }
-        const existingSheetId = this.sheetMapping.get(name);
+        const existingSheetId = this.sheetMapping.getSheetId(name);
         if (existingSheetId !== void 0 && existingSheetId !== sheetId) {
             throw new SheetNameAlreadyTakenError(name);
         }
     }
     ensureItIsPossibleToChangeContent(address) {
-        if (invalidSimpleCellAddress(address)) {
+        if (isColOrRowInvalid(address)) {
             throw new InvalidAddressError(address);
         }
         if (!this.sheetMapping.hasSheetWithId(address.sheet)) {
@@ -85684,37 +86415,7 @@ class Evaluator {
     partialRun(vertices) {
         const changes = ContentChanges.empty();
         this.stats.measure(StatType.EVALUATION, () => {
-            this.dependencyGraph.graph.getTopSortedWithSccSubgraphFrom(vertices, (vertex) => {
-                if (vertex instanceof FormulaVertex) {
-                    const currentValue = vertex.isComputed() ? vertex.getCellValue() : void 0;
-                    const newCellValue = this.recomputeFormulaVertexValue(vertex);
-                    if (newCellValue !== currentValue) {
-                        const address = vertex.getAddress(this.lazilyTransformingAstService);
-                        changes.addChange(newCellValue, address);
-                        this.columnSearch.change(getRawValue(currentValue), getRawValue(newCellValue), address);
-                        return true;
-                    }
-                    return false;
-                }
-                else if (vertex instanceof RangeVertex) {
-                    vertex.clearCache();
-                    return true;
-                }
-                else {
-                    return true;
-                }
-            }, (vertex) => {
-                if (vertex instanceof RangeVertex) {
-                    vertex.clearCache();
-                }
-                else if (vertex instanceof FormulaVertex) {
-                    const address = vertex.getAddress(this.lazilyTransformingAstService);
-                    this.columnSearch.remove(getRawValue(vertex.valueOrUndef()), address);
-                    const error = new CellError(ErrorType.CYCLE, void 0, vertex);
-                    vertex.setCellValue(error);
-                    changes.addChange(error, address);
-                }
-            });
+            this.dependencyGraph.graph.getTopSortedWithSccSubgraphFrom(vertices, (vertex) => this.recomputeVertex(vertex, changes), (vertex) => this.processVertexOnCycle(vertex, changes));
         });
         return changes;
     }
@@ -85725,17 +86426,55 @@ class Evaluator {
                 const range2 = dep;
                 if (this.dependencyGraph.getRange(range2.start, range2.end) === void 0) {
                     const rangeVertex = new RangeVertex(range2);
-                    this.dependencyGraph.rangeMapping.setRange(rangeVertex);
+                    this.dependencyGraph.rangeMapping.addOrUpdateVertex(rangeVertex);
                     tmpRanges.push(rangeVertex);
                 }
             }
         }
         const ret = this.evaluateAstToCellValue(ast, new InterpreterState(address, this.config.useArrayArithmetic));
         tmpRanges.forEach((rangeVertex) => {
-            this.dependencyGraph.rangeMapping.removeRange(rangeVertex);
+            this.dependencyGraph.rangeMapping.removeVertexIfExists(rangeVertex);
         });
         return ret;
     }
+    /**
+     * Recalculates the value of a single vertex assuming its dependencies have already been recalculated
+     */
+    recomputeVertex(vertex, changes) {
+        if (vertex instanceof FormulaVertex) {
+            const currentValue = vertex.isComputed() ? vertex.getCellValue() : void 0;
+            const newCellValue = this.recomputeFormulaVertexValue(vertex);
+            if (newCellValue !== currentValue) {
+                const address = vertex.getAddress(this.lazilyTransformingAstService);
+                changes.addChange(newCellValue, address);
+                this.columnSearch.change(getRawValue(currentValue), getRawValue(newCellValue), address);
+                return true;
+            }
+            return false;
+        }
+        else if (vertex instanceof RangeVertex) {
+            vertex.clearCache();
+            return true;
+        }
+        else {
+            return true;
+        }
+    }
+    /**
+     * Processes a vertex that is part of a cycle in dependency graph
+     */
+    processVertexOnCycle(vertex, changes) {
+        if (vertex instanceof RangeVertex) {
+            vertex.clearCache();
+        }
+        else if (vertex instanceof FormulaVertex) {
+            const address = vertex.getAddress(this.lazilyTransformingAstService);
+            this.columnSearch.remove(getRawValue(vertex.valueOrUndef()), address);
+            const error = new CellError(ErrorType.CYCLE, void 0, vertex);
+            vertex.setCellValue(error);
+            changes.addChange(error, address);
+        }
+    }
     /**
      * Recalculates formulas in the topological sort order
      */
@@ -85758,7 +86497,7 @@ class Evaluator {
     }
     recomputeFormulaVertexValue(vertex) {
         const address = vertex.getAddress(this.lazilyTransformingAstService);
-        if (vertex instanceof ArrayVertex && (vertex.array.size.isRef || !this.dependencyGraph.isThereSpaceForArray(vertex))) {
+        if (vertex instanceof ArrayFormulaVertex && (vertex.array.size.isRef || !this.dependencyGraph.isThereSpaceForArray(vertex))) {
             return vertex.setNoSpace();
         }
         else {
@@ -85805,10 +86544,10 @@ class ExportedNamedExpressionChange {
     }
 }
 class Exporter {
-    constructor(config2, namedExpressions, sheetIndexMapping, lazilyTransformingService) {
+    constructor(config2, namedExpressions, sheetMapping, lazilyTransformingService) {
         this.config = config2;
         this.namedExpressions = namedExpressions;
-        this.sheetIndexMapping = sheetIndexMapping;
+        this.sheetMapping = sheetMapping;
         this.lazilyTransformingService = lazilyTransformingService;
     }
     exportChange(change) {
@@ -85866,7 +86605,7 @@ class Exporter {
                 address = (_b = this.namedExpressions.namedExpressionInAddress(originAddress.row)) === null || _b === void 0 ? void 0 : _b.displayName;
             }
             else {
-                address = simpleCellAddressToString(this.sheetIndexMapping, originAddress, -1);
+                address = simpleCellAddressToString(this.sheetMapping.getSheetNameOrThrowError.bind(this.sheetMapping), originAddress, -1);
             }
         }
         return new DetailedCellError(error, this.config.translationPackage.getErrorTranslation(error.type), address);
@@ -85943,7 +86682,7 @@ class SimpleStrategy {
                             this.shrinkArrayIfNeeded(address);
                             const size2 = this.arraySizePredictor.checkArraySize(parseResult.ast, address);
                             if (size2.isScalar()) {
-                                const vertex = new FormulaCellVertex(parseResult.ast, address, 0);
+                                const vertex = new ScalarFormulaVertex(parseResult.ast, address, 0);
                                 dependencies.set(vertex, absolutizeDependencies(parseResult.dependencies, address));
                                 this.dependencyGraph.addVertex(address, vertex);
                                 if (parseResult.hasVolatileFunction) {
@@ -85954,7 +86693,7 @@ class SimpleStrategy {
                                 }
                             }
                             else {
-                                const vertex = new ArrayVertex(parseResult.ast, address, new ArraySize(size2.width, size2.height));
+                                const vertex = new ArrayFormulaVertex(parseResult.ast, address, new ArraySize(size2.width, size2.height));
                                 dependencies.set(vertex, absolutizeDependencies(parseResult.dependencies, address));
                                 this.dependencyGraph.addArrayVertex(address, vertex);
                             }
@@ -85975,7 +86714,7 @@ class SimpleStrategy {
     }
     shrinkArrayIfNeeded(address) {
         const vertex = this.dependencyGraph.getCell(address);
-        if (vertex instanceof ArrayVertex) {
+        if (vertex instanceof ArrayFormulaVertex) {
             this.dependencyGraph.shrinkArrayToCorner(vertex);
         }
     }
@@ -86476,8 +87215,8 @@ class Interpreter {
     /**
      * Calculates cell value from formula abstract syntax tree
      *
-     * @param formula - abstract syntax tree of formula
-     * @param formulaAddress - address of the cell in which formula is located
+     * @param {Ast} ast - abstract syntax tree of formula
+     * @param {InterpreterState} state - interpreter state
      */
     evaluateAstWithoutPostprocessing(ast, state) {
         switch (ast.type) {
@@ -86486,9 +87225,12 @@ class Interpreter {
             }
             case AstNodeType.CELL_REFERENCE: {
                 const address = ast.reference.toSimpleCellAddress(state.formulaAddress);
-                if (invalidSimpleCellAddress(address)) {
+                if (isColOrRowInvalid(address)) {
                     return new CellError(ErrorType.REF, ErrorMessage.BadRef);
                 }
+                if (!this.isSheetValid(ast.reference)) {
+                    return new CellError(ErrorType.REF, ErrorMessage.SheetRef);
+                }
                 return this.dependencyGraph.getCellValue(address);
             }
             case AstNodeType.NUMBER:
@@ -86589,6 +87331,9 @@ class Interpreter {
                 }
             }
             case AstNodeType.CELL_RANGE: {
+                if (!this.isSheetValid(ast.start) || !this.isSheetValid(ast.end)) {
+                    return new CellError(ErrorType.REF, ErrorMessage.SheetRef);
+                }
                 if (!this.rangeSpansOneSheet(ast)) {
                     return new CellError(ErrorType.REF, ErrorMessage.RangeManySheets);
                 }
@@ -86609,11 +87354,12 @@ class Interpreter {
                         throw new Error("Unknown array");
                     }
                 }
-                else {
-                    return SimpleRangeValue.onlyRange(range2, this.dependencyGraph);
-                }
+                return SimpleRangeValue.onlyRange(range2, this.dependencyGraph);
             }
             case AstNodeType.COLUMN_RANGE: {
+                if (!this.isSheetValid(ast.start) || !this.isSheetValid(ast.end)) {
+                    return new CellError(ErrorType.REF, ErrorMessage.SheetRef);
+                }
                 if (!this.rangeSpansOneSheet(ast)) {
                     return new CellError(ErrorType.REF, ErrorMessage.RangeManySheets);
                 }
@@ -86621,6 +87367,9 @@ class Interpreter {
                 return SimpleRangeValue.onlyRange(range2, this.dependencyGraph);
             }
             case AstNodeType.ROW_RANGE: {
+                if (!this.isSheetValid(ast.start) || !this.isSheetValid(ast.end)) {
+                    return new CellError(ErrorType.REF, ErrorMessage.SheetRef);
+                }
                 if (!this.rangeSpansOneSheet(ast)) {
                     return new CellError(ErrorType.REF, ErrorMessage.RangeManySheets);
                 }
@@ -86672,6 +87421,18 @@ class Interpreter {
             }
         }
     }
+    /**
+     * Sheet is valid if:
+     * - sheet is undefined OR
+     * - sheet is a named expressions store OR
+     * - sheet exists in sheet mapping
+     * - sheet is not a placeholder
+     */
+    isSheetValid(address) {
+        return address.sheet === void 0 || address.sheet === NamedExpressions.SHEET_FOR_WORKBOOK_EXPRESSIONS || this.dependencyGraph.sheetMapping.hasSheetWithId(address.sheet, {
+            includePlaceholders: false
+        });
+    }
     rangeSpansOneSheet(ast) {
         return ast.start.sheet === ast.end.sheet;
     }
@@ -87357,7 +88118,7 @@ class Serialization {
     }
     getCellHyperlink(address) {
         const formulaVertex = this.dependencyGraph.getCell(address);
-        if (formulaVertex instanceof FormulaCellVertex) {
+        if (formulaVertex instanceof ScalarFormulaVertex) {
             const formula = formulaVertex.getFormula(this.dependencyGraph.lazilyTransformingAstService);
             if ("HYPERLINK" === formula.procedureName) {
                 return formula.hyperlink;
@@ -87367,12 +88128,12 @@ class Serialization {
     }
     getCellFormula(address, targetAddress) {
         const formulaVertex = this.dependencyGraph.getCell(address);
-        if (formulaVertex instanceof FormulaCellVertex) {
+        if (formulaVertex instanceof ScalarFormulaVertex) {
             const formula = formulaVertex.getFormula(this.dependencyGraph.lazilyTransformingAstService);
             targetAddress = targetAddress !== null && targetAddress !== void 0 ? targetAddress : address;
             return this.unparser.unparse(formula, targetAddress);
         }
-        else if (formulaVertex instanceof ArrayVertex) {
+        else if (formulaVertex instanceof ArrayFormulaVertex) {
             const arrayVertexAddress = formulaVertex.getAddress(this.dependencyGraph.lazilyTransformingAstService);
             if (arrayVertexAddress.row !== address.row || arrayVertexAddress.col !== address.col || arrayVertexAddress.sheet !== address.sheet) {
                 return void 0;
@@ -87435,8 +88196,8 @@ class Serialization {
     }
     genericAllSheetsGetter(sheetGetter) {
         const result = {};
-        for (const sheetName of this.dependencyGraph.sheetMapping.displayNames()) {
-            const sheetId = this.dependencyGraph.sheetMapping.fetch(sheetName);
+        for (const sheetName of this.dependencyGraph.sheetMapping.iterateSheetNames()) {
+            const sheetId = this.dependencyGraph.sheetMapping.getSheetIdOrThrowError(sheetName);
             result[sheetName] = sheetGetter(sheetId);
         }
         return result;
@@ -87456,8 +88217,8 @@ class Serialization {
     getAllNamedExpressionsSerialized() {
         const idMap = [];
         let id2 = 0;
-        for (const sheetName of this.dependencyGraph.sheetMapping.displayNames()) {
-            const sheetId = this.dependencyGraph.sheetMapping.fetch(sheetName);
+        for (const sheetName of this.dependencyGraph.sheetMapping.iterateSheetNames()) {
+            const sheetId = this.dependencyGraph.sheetMapping.getSheetIdOrThrowError(sheetName);
             idMap[sheetId] = id2;
             id2++;
         }
@@ -87471,7 +88232,7 @@ class Serialization {
         });
     }
     withNewConfig(newConfig, namedExpressions) {
-        const newUnparser = new Unparser(newConfig, buildLexerConfig(newConfig), this.dependencyGraph.sheetMapping.fetchDisplayName, namedExpressions);
+        const newUnparser = new Unparser(newConfig, this.dependencyGraph.sheetMapping, namedExpressions);
         return new Serialization(this.dependencyGraph, newUnparser, this.exporter);
     }
 }
@@ -87511,12 +88272,14 @@ class BuildEngineFactory {
                     throw new SheetSizeLimitExceededError();
                 }
                 const sheetId = sheetMapping.addSheet(sheetName);
-                addressMapping.autoAddSheet(sheetId, boundaries);
+                addressMapping.addSheetAndSetStrategyBasedOnBoundaries(sheetId, boundaries, {
+                    throwIfSheetAlreadyExists: true
+                });
             }
         }
-        const parser2 = new ParserWithCaching(config2, functionRegistry, sheetMapping.get);
+        const parser2 = new ParserWithCaching(config2, functionRegistry, dependencyGraph.sheetReferenceRegistrar.ensureSheetRegistered.bind(dependencyGraph.sheetReferenceRegistrar));
         lazilyTransformingAstService.parser = parser2;
-        const unparser = new Unparser(config2, buildLexerConfig(config2), sheetMapping.fetchDisplayName, namedExpressions);
+        const unparser = new Unparser(config2, sheetMapping, namedExpressions);
         const dateTimeHelper = new DateTimeHelper(config2);
         const numberLiteralHelper = new NumberLiteralHelper(config2);
         const arithmeticHelper = new ArithmeticHelper(config2, dateTimeHelper, numberLiteralHelper);
@@ -87527,7 +88290,7 @@ class BuildEngineFactory {
         lazilyTransformingAstService.undoRedo = undoRedo;
         const clipboardOperations = new ClipboardOperations(config2, dependencyGraph, operations);
         const crudOperations = new CrudOperations(config2, operations, undoRedo, clipboardOperations, dependencyGraph, columnSearch, parser2, cellContentParser, lazilyTransformingAstService, namedExpressions);
-        const exporter = new Exporter(config2, namedExpressions, sheetMapping.fetchDisplayName, lazilyTransformingAstService);
+        const exporter = new Exporter(config2, namedExpressions, sheetMapping, lazilyTransformingAstService);
         const serialization = new Serialization(dependencyGraph, unparser, exporter);
         const interpreter = new Interpreter(config2, dependencyGraph, columnSearch, stats, arithmeticHelper, functionRegistry, namedExpressions, serialization, arraySizePredictor, dateTimeHelper);
         stats.measure(StatType.GRAPH_BUILD, () => {
@@ -90040,6 +90803,8 @@ class HyperFormula {
     /**
      * Adds a new sheet to the HyperFormula instance. Returns given or autogenerated name of a new sheet.
      *
+     * Note that this method may trigger dependency graph recalculation.
+     *
      * @param {string} [sheetName] - if not specified, name is autogenerated
      *
      * @fires [[sheetAdded]] after the sheet was added
@@ -90069,6 +90834,7 @@ class HyperFormula {
             validateArgToType(sheetName, "string", "sheetName");
         }
         const addedSheetName = this._crudOperations.addSheet(sheetName);
+        this.recomputeIfDependencyGraphNeedsIt();
         this._emitter.emit(Events.SheetAdded, addedSheetName);
         return addedSheetName;
     }
@@ -90139,7 +90905,7 @@ class HyperFormula {
      */
     removeSheet(sheetId) {
         validateArgToType(sheetId, "number", "sheetId");
-        const displayName = this.sheetMapping.getDisplayName(sheetId);
+        const displayName = this.sheetMapping.getSheetName(sheetId);
         this._crudOperations.removeSheet(sheetId);
         const changes = this.recomputeIfDependencyGraphNeedsIt();
         this._emitter.emit(Events.SheetRemoved, displayName, changes);
@@ -90315,7 +91081,7 @@ class HyperFormula {
     simpleCellAddressFromString(cellAddress, contextSheetId) {
         validateArgToType(cellAddress, "string", "cellAddress");
         validateArgToType(contextSheetId, "number", "sheetId");
-        return simpleCellAddressFromString(this.sheetMapping.get, cellAddress, contextSheetId);
+        return simpleCellAddressFromString(this.sheetMapping.getSheetId.bind(this.sheetMapping), cellAddress, contextSheetId);
     }
     /**
      * Computes simple (absolute) address of a cell range based on its string representation.
@@ -90343,7 +91109,7 @@ class HyperFormula {
     simpleCellRangeFromString(cellRange, contextSheetId) {
         validateArgToType(cellRange, "string", "cellRange");
         validateArgToType(contextSheetId, "number", "sheetId");
-        return simpleCellRangeFromString(this.sheetMapping.get, cellRange, contextSheetId);
+        return simpleCellRangeFromString(this.sheetMapping.getSheetId.bind(this.sheetMapping), cellRange, contextSheetId);
     }
     /**
      * Computes string representation of an absolute address in A1 notation. If `cellAddress.sheet` is not present in the engine, returns `undefined`.
@@ -90384,7 +91150,7 @@ class HyperFormula {
             throw new ExpectedValueOfTypeError("SimpleCellAddress", "cellAddress");
         }
         const contextSheetId = typeof optionsOrContextSheetId === "number" ? optionsOrContextSheetId : optionsOrContextSheetId.includeSheetName ? cellAddress.sheet + 1 : cellAddress.sheet;
-        return simpleCellAddressToString(this.sheetMapping.fetchDisplayName, cellAddress, contextSheetId);
+        return simpleCellAddressToString(this.sheetMapping.getSheetNameOrThrowError.bind(this.sheetMapping), cellAddress, contextSheetId);
     }
     /**
      * Computes string representation of an absolute range in A1 notation.
@@ -90432,7 +91198,7 @@ class HyperFormula {
             throw new ExpectedValueOfTypeError("SimpleCellRange", "cellRange");
         }
         const contextSheetId = typeof optionsOrContextSheetId === "number" ? optionsOrContextSheetId : optionsOrContextSheetId.includeSheetName ? cellRange.start.sheet + cellRange.end.sheet + 1 : cellRange.start.sheet;
-        return simpleCellRangeToString(this.sheetMapping.fetchDisplayName, cellRange, contextSheetId);
+        return simpleCellRangeToString(this.sheetMapping.getSheetNameOrThrowError.bind(this.sheetMapping), cellRange, contextSheetId);
     }
     /**
      * Returns all the out-neighbors in the [dependency graph](../../guide/dependency-graph.md) for a given cell address or range. Including:
@@ -90465,7 +91231,7 @@ class HyperFormula {
             vertex = this._dependencyGraph.addressMapping.getCell(address);
         }
         else if (isSimpleCellRange(address)) {
-            vertex = this._dependencyGraph.rangeMapping.getRange(address.start, address.end);
+            vertex = this._dependencyGraph.rangeMapping.getRangeVertex(address.start, address.end);
         }
         else {
             throw new ExpectedValueOfTypeError("SimpleCellAddress | SimpleCellRange", address);
@@ -90504,7 +91270,7 @@ class HyperFormula {
             vertex = this._dependencyGraph.addressMapping.getCell(address);
         }
         else if (isSimpleCellRange(address)) {
-            vertex = this._dependencyGraph.rangeMapping.getRange(address.start, address.end);
+            vertex = this._dependencyGraph.rangeMapping.getRangeVertex(address.start, address.end);
         }
         else {
             throw new ExpectedValueOfTypeError("SimpleCellAddress | SimpleCellRange", address);
@@ -90536,7 +91302,7 @@ class HyperFormula {
      */
     getSheetName(sheetId) {
         validateArgToType(sheetId, "number", "sheetId");
-        return this.sheetMapping.getDisplayName(sheetId);
+        return this.sheetMapping.getSheetName(sheetId);
     }
     /**
      * List all sheet names.
@@ -90556,7 +91322,7 @@ class HyperFormula {
      * @category Sheets
      */
     getSheetNames() {
-        return this.sheetMapping.sheetNames();
+        return this.sheetMapping.getSheetNames();
     }
     /**
      * Returns a unique sheet ID assigned to the sheet with a given name or `undefined` if the sheet does not exist.
@@ -90580,7 +91346,7 @@ class HyperFormula {
      */
     getSheetId(sheetName) {
         validateArgToType(sheetName, "string", "sheetName");
-        return this.sheetMapping.get(sheetName);
+        return this.sheetMapping.getSheetId(sheetName);
     }
     /**
      * Returns `true` whether sheet with a given name exists. The method accepts sheet name to be checked.
@@ -90914,6 +91680,8 @@ class HyperFormula {
     /**
      * Renames a specified sheet.
      *
+     * Note that this method may trigger dependency graph recalculation.
+     *
      * @param {number} sheetId - a sheet ID
      * @param {string} newName - a name of the sheet to be given, if is the same as the old one the method does nothing
      *
@@ -90940,6 +91708,7 @@ class HyperFormula {
         validateArgToType(sheetId, "number", "sheetId");
         validateArgToType(newName, "string", "newName");
         const oldName = this._crudOperations.renameSheet(sheetId, newName);
+        this.recomputeIfDependencyGraphNeedsIt();
         if (oldName !== void 0) {
             this._emitter.emit(Events.SheetRenamed, oldName, newName);
         }
@@ -91999,9 +92768,9 @@ class HyperFormula {
         }
     }
 }
-HyperFormula.version = "3.1.0";
-HyperFormula.buildDate = "14/10/2025 09:41:56";
-HyperFormula.releaseDate = "14/10/2025";
+HyperFormula.version = "3.1.1";
+HyperFormula.buildDate = "18/12/2025 11:47:25";
+HyperFormula.releaseDate = "18/12/2025";
 HyperFormula.languages = {};
 HyperFormula.registeredLanguages = /* @__PURE__ */ new Map();
 const privatePool = /* @__PURE__ */ new WeakMap();
@@ -95240,7 +96009,7 @@ class InformationPlugin extends FunctionPlugin {
      */
     sheet(ast, state) {
         return this.runFunctionWithReferenceArgument(ast.args, state, this.metadata("SHEET"), () => state.formulaAddress.sheet + 1, (reference) => reference.sheet + 1, (value) => {
-            const sheetNumber = this.dependencyGraph.sheetMapping.get(value);
+            const sheetNumber = this.dependencyGraph.sheetMapping.getSheetId(value);
             if (sheetNumber !== void 0) {
                 return sheetNumber + 1;
             }
@@ -96216,13 +96985,13 @@ class NumericAggregationPlugin extends FunctionPlugin {
     /**
      * Performs range operation on given range
      *
-     * @param ast - cell range ast
-     * @param state
-     * @param initialAccValue - initial accumulator value for reducing function
-     * @param functionName - function name to use as cache key
-     * @param reducingFunction - reducing function
-     * @param mapFunction
-     * @param coercionFunction
+     * @param {CellRangeAst | ColumnRangeAst | RowRangeAst} ast - cell range ast
+     * @param {InterpreterState} state - interpreter state
+     * @param {T} initialAccValue - initial accumulator value for reducing function
+     * @param {string} functionName - function name to use as cache key
+     * @param {BinaryOperation<T>} reducingFunction - reducing function
+     * @param {MapOperation<T>} mapFunction - mapper transforming coerced scalar
+     * @param {coercionOperation} coercionFunction - scalar-to-number coercer
      */
     evaluateRange(ast, state, initialAccValue, functionName2, reducingFunction, mapFunction, coercionFunction) {
         let range2;
@@ -96237,6 +97006,9 @@ class NumericAggregationPlugin extends FunctionPlugin {
                 throw err;
             }
         }
+        if (!this.isSheetValid(range2)) {
+            return new CellError(ErrorType.REF, ErrorMessage.SheetRef);
+        }
         const rangeVertex = this.dependencyGraph.getRange(range2.start, range2.end);
         if (rangeVertex === void 0) {
             throw new Error("Range does not exists in graph");
@@ -96259,6 +97031,16 @@ class NumericAggregationPlugin extends FunctionPlugin {
         }
         return value;
     }
+    /**
+     * Checks whether both ends of a range point to existing sheets (placeholders excluded).
+     */
+    isSheetValid(range2) {
+        return this.dependencyGraph.sheetMapping.hasSheetWithId(range2.start.sheet, {
+            includePlaceholders: false
+        }) && this.dependencyGraph.sheetMapping.hasSheetWithId(range2.end.sheet, {
+            includePlaceholders: false
+        });
+    }
     /**
      * Returns list of values for given range and function name
      *
@@ -111665,7 +112447,7 @@ function requireDefineProperties() {
         return defineProperties_1;
     hasRequiredDefineProperties = 1;
     var keys2 = requireObjectKeys();
-    var hasSymbols2 = typeof Symbol === "function" && typeof Symbol("foo") === "symbol";
+    var hasSymbols2 = typeof Symbol === "function" && typeof /* @__PURE__ */ Symbol("foo") === "symbol";
     var toStr = Object.prototype.toString;
     var concat = Array.prototype.concat;
     var defineDataProperty2 = /* @__PURE__ */ requireDefineDataProperty();
@@ -111854,7 +112636,7 @@ function requireShams$1() {
             return true;
         }
         var obj = {};
-        var sym = Symbol("test");
+        var sym = /* @__PURE__ */ Symbol("test");
         var symObj = Object(sym);
         if (typeof sym === "string") {
             return false;
@@ -111913,7 +112695,7 @@ function requireHasSymbols() {
         if (typeof origSymbol("foo") !== "symbol") {
             return false;
         }
-        if (typeof Symbol("bar") !== "symbol") {
+        if (typeof /* @__PURE__ */ Symbol("bar") !== "symbol") {
             return false;
         }
         return hasSymbolSham();
@@ -134315,7 +135097,21 @@ async function init(config2) {
     _setDocumentDir(dataDir || process.cwd());
     if (serverURL) {
         setServer(serverURL);
-        if (config2.password) {
+        if ("sessionToken" in config2 && config2.sessionToken) {
+            await runHandler(exports.handlers["subscribe-set-token"], {
+                token: config2.sessionToken
+            });
+            const user = await runHandler(exports.handlers["subscribe-get-user"], void 0);
+            if (!user || user.tokenExpired === true) {
+                await runHandler(exports.handlers["subscribe-set-token"], { token: "" });
+                throw new Error("Authentication failed: invalid or expired session token");
+            }
+            if (user.offline === true) {
+                await runHandler(exports.handlers["subscribe-set-token"], { token: "" });
+                throw new Error("Authentication failed: server offline or unreachable");
+            }
+        }
+        else if ("password" in config2 && config2.password) {
             const result = await runHandler(exports.handlers["subscribe-sign-in"], {
                 password: config2.password
             });