@bilig/headless 0.1.28 → 0.1.29

package/dist/{headless-workbook.js → work-paper-runtime.js}

@@ -1,8 +1,15 @@
-import { SpreadsheetEngine } from "@bilig/core";
+import { SpreadsheetEngine, makeCellKey } from "@bilig/core";
 import { ErrorCode, MAX_COLS, MAX_ROWS, ValueTag, } from "@bilig/protocol";
 import { excelSerialToDateParts, formatAddress, formatRangeAddress, installExternalFunctionAdapter, isArrayValue, isCellReferenceText, parseCellAddress, parseFormula, parseRangeAddress, serializeFormula, translateFormulaReferences, } from "@bilig/formula";
-import { ConfigValueTooBigError, ConfigValueTooSmallError, HeadlessArgumentError, HeadlessEvaluationSuspendedError, HeadlessOperationError, HeadlessParseError, HeadlessSheetError, ExpectedOneOfValuesError, FunctionPluginValidationError, InvalidArgumentsError, LanguageAlreadyRegisteredError, LanguageNotRegisteredError, NamedExpressionDoesNotExistError, NamedExpressionNameIsAlreadyTakenError, NamedExpressionNameIsInvalidError, NoOperationToRedoError, NoOperationToUndoError, NoRelativeAddressesAllowedError, NoSheetWithIdError, NoSheetWithNameError, NotAFormulaError, NothingToPasteError, SheetNameAlreadyTakenError, SheetSizeLimitExceededError, UnableToParseError, } from "./errors.js";
+import { tryLoadInitialLiteralSheet } from "./initial-sheet-load.js";
+import { orderWorkPaperCellChanges } from "./change-order.js";
+import { WorkPaperConfigValueTooBigError, WorkPaperConfigValueTooSmallError, WorkPaperEvaluationSuspendedError, WorkPaperExpectedValueOfTypeError, WorkPaperOperationError, WorkPaperParseError, WorkPaperSheetError, WorkPaperExpectedOneOfValuesError, WorkPaperFunctionPluginValidationError, WorkPaperInvalidArgumentsError, WorkPaperLanguageAlreadyRegisteredError, WorkPaperLanguageNotRegisteredError, WorkPaperNamedExpressionDoesNotExistError, WorkPaperNamedExpressionNameIsAlreadyTakenError, WorkPaperNamedExpressionNameIsInvalidError, WorkPaperNoOperationToRedoError, WorkPaperNoOperationToUndoError, WorkPaperNoRelativeAddressesAllowedError, WorkPaperNoSheetWithIdError, WorkPaperNoSheetWithNameError, WorkPaperNotAFormulaError, WorkPaperNothingToPasteError, WorkPaperSheetNameAlreadyTakenError, WorkPaperSheetSizeLimitExceededError, WorkPaperUnableToParseError, } from "./work-paper-errors.js";
 import { buildMatrixMutationPlan } from "./matrix-mutation-plan.js";
+import { captureTrackedEngineEvent } from "./tracked-engine-event-refs.js";
+import { calculateWorkPaperFormulaInScratchWorkbook } from "./work-paper-scratch-evaluator.js";
+import { replaceWorkPaperSheetContent } from "./work-paper-sheet-replacement.js";
+const EMPTY_NAMED_EXPRESSION_VALUES = new Map();
+const VISIBILITY_SHEET_STRIDE = MAX_ROWS * MAX_COLS;
 const DEFAULT_CONFIG = Object.freeze({
     accentSensitive: false,
     caseSensitive: false,
@@ -43,7 +50,7 @@ const DEFAULT_CONFIG = Object.freeze({
     useRegularExpressions: true,
     useWildcards: true,
 });
-const HEADLESS_CONFIG_KEYS = [
+const WORKPAPER_CONFIG_KEYS = [
     "accentSensitive",
     "caseSensitive",
     "caseFirst",
@@ -83,46 +90,44 @@ const HEADLESS_CONFIG_KEYS = [
     "useRegularExpressions",
     "useWildcards",
 ];
-const HEADLESS_PUBLIC_ERROR_NAMES = new Set([
-    "ConfigValueTooBigError",
-    "ConfigValueTooSmallError",
-    "EvaluationSuspendedError",
-    "ExpectedOneOfValuesError",
-    "ExpectedValueOfTypeError",
-    "FunctionPluginValidationError",
-    "InvalidAddressError",
-    "InvalidArgumentsError",
-    "LanguageAlreadyRegisteredError",
-    "LanguageNotRegisteredError",
-    "MissingTranslationError",
-    "NamedExpressionDoesNotExistError",
-    "NamedExpressionNameIsAlreadyTakenError",
-    "NamedExpressionNameIsInvalidError",
-    "NoOperationToRedoError",
-    "NoOperationToUndoError",
-    "NoRelativeAddressesAllowedError",
-    "NoSheetWithIdError",
-    "NoSheetWithNameError",
-    "NotAFormulaError",
-    "NothingToPasteError",
-    "ProtectedFunctionTranslationError",
-    "SheetNameAlreadyTakenError",
-    "SheetSizeLimitExceededError",
-    "SourceLocationHasArrayError",
-    "TargetLocationHasArrayError",
-    "UnableToParseError",
-    "HeadlessArgumentError",
-    "HeadlessConfigError",
-    "HeadlessSheetError",
-    "HeadlessNamedExpressionError",
-    "HeadlessClipboardError",
-    "HeadlessEvaluationSuspendedError",
-    "HeadlessParseError",
-    "HeadlessOperationError",
+const WORKPAPER_PUBLIC_ERROR_NAMES = new Set([
+    "WorkPaperConfigValueTooBigError",
+    "WorkPaperConfigValueTooSmallError",
+    "WorkPaperEvaluationSuspendedError",
+    "WorkPaperExpectedOneOfValuesError",
+    "WorkPaperExpectedValueOfTypeError",
+    "WorkPaperFunctionPluginValidationError",
+    "WorkPaperInvalidAddressError",
+    "WorkPaperInvalidArgumentsError",
+    "WorkPaperLanguageAlreadyRegisteredError",
+    "WorkPaperLanguageNotRegisteredError",
+    "WorkPaperMissingTranslationError",
+    "WorkPaperNamedExpressionDoesNotExistError",
+    "WorkPaperNamedExpressionNameIsAlreadyTakenError",
+    "WorkPaperNamedExpressionNameIsInvalidError",
+    "WorkPaperNoOperationToRedoError",
+    "WorkPaperNoOperationToUndoError",
+    "WorkPaperNoRelativeAddressesAllowedError",
+    "WorkPaperNoSheetWithIdError",
+    "WorkPaperNoSheetWithNameError",
+    "WorkPaperNotAFormulaError",
+    "WorkPaperNothingToPasteError",
+    "WorkPaperProtectedFunctionTranslationError",
+    "WorkPaperSheetNameAlreadyTakenError",
+    "WorkPaperSheetSizeLimitExceededError",
+    "WorkPaperSourceLocationHasArrayError",
+    "WorkPaperTargetLocationHasArrayError",
+    "WorkPaperUnableToParseError",
+    "WorkPaperConfigError",
+    "WorkPaperSheetError",
+    "WorkPaperNamedExpressionError",
+    "WorkPaperClipboardError",
+    "WorkPaperParseError",
+    "WorkPaperOperationError",
 ]);
-const HEADLESS_VERSION = "0.1.2";
-const HEADLESS_BUILD_DATE = "2026-04-10";
-const HEADLESS_RELEASE_DATE = "2026-04-10";
+const WORKPAPER_VERSION = "0.1.2";
+const WORKPAPER_BUILD_DATE = "2026-04-10";
+const WORKPAPER_RELEASE_DATE = "2026-04-10";
 const globalCustomFunctions = new Map();
 let customAdapterInstalled = false;
 let nextWorkbookId = 1;
@@ -165,6 +170,10 @@ function clonePluginDefinition(plugin) {
 function cloneConfig(config) {
     return {
         ...config,
+        chooseAddressMappingPolicy: config.chooseAddressMappingPolicy
+            ? { ...config.chooseAddressMappingPolicy }
+            : undefined,
+        context: config.context !== undefined ? structuredClone(config.context) : undefined,
         currencySymbol: config.currencySymbol ? [...config.currencySymbol] : undefined,
         dateFormats: config.dateFormats ? [...config.dateFormats] : undefined,
         functionPlugins: config.functionPlugins
@@ -259,7 +268,7 @@ function makeNamedExpressionKey(name, scope) {
     return `${scope ?? "workbook"}:${normalizeName(name)}`;
 }
 function makeInternalScopedName(scope, name) {
-    return `__BILIG_HEADLESS_SCOPE_${scope}_${normalizeName(name)}`;
+    return `__BILIG_WORKPAPER_SCOPE_${scope}_${normalizeName(name)}`;
 }
 function isFormulaContent(content) {
     return typeof content === "string" && content.trim().startsWith("=");
@@ -267,7 +276,7 @@ function isFormulaContent(content) {
 function isCellValueMatrix(value) {
     return Array.isArray(value);
 }
-function isHeadlessSheetMatrix(value) {
+function isWorkPaperSheetMatrix(value) {
     return Array.isArray(value);
 }
 function matrixContainsFormulaContent(content) {
@@ -284,7 +293,7 @@ function stripLeadingEquals(formula) {
 }
 function assertRowAndColumn(value, label) {
     if (!Number.isInteger(value) || value < 0) {
-        throw new InvalidArgumentsError(`${label} to be a non-negative integer`);
+        throw new WorkPaperInvalidArgumentsError(`${label} to be a non-negative integer`);
     }
 }
 function assertRange(range) {
@@ -295,7 +304,7 @@ function assertRange(range) {
     assertRowAndColumn(range.end.row, "end.row");
     assertRowAndColumn(range.end.col, "end.col");
     if (range.start.sheet !== range.end.sheet) {
-        throw new HeadlessArgumentError("Ranges must stay on a single sheet");
+        throw new WorkPaperInvalidArgumentsError("Ranges must stay on a single sheet");
     }
 }
 function isCellRange(value) {
@@ -443,7 +452,7 @@ function formulaHasRelativeReferences(node) {
 function compareSheetNames(left, right) {
     return left.localeCompare(right);
 }
-function checkHeadlessLicenseKeyValidity(licenseKey) {
+function checkWorkPaperLicenseKeyValidity(licenseKey) {
     if (!licenseKey || licenseKey.trim().length === 0) {
         return "missing";
     }
@@ -454,56 +463,80 @@ function checkHeadlessLicenseKeyValidity(licenseKey) {
     }
     return "invalid";
 }
-function validateHeadlessConfig(config) {
+function validateWorkPaperConfig(config) {
     if (config.maxRows !== undefined && (!Number.isInteger(config.maxRows) || config.maxRows < 1)) {
-        throw new ConfigValueTooSmallError("maxRows", 1);
+        throw new WorkPaperConfigValueTooSmallError("maxRows", 1);
     }
     if (config.maxColumns !== undefined &&
         (!Number.isInteger(config.maxColumns) || config.maxColumns < 1)) {
-        throw new ConfigValueTooSmallError("maxColumns", 1);
+        throw new WorkPaperConfigValueTooSmallError("maxColumns", 1);
     }
     if ((config.maxRows ?? MAX_ROWS) > MAX_ROWS) {
-        throw new ConfigValueTooBigError("maxRows", MAX_ROWS);
+        throw new WorkPaperConfigValueTooBigError("maxRows", MAX_ROWS);
     }
     if ((config.maxColumns ?? MAX_COLS) > MAX_COLS) {
-        throw new ConfigValueTooBigError("maxColumns", MAX_COLS);
+        throw new WorkPaperConfigValueTooBigError("maxColumns", MAX_COLS);
     }
     if (config.decimalSeparator !== undefined &&
         config.decimalSeparator !== "." &&
         config.decimalSeparator !== ",") {
-        throw new ExpectedOneOfValuesError('".", ","', "decimalSeparator");
+        throw new WorkPaperExpectedOneOfValuesError('".", ","', "decimalSeparator");
     }
     if (config.arrayColumnSeparator !== undefined &&
         config.arrayColumnSeparator !== "," &&
         config.arrayColumnSeparator !== ";") {
-        throw new ExpectedOneOfValuesError('",", ";"', "arrayColumnSeparator");
+        throw new WorkPaperExpectedOneOfValuesError('",", ";"', "arrayColumnSeparator");
     }
     if (config.arrayRowSeparator !== undefined &&
         config.arrayRowSeparator !== ";" &&
         config.arrayRowSeparator !== "|") {
-        throw new ExpectedOneOfValuesError('";", "|"', "arrayRowSeparator");
+        throw new WorkPaperExpectedOneOfValuesError('";", "|"', "arrayRowSeparator");
     }
     if (config.ignoreWhiteSpace !== undefined &&
         config.ignoreWhiteSpace !== "standard" &&
         config.ignoreWhiteSpace !== "any") {
-        throw new ExpectedOneOfValuesError('"standard", "any"', "ignoreWhiteSpace");
+        throw new WorkPaperExpectedOneOfValuesError('"standard", "any"', "ignoreWhiteSpace");
     }
     if (config.caseFirst !== undefined &&
         config.caseFirst !== "upper" &&
         config.caseFirst !== "lower" &&
         config.caseFirst !== "false") {
-        throw new ExpectedOneOfValuesError('"upper", "lower", "false"', "caseFirst");
+        throw new WorkPaperExpectedOneOfValuesError('"upper", "lower", "false"', "caseFirst");
+    }
+    if (config.chooseAddressMappingPolicy !== undefined &&
+        (typeof config.chooseAddressMappingPolicy !== "object" ||
+            config.chooseAddressMappingPolicy === null ||
+            (config.chooseAddressMappingPolicy.mode !== "dense" &&
+                config.chooseAddressMappingPolicy.mode !== "sparse"))) {
+        throw new WorkPaperExpectedOneOfValuesError('"dense", "sparse"', "chooseAddressMappingPolicy.mode");
+    }
+    if (config.parseDateTime !== undefined && typeof config.parseDateTime !== "function") {
+        throw new WorkPaperExpectedValueOfTypeError("function", "parseDateTime");
+    }
+    if (config.stringifyDateTime !== undefined && typeof config.stringifyDateTime !== "function") {
+        throw new WorkPaperExpectedValueOfTypeError("function", "stringifyDateTime");
+    }
+    if (config.stringifyDuration !== undefined && typeof config.stringifyDuration !== "function") {
+        throw new WorkPaperExpectedValueOfTypeError("function", "stringifyDuration");
+    }
+    if (config.context !== undefined) {
+        try {
+            structuredClone(config.context);
+        }
+        catch {
+            throw new WorkPaperExpectedValueOfTypeError("structured-cloneable value", "context");
+        }
     }
 }
 function validateSheetWithinLimits(sheetName, sheet, config) {
     const height = sheet.length;
     const width = Math.max(0, ...sheet.map((row) => row.length));
     if (height > (config.maxRows ?? MAX_ROWS) || width > (config.maxColumns ?? MAX_COLS)) {
-        throw new SheetSizeLimitExceededError();
+        throw new WorkPaperSheetSizeLimitExceededError();
     }
     sheet.forEach((row) => {
         if (!Array.isArray(row)) {
-            throw new UnableToParseError({ sheetName, reason: "Rows must be arrays" });
+            throw new WorkPaperUnableToParseError({ sheetName, reason: "Rows must be arrays" });
         }
     });
 }
@@ -549,7 +582,7 @@ function formatQualifiedCellAddress(sheetName, row, col) {
     const base = formatAddress(row, col);
     return sheetName ? `${quoteSheetNameIfNeeded(sheetName)}!${base}` : base;
 }
-class HeadlessEmitter {
+class WorkPaperEmitter {
     listeners = {
         sheetAdded: new Set(),
         sheetRemoved: new Set(),
@@ -671,17 +704,17 @@ class HeadlessEmitter {
         Object.values(this.detailedListeners).forEach((listeners) => listeners.clear());
     }
 }
-export class HeadlessWorkbook {
-    static version = HEADLESS_VERSION;
-    static buildDate = HEADLESS_BUILD_DATE;
-    static releaseDate = HEADLESS_RELEASE_DATE;
+export class WorkPaper {
+    static version = WORKPAPER_VERSION;
+    static buildDate = WORKPAPER_BUILD_DATE;
+    static releaseDate = WORKPAPER_RELEASE_DATE;
     static languages = {};
     static defaultConfig = cloneConfig(DEFAULT_CONFIG);
     static languageRegistry = new Map();
     static functionPluginRegistry = new Map();
     workbookId = nextWorkbookId++;
-    engine = new SpreadsheetEngine({ workbookName: "Workbook" });
-    emitter = new HeadlessEmitter();
+    engine;
+    emitter = new WorkPaperEmitter();
     namedExpressions = new Map();
     functionSnapshot = new Map();
     functionAliasLookup = new Map();
@@ -689,6 +722,8 @@ export class HeadlessWorkbook {
     internals;
     config;
     clipboard = null;
+    visibilityCache = null;
+    namedExpressionValueCache = null;
     batchDepth = 0;
     batchStartVisibility = null;
     batchStartNamedValues = null;
@@ -699,14 +734,23 @@ export class HeadlessWorkbook {
     suspendedVisibility = null;
     suspendedNamedValues = null;
     queuedEvents = [];
+    trackedEngineEvents = [];
+    engineEventCaptureEnabled = true;
+    unsubscribeEngineEvents = null;
     disposed = false;
     constructor(configInput = {}) {
         ensureCustomAdapterInstalled();
-        validateHeadlessConfig(configInput);
+        validateWorkPaperConfig(configInput);
         this.config = {
             ...cloneConfig(DEFAULT_CONFIG),
             ...cloneConfig(configInput),
         };
+        this.engine = new SpreadsheetEngine({
+            workbookName: "Workbook",
+            useColumnIndex: this.config.useColumnIndex,
+            trackReplicaVersions: false,
+        });
+        this.attachEngineEventTracking();
         this.captureFunctionRegistry();
         this.internals = Object.freeze({
             graph: Object.freeze({
@@ -765,51 +809,59 @@ export class HeadlessWorkbook {
         });
     }
     static buildEmpty(configInput = {}, namedExpressions = []) {
-        const workbook = new HeadlessWorkbook(configInput);
-        namedExpressions.forEach((expression) => {
-            workbook.upsertNamedExpressionInternal(expression, { duringInitialization: true });
+        const workbook = new WorkPaper(configInput);
+        workbook.withEngineEventCaptureDisabled(() => {
+            namedExpressions.forEach((expression) => {
+                workbook.upsertNamedExpressionInternal(expression, { duringInitialization: true });
+            });
         });
         workbook.clearHistoryStacks();
+        workbook.primeChangeTrackingCaches();
         return workbook;
     }
     static buildFromArray(sheet, configInput = {}, namedExpressions = []) {
         return this.buildFromSheets({ Sheet1: sheet }, configInput, namedExpressions);
     }
     static buildFromSheets(sheets, configInput = {}, namedExpressions = []) {
-        const workbook = new HeadlessWorkbook(configInput);
+        const workbook = new WorkPaper(configInput);
         Object.entries(sheets).forEach(([sheetName, sheet]) => {
             validateSheetWithinLimits(sheetName, sheet, workbook.config);
         });
-        Object.keys(sheets).forEach((sheetName) => {
-            workbook.engine.createSheet(sheetName);
-        });
-        namedExpressions.forEach((expression) => {
-            workbook.upsertNamedExpressionInternal(expression, { duringInitialization: true });
-        });
-        Object.entries(sheets).forEach(([sheetName, sheet]) => {
-            const sheetId = workbook.requireSheetId(sheetName);
-            workbook.replaceSheetContentInternal(sheetId, sheet, { duringInitialization: true });
+        workbook.withEngineEventCaptureDisabled(() => {
+            Object.keys(sheets).forEach((sheetName) => {
+                workbook.engine.createSheet(sheetName);
+            });
+            namedExpressions.forEach((expression) => {
+                workbook.upsertNamedExpressionInternal(expression, { duringInitialization: true });
+            });
+            Object.entries(sheets).forEach(([sheetName, sheet]) => {
+                const sheetId = workbook.requireSheetId(sheetName);
+                if (!tryLoadInitialLiteralSheet(workbook.engine, sheetId, sheet)) {
+                    workbook.replaceSheetContentInternal(sheetId, sheet, { duringInitialization: true });
+                }
+            });
         });
         workbook.clearHistoryStacks();
+        workbook.primeChangeTrackingCaches();
         return workbook;
     }
     static getLanguage(languageCode) {
         const language = this.languageRegistry.get(languageCode);
         if (!language) {
-            throw new LanguageNotRegisteredError(languageCode);
+            throw new WorkPaperLanguageNotRegisteredError(languageCode);
         }
         return structuredClone(language);
     }
     static registerLanguage(languageCode, languagePackage) {
         if (this.languageRegistry.has(languageCode)) {
-            throw new LanguageAlreadyRegisteredError(languageCode);
+            throw new WorkPaperLanguageAlreadyRegisteredError(languageCode);
         }
         this.languageRegistry.set(languageCode, structuredClone(languagePackage));
         this.languages[languageCode] = structuredClone(languagePackage);
     }
     static unregisterLanguage(languageCode) {
         if (!this.languageRegistry.delete(languageCode)) {
-            throw new LanguageNotRegisteredError(languageCode);
+            throw new WorkPaperLanguageNotRegisteredError(languageCode);
         }
         delete this.languages[languageCode];
     }
@@ -830,7 +882,7 @@ export class HeadlessWorkbook {
         const existing = this.functionPluginRegistry.get(plugin.id);
         const nextPlugin = clonePluginDefinition(existing ?? plugin);
         if (!nextPlugin.implementedFunctions[functionId]) {
-            throw FunctionPluginValidationError.functionNotDeclaredInPlugin(functionId, plugin.id);
+            throw WorkPaperFunctionPluginValidationError.functionNotDeclaredInPlugin(functionId, plugin.id);
         }
         this.functionPluginRegistry.set(nextPlugin.id, nextPlugin);
         if (translations) {
@@ -884,7 +936,7 @@ export class HeadlessWorkbook {
         Object.entries(translations).forEach(([languageCode, functionTranslations]) => {
             const existing = this.languageRegistry.get(languageCode);
             if (!existing) {
-                throw new LanguageNotRegisteredError(languageCode);
+                throw new WorkPaperLanguageNotRegisteredError(languageCode);
             }
             const nextLanguage = {
                 ...structuredClone(existing),
@@ -950,7 +1002,7 @@ export class HeadlessWorkbook {
         return this.internals.lazilyTransformingAstService;
     }
     get licenseKeyValidityState() {
-        return checkHeadlessLicenseKeyValidity(this.config.licenseKey);
+        return checkWorkPaperLicenseKeyValidity(this.config.licenseKey);
     }
     updateConfig(next) {
         this.assertNotDisposed();
@@ -958,7 +1010,7 @@ export class HeadlessWorkbook {
             ...this.config,
             ...cloneConfig(next),
         };
-        const hasChanges = HEADLESS_CONFIG_KEYS.some((key) => Object.hasOwn(next, key) && this.config[key] !== next[key]);
+        const hasChanges = WORKPAPER_CONFIG_KEYS.some((key) => Object.hasOwn(next, key) && this.config[key] !== next[key]);
         if (!hasChanges) {
             return;
         }
@@ -981,9 +1033,10 @@ export class HeadlessWorkbook {
         this.assertNotDisposed();
         const isOutermost = this.batchDepth === 0;
         if (isOutermost) {
-            this.batchStartVisibility = this.captureVisibilitySnapshot();
-            this.batchStartNamedValues = this.captureNamedExpressionValueSnapshot();
+            this.batchStartVisibility = this.ensureVisibilityCache();
+            this.batchStartNamedValues = this.ensureNamedExpressionValueCache();
             this.batchUndoStackLength = this.getUndoStack().length;
+            this.drainTrackedEngineEvents();
         }
         this.batchDepth += 1;
         try {
@@ -999,7 +1052,7 @@ export class HeadlessWorkbook {
         if (!isOutermost) {
             return [];
         }
-        const changes = this.computeChanges(this.batchStartVisibility ?? new Map(), this.captureVisibilitySnapshot(), this.batchStartNamedValues ?? new Map(), this.captureNamedExpressionValueSnapshot());
+        const changes = this.computeChangesAfterMutation(this.batchStartVisibility ?? new Map(), this.batchStartNamedValues ?? new Map());
         this.batchStartVisibility = null;
         this.batchStartNamedValues = null;
         if (!this.evaluationSuspended) {
@@ -1016,8 +1069,9 @@ export class HeadlessWorkbook {
             return;
         }
         this.evaluationSuspended = true;
-        this.suspendedVisibility = this.captureVisibilitySnapshot();
-        this.suspendedNamedValues = this.captureNamedExpressionValueSnapshot();
+        this.suspendedVisibility = this.ensureVisibilityCache();
+        this.suspendedNamedValues = this.ensureNamedExpressionValueCache();
+        this.drainTrackedEngineEvents();
         this.emitter.emitDetailed({ eventName: "evaluationSuspended", payload: {} });
     }
     resumeEvaluation() {
@@ -1025,7 +1079,7 @@ export class HeadlessWorkbook {
         if (!this.evaluationSuspended) {
             return [];
         }
-        const changes = this.computeChanges(this.suspendedVisibility ?? new Map(), this.captureVisibilitySnapshot(), this.suspendedNamedValues ?? new Map(), this.captureNamedExpressionValueSnapshot());
+        const changes = this.computeChangesAfterMutation(this.suspendedVisibility ?? new Map(), this.suspendedNamedValues ?? new Map());
         this.evaluationSuspended = false;
         this.suspendedVisibility = null;
         this.suspendedNamedValues = null;
@@ -1043,7 +1097,7 @@ export class HeadlessWorkbook {
         this.assertNotDisposed();
         return this.captureChanges(undefined, () => {
             if (!this.engine.undo()) {
-                throw new NoOperationToUndoError();
+                throw new WorkPaperNoOperationToUndoError();
             }
         });
     }
@@ -1051,7 +1105,7 @@ export class HeadlessWorkbook {
         this.assertNotDisposed();
         return this.captureChanges(undefined, () => {
             if (!this.engine.redo()) {
-                throw new NoOperationToRedoError();
+                throw new WorkPaperNoOperationToRedoError();
             }
         });
     }
@@ -1090,7 +1144,7 @@ export class HeadlessWorkbook {
     paste(targetLeftCorner) {
         this.assertNotDisposed();
         if (!this.clipboard) {
-            throw new NothingToPasteError();
+            throw new WorkPaperNothingToPasteError();
         }
         return this.captureChanges(undefined, () => {
             this.applySerializedMatrix(targetLeftCorner, this.clipboard.serialized, this.clipboard.sourceAnchor);
@@ -1441,7 +1495,7 @@ export class HeadlessWorkbook {
     }
     addNamedExpression(expressionName, expression, scope, options) {
         if (!this.isItPossibleToAddNamedExpression(expressionName, expression, scope)) {
-            throw new NamedExpressionNameIsAlreadyTakenError(expressionName);
+            throw new WorkPaperNamedExpressionNameIsAlreadyTakenError(expressionName);
         }
         return this.captureChanges({
             eventName: "namedExpressionAdded",
@@ -1456,7 +1510,7 @@ export class HeadlessWorkbook {
     }
     changeNamedExpression(expressionName, expression, scope, options) {
         if (!this.isItPossibleToChangeNamedExpression(expressionName, expression, scope)) {
-            throw new NamedExpressionDoesNotExistError(expressionName);
+            throw new WorkPaperNamedExpressionDoesNotExistError(expressionName);
         }
         return this.captureChanges(undefined, () => {
             this.upsertNamedExpressionInternal({ name: expressionName, expression, scope, options }, { duringInitialization: false });
@@ -1464,7 +1518,7 @@ export class HeadlessWorkbook {
     }
     removeNamedExpression(expressionName, scope) {
         if (!this.isItPossibleToRemoveNamedExpression(expressionName, scope)) {
-            throw new NamedExpressionDoesNotExistError(expressionName);
+            throw new WorkPaperNamedExpressionDoesNotExistError(expressionName);
         }
         const existing = this.namedExpressionRecord(expressionName, scope);
         return this.captureChanges({
@@ -1497,44 +1551,57 @@ export class HeadlessWorkbook {
     }
     normalizeFormula(formula) {
         if (!formula.trim().startsWith("=")) {
-            throw new NotAFormulaError();
+            throw new WorkPaperNotAFormulaError();
         }
         try {
             return `=${serializeFormula(parseFormula(stripLeadingEquals(formula)))}`;
         }
         catch (error) {
-            throw new HeadlessParseError(this.messageOf(error, `Unable to normalize formula`));
+            throw new WorkPaperParseError(this.messageOf(error, `Unable to normalize formula`));
         }
     }
     calculateFormula(formula, scope) {
         if (!formula.trim().startsWith("=")) {
-            throw new NotAFormulaError();
+            throw new WorkPaperNotAFormulaError();
         }
         try {
-            const temporaryWorkbook = HeadlessWorkbook.buildFromSheets(this.getAllSheetsSerialized(), this.getConfig(), this.getAllNamedExpressionsSerialized());
-            const scratchSheetName = scope !== undefined ? `__HEADLESS_CALC_${scope}__` : "__HEADLESS_CALC__";
-            temporaryWorkbook.engine.createSheet(scratchSheetName);
-            const scratchSheetId = temporaryWorkbook.requireSheetId(scratchSheetName);
-            temporaryWorkbook.applyRawContent(scratchSheetName, "A1", formula.trim().startsWith("=") ? formula : `=${formula}`, scratchSheetId);
-            const spill = temporaryWorkbook.engine
-                .getSpillRanges()
-                .find((candidate) => candidate.sheetName === scratchSheetName && candidate.address === "A1");
-            const value = spill
-                ? temporaryWorkbook.getRangeValues({
-                    start: { sheet: scratchSheetId, row: 0, col: 0 },
-                    end: { sheet: scratchSheetId, row: spill.rows - 1, col: spill.cols - 1 },
-                })
-                : temporaryWorkbook.getCellValue({ sheet: scratchSheetId, row: 0, col: 0 });
-            temporaryWorkbook.dispose();
-            return value;
+            return calculateWorkPaperFormulaInScratchWorkbook({
+                createWorkbook: (config) => {
+                    const temporaryWorkbook = new WorkPaper(config);
+                    return {
+                        engine: temporaryWorkbook.engine,
+                        registerNamedExpression: (expression) => {
+                            temporaryWorkbook.upsertNamedExpressionInternal(expression, {
+                                duringInitialization: true,
+                            });
+                        },
+                        requireSheetId: (sheetName) => temporaryWorkbook.requireSheetId(sheetName),
+                        replaceSheetContent: (sheetId, sheet) => {
+                            temporaryWorkbook.replaceSheetContentInternal(sheetId, sheet, {
+                                duringInitialization: true,
+                            });
+                        },
+                        clearHistoryStacks: () => temporaryWorkbook.clearHistoryStacks(),
+                        applyRawContent: (address, content) => temporaryWorkbook.applyRawContent(address, content),
+                        getRangeValues: (range) => temporaryWorkbook.getRangeValues(range),
+                        getCellValue: (address) => temporaryWorkbook.getCellValue(address),
+                        dispose: () => temporaryWorkbook.dispose(),
+                    };
+                },
+                config: this.getConfig(),
+                serializedSheets: this.getAllSheetsSerialized(),
+                namedExpressions: this.getAllNamedExpressionsSerialized(),
+                formula,
+                scope,
+            });
         }
         catch (error) {
-            throw new HeadlessParseError(this.messageOf(error, "Unable to calculate formula"));
+            throw new WorkPaperParseError(this.messageOf(error, "Unable to calculate formula"));
         }
     }
     getNamedExpressionsFromFormula(formula) {
         if (!formula.trim().startsWith("=")) {
-            throw new NotAFormulaError();
+            throw new WorkPaperNotAFormulaError();
         }
         try {
             const parsed = parseFormula(stripLeadingEquals(formula));
@@ -1543,7 +1610,7 @@ export class HeadlessWorkbook {
             return [...names].toSorted(compareSheetNames);
         }
         catch (error) {
-            throw new HeadlessParseError(this.messageOf(error, "Unable to inspect formula"));
+            throw new WorkPaperParseError(this.messageOf(error, "Unable to inspect formula"));
         }
     }
     validateFormula(formula) {
@@ -1560,7 +1627,7 @@ export class HeadlessWorkbook {
     }
     getRegisteredFunctionNames(languageCode) {
         const code = languageCode ?? this.config.language ?? "enGB";
-        const language = HeadlessWorkbook.languageRegistry.get(code);
+        const language = WorkPaper.languageRegistry.get(code);
         const functions = [...this.functionSnapshot.values()]
             .filter((binding) => binding.publicName === binding.publicName.toUpperCase())
             .map((binding) => binding.publicName)
@@ -1575,13 +1642,13 @@ export class HeadlessWorkbook {
         if (!binding) {
             return undefined;
         }
-        const plugin = HeadlessWorkbook.functionPluginRegistry.get(binding.pluginId);
+        const plugin = WorkPaper.functionPluginRegistry.get(binding.pluginId);
         return plugin ? clonePluginDefinition(plugin) : undefined;
     }
     getAllFunctionPlugins() {
         const pluginIds = new Set([...this.functionSnapshot.values()].map((binding) => binding.pluginId));
         return [...pluginIds]
-            .map((pluginId) => HeadlessWorkbook.functionPluginRegistry.get(pluginId))
+            .map((pluginId) => WorkPaper.functionPluginRegistry.get(pluginId))
             .filter((plugin) => plugin !== undefined)
             .map((plugin) => clonePluginDefinition(plugin));
     }
@@ -1622,28 +1689,28 @@ export class HeadlessWorkbook {
         return { hours, minutes, seconds };
     }
     setCellContents(address, content) {
+        this.assertNotDisposed();
         if (!this.isItPossibleToSetCellContents(address, content)) {
-            throw new HeadlessOperationError("Cell contents cannot be set");
+            throw new WorkPaperOperationError("Cell contents cannot be set");
+        }
+        if (!isWorkPaperSheetMatrix(content) &&
+            this.enqueueDeferredBatchLiteral(address.sheet, address.row, address.col, content)) {
+            return [];
         }
         return this.captureChanges(undefined, () => {
-            if (isHeadlessSheetMatrix(content)) {
+            if (isWorkPaperSheetMatrix(content)) {
                 this.flushPendingBatchOps();
                 this.applyMatrixContents(address, content);
                 return;
             }
-            const sheetName = this.sheetName(address.sheet);
-            const a1 = this.a1(address);
-            if (this.enqueueDeferredBatchLiteral(sheetName, a1, content)) {
-                return;
-            }
             this.flushPendingBatchOps();
-            this.applyRawContent(sheetName, a1, content, address.sheet);
+            this.applyRawContent(address, content);
         });
     }
     swapRowIndexes(sheetId, rowAOrMappings, rowB) {
         const mappings = this.normalizeAxisSwapMappings("row", rowAOrMappings, rowB);
         if (!this.isItPossibleToSwapRowIndexes(sheetId, mappings)) {
-            throw new HeadlessOperationError("Rows cannot be swapped");
+            throw new WorkPaperOperationError("Rows cannot be swapped");
         }
         return this.batch(() => {
             mappings.forEach(([rowA, mappedRowB]) => {
@@ -1663,7 +1730,7 @@ export class HeadlessWorkbook {
     }
     setRowOrder(sheetId, rowOrder) {
         if (!this.isItPossibleToSetRowOrder(sheetId, rowOrder)) {
-            throw new HeadlessOperationError("Row order is invalid");
+            throw new WorkPaperOperationError("Row order is invalid");
         }
         const current = rowOrder.toSorted((left, right) => left - right);
         return this.batch(() => {
@@ -1681,7 +1748,7 @@ export class HeadlessWorkbook {
     swapColumnIndexes(sheetId, columnAOrMappings, columnB) {
         const mappings = this.normalizeAxisSwapMappings("column", columnAOrMappings, columnB);
         if (!this.isItPossibleToSwapColumnIndexes(sheetId, mappings)) {
-            throw new HeadlessOperationError("Columns cannot be swapped");
+            throw new WorkPaperOperationError("Columns cannot be swapped");
         }
         return this.batch(() => {
             mappings.forEach(([columnA, mappedColumnB]) => {
@@ -1701,7 +1768,7 @@ export class HeadlessWorkbook {
     }
     setColumnOrder(sheetId, columnOrder) {
         if (!this.isItPossibleToSetColumnOrder(sheetId, columnOrder)) {
-            throw new HeadlessOperationError("Column order is invalid");
+            throw new WorkPaperOperationError("Column order is invalid");
         }
         const current = columnOrder.toSorted((left, right) => left - right);
         return this.batch(() => {
@@ -1719,7 +1786,7 @@ export class HeadlessWorkbook {
     addRows(sheetId, startOrInterval, countOrInterval, ...restIntervals) {
         const indexes = this.normalizeAxisIntervals(startOrInterval, countOrInterval, restIntervals);
         if (!this.isItPossibleToAddRows(sheetId, ...indexes)) {
-            throw new HeadlessOperationError("Rows cannot be added");
+            throw new WorkPaperOperationError("Rows cannot be added");
         }
         return this.batch(() => {
             indexes.forEach(([start, amount]) => {
@@ -1730,7 +1797,7 @@ export class HeadlessWorkbook {
     removeRows(sheetId, startOrInterval, countOrInterval, ...restIntervals) {
         const indexes = this.normalizeAxisIntervals(startOrInterval, countOrInterval, restIntervals);
         if (!this.isItPossibleToRemoveRows(sheetId, ...indexes)) {
-            throw new HeadlessOperationError("Rows cannot be removed");
+            throw new WorkPaperOperationError("Rows cannot be removed");
         }
         return this.batch(() => {
             indexes
@@ -1743,7 +1810,7 @@ export class HeadlessWorkbook {
     addColumns(sheetId, startOrInterval, countOrInterval, ...restIntervals) {
         const indexes = this.normalizeAxisIntervals(startOrInterval, countOrInterval, restIntervals);
         if (!this.isItPossibleToAddColumns(sheetId, ...indexes)) {
-            throw new HeadlessOperationError("Columns cannot be added");
+            throw new WorkPaperOperationError("Columns cannot be added");
         }
         return this.batch(() => {
             indexes.forEach(([start, amount]) => {
@@ -1754,7 +1821,7 @@ export class HeadlessWorkbook {
     removeColumns(sheetId, startOrInterval, countOrInterval, ...restIntervals) {
         const indexes = this.normalizeAxisIntervals(startOrInterval, countOrInterval, restIntervals);
         if (!this.isItPossibleToRemoveColumns(sheetId, ...indexes)) {
-            throw new HeadlessOperationError("Columns cannot be removed");
+            throw new WorkPaperOperationError("Columns cannot be removed");
         }
         return this.batch(() => {
             indexes
@@ -1766,7 +1833,7 @@ export class HeadlessWorkbook {
     }
     moveCells(source, target) {
         if (!this.isItPossibleToMoveCells(source, target)) {
-            throw new HeadlessOperationError("Cells cannot be moved");
+            throw new WorkPaperOperationError("Cells cannot be moved");
         }
         const sourceHeight = source.end.row - source.start.row;
         const sourceWidth = source.end.col - source.start.col;
@@ -1780,7 +1847,7 @@ export class HeadlessWorkbook {
     }
     moveRows(sheetId, start, count, target) {
         if (!this.isItPossibleToMoveRows(sheetId, start, count, target)) {
-            throw new HeadlessOperationError("Rows cannot be moved");
+            throw new WorkPaperOperationError("Rows cannot be moved");
         }
         return this.captureChanges(undefined, () => {
             this.engine.moveRows(this.sheetName(sheetId), start, count, target);
@@ -1788,7 +1855,7 @@ export class HeadlessWorkbook {
     }
     moveColumns(sheetId, start, count, target) {
         if (!this.isItPossibleToMoveColumns(sheetId, start, count, target)) {
-            throw new HeadlessOperationError("Columns cannot be moved");
+            throw new WorkPaperOperationError("Columns cannot be moved");
         }
         return this.captureChanges(undefined, () => {
             this.engine.moveColumns(this.sheetName(sheetId), start, count, target);
@@ -1798,10 +1865,11 @@ export class HeadlessWorkbook {
         this.assertNotDisposed();
         const name = sheetName?.trim() || this.nextSheetName();
         if (!this.isItPossibleToAddSheet(name)) {
-            throw new SheetNameAlreadyTakenError(name);
+            throw new WorkPaperSheetNameAlreadyTakenError(name);
         }
-        const beforeVisibility = this.captureVisibilitySnapshot();
-        const beforeNames = this.captureNamedExpressionValueSnapshot();
+        const beforeVisibility = this.ensureVisibilityCache();
+        const beforeNames = this.ensureNamedExpressionValueCache();
+        this.drainTrackedEngineEvents();
         this.engine.createSheet(name);
         const sheetId = this.requireSheetId(name);
         const payload = { sheetId, sheetName: name };
@@ -1811,7 +1879,7 @@ export class HeadlessWorkbook {
         else {
             this.emitter.emitDetailed({ eventName: "sheetAdded", payload });
         }
-        const changes = this.computeChanges(beforeVisibility, this.captureVisibilitySnapshot(), beforeNames, this.captureNamedExpressionValueSnapshot());
+        const changes = this.computeChangesAfterMutation(beforeVisibility, beforeNames);
         if (!this.shouldSuppressEvents() && changes.length > 0) {
             this.emitter.emitDetailed({ eventName: "valuesUpdated", payload: { changes } });
         }
@@ -1819,7 +1887,7 @@ export class HeadlessWorkbook {
     }
     removeSheet(sheetId) {
         if (!this.isItPossibleToRemoveSheet(sheetId)) {
-            throw new HeadlessSheetError(`Sheet '${sheetId}' cannot be removed`);
+            throw new WorkPaperSheetError(`Sheet '${sheetId}' cannot be removed`);
         }
         const sheetName = this.sheetName(sheetId);
         return this.captureChanges({
@@ -1835,7 +1903,7 @@ export class HeadlessWorkbook {
     }
     clearSheet(sheetId) {
         if (!this.isItPossibleToClearSheet(sheetId)) {
-            throw new HeadlessSheetError(`Sheet '${sheetId}' cannot be cleared`);
+            throw new WorkPaperSheetError(`Sheet '${sheetId}' cannot be cleared`);
         }
         return this.captureChanges(undefined, () => {
             const dimensions = this.getSheetDimensions(sheetId);
@@ -1851,7 +1919,7 @@ export class HeadlessWorkbook {
     }
     setSheetContent(sheetId, content) {
         if (!this.isItPossibleToReplaceSheetContent(sheetId, content)) {
-            throw new HeadlessSheetError(`Sheet '${sheetId}' cannot be replaced`);
+            throw new WorkPaperSheetError(`Sheet '${sheetId}' cannot be replaced`);
         }
         return this.captureChanges(undefined, () => {
             this.replaceSheetContentInternal(sheetId, content, { duringInitialization: false });
@@ -1859,7 +1927,7 @@ export class HeadlessWorkbook {
     }
     renameSheet(sheetId, nextName) {
         if (!this.isItPossibleToRenameSheet(sheetId, nextName)) {
-            throw new HeadlessSheetError(`Sheet '${sheetId}' cannot be renamed to '${nextName}'`);
+            throw new WorkPaperSheetError(`Sheet '${sheetId}' cannot be renamed to '${nextName}'`);
         }
         const oldName = this.sheetName(sheetId);
         const newName = nextName.trim();
@@ -1891,7 +1959,7 @@ export class HeadlessWorkbook {
         }
         if (Array.isArray(content)) {
             if (!content.every((row) => Array.isArray(row))) {
-                throw new HeadlessArgumentError("Content matrix must be a two-dimensional array");
+                throw new WorkPaperInvalidArgumentsError("Content matrix must be a two-dimensional array");
             }
             const height = content.length;
             const width = Math.max(0, ...content.map((row) => row.length));
@@ -1991,7 +2059,7 @@ export class HeadlessWorkbook {
     isItPossibleToAddSheet(sheetName) {
         const trimmed = sheetName.trim();
         if (trimmed.length === 0) {
-            throw new HeadlessArgumentError("Sheet name must be non-empty");
+            throw new WorkPaperInvalidArgumentsError("Sheet name must be non-empty");
         }
         return !this.doesSheetExist(trimmed);
     }
@@ -2004,7 +2072,7 @@ export class HeadlessWorkbook {
     isItPossibleToReplaceSheetContent(sheetId, content) {
         this.sheetRecord(sheetId);
         if (!content.every((row) => Array.isArray(row))) {
-            throw new HeadlessArgumentError("Sheet content must be a two-dimensional array");
+            throw new WorkPaperInvalidArgumentsError("Sheet content must be a two-dimensional array");
         }
         const height = content.length;
         const width = Math.max(0, ...content.map((row) => row.length));
@@ -2014,7 +2082,7 @@ export class HeadlessWorkbook {
         this.sheetRecord(sheetId);
         const trimmed = nextName.trim();
         if (trimmed.length === 0) {
-            throw new HeadlessArgumentError("Sheet name must be non-empty");
+            throw new WorkPaperInvalidArgumentsError("Sheet name must be non-empty");
         }
         const existing = this.engine.workbook.getSheet(trimmed);
         return !existing || existing.id === sheetId;
@@ -2038,12 +2106,61 @@ export class HeadlessWorkbook {
             return;
         }
         this.disposed = true;
+        this.unsubscribeEngineEvents?.();
+        this.unsubscribeEngineEvents = null;
         this.emitter.clear();
         this.clearFunctionBindings();
         this.clipboard = null;
+        this.visibilityCache = null;
+        this.namedExpressionValueCache = null;
         this.queuedEvents = [];
+        this.trackedEngineEvents = [];
         this.namedExpressions.clear();
     }
+    attachEngineEventTracking() {
+        this.unsubscribeEngineEvents?.();
+        this.trackedEngineEvents = [];
+        this.unsubscribeEngineEvents = this.engine.subscribe((event) => {
+            if (!this.engineEventCaptureEnabled) {
+                return;
+            }
+            this.trackedEngineEvents.push(captureTrackedEngineEvent(event));
+        });
+    }
+    withEngineEventCaptureDisabled(callback) {
+        const previous = this.engineEventCaptureEnabled;
+        this.engineEventCaptureEnabled = false;
+        this.trackedEngineEvents = [];
+        try {
+            return callback();
+        }
+        finally {
+            this.engineEventCaptureEnabled = previous;
+            this.trackedEngineEvents = [];
+        }
+    }
+    drainTrackedEngineEvents() {
+        const events = this.trackedEngineEvents;
+        this.trackedEngineEvents = [];
+        return events;
+    }
+    primeChangeTrackingCaches() {
+        this.visibilityCache = this.captureVisibilitySnapshot();
+        this.namedExpressionValueCache = this.captureNamedExpressionValueSnapshot();
+        this.drainTrackedEngineEvents();
+    }
+    ensureVisibilityCache() {
+        if (!this.visibilityCache) {
+            this.visibilityCache = this.captureVisibilitySnapshot();
+        }
+        return this.visibilityCache;
+    }
+    ensureNamedExpressionValueCache() {
+        if (!this.namedExpressionValueCache) {
+            this.namedExpressionValueCache = this.captureNamedExpressionValueSnapshot();
+        }
+        return this.namedExpressionValueCache;
+    }
     flushPendingBatchOps() {
         if (this.pendingBatchOps.length === 0) {
             return;
@@ -2052,22 +2169,22 @@ export class HeadlessWorkbook {
         const potentialNewCells = this.pendingBatchPotentialNewCells;
         this.pendingBatchOps = [];
         this.pendingBatchPotentialNewCells = 0;
-        this.engine.applyOps(ops, {
-            captureUndo: true,
-            potentialNewCells: potentialNewCells > 0 ? potentialNewCells : undefined,
-        });
+        this.engine.applyCellMutationsAt(ops, potentialNewCells > 0 ? potentialNewCells : undefined);
     }
-    enqueueDeferredBatchLiteral(sheetName, address, content) {
+    enqueueDeferredBatchLiteral(sheetId, row, col, content) {
         if (this.batchDepth === 0 ||
             !isDeferredBatchLiteralContent(content) ||
             isFormulaContent(content)) {
             return false;
         }
         if (content === null) {
-            this.pendingBatchOps.push({ kind: "clearCell", sheetName, address });
+            this.pendingBatchOps.push({ sheetId, mutation: { kind: "clearCell", row, col } });
             return true;
         }
-        this.pendingBatchOps.push({ kind: "setCellValue", sheetName, address, value: content });
+        this.pendingBatchOps.push({
+            sheetId,
+            mutation: { kind: "setCellValue", row, col, value: content },
+        });
         this.pendingBatchPotentialNewCells += 1;
         return true;
     }
@@ -2077,19 +2194,19 @@ export class HeadlessWorkbook {
     }
     assertNotDisposed() {
         if (this.disposed) {
-            throw new HeadlessOperationError("Workbook has been disposed");
+            throw new WorkPaperOperationError("Workbook has been disposed");
         }
     }
     assertReadable() {
         this.prepareReadableState();
         if (this.evaluationSuspended) {
-            throw new HeadlessEvaluationSuspendedError();
+            throw new WorkPaperEvaluationSuspendedError();
         }
     }
     sheetRecord(sheetId) {
         const sheet = this.engine.workbook.getSheetById(sheetId);
         if (!sheet) {
-            throw new NoSheetWithIdError(sheetId);
+            throw new WorkPaperNoSheetWithIdError(sheetId);
         }
         return sheet;
     }
@@ -2099,7 +2216,7 @@ export class HeadlessWorkbook {
     requireSheetId(name) {
         const sheetId = this.getSheetId(name);
         if (sheetId === undefined) {
-            throw new NoSheetWithNameError(name);
+            throw new WorkPaperNoSheetWithNameError(name);
         }
         return sheetId;
     }
@@ -2138,15 +2255,16 @@ export class HeadlessWorkbook {
     }
     captureVisibilitySnapshot() {
         const snapshot = new Map();
+        const strings = this.engine.strings;
+        const cellStore = this.engine.workbook.cellStore;
         this.listSheetRecords().forEach((sheet) => {
             const cells = new Map();
-            sheet.grid.forEachCellEntry((_cellIndex, row, col) => {
-                const address = formatAddress(row, col);
-                const value = this.engine.getCellValue(sheet.name, address);
+            sheet.grid.forEachCellEntry((cellIndex, row, col) => {
+                const value = cellStore.getValue(cellIndex, (id) => strings.get(id));
                 if (value.tag === ValueTag.Empty) {
                     return;
                 }
-                cells.set(address, cloneCellValue(value));
+                cells.set(makeCellKey(sheet.id, row, col), value);
             });
             snapshot.set(sheet.id, {
                 sheetId: sheet.id,
@@ -2158,36 +2276,178 @@ export class HeadlessWorkbook {
         return snapshot;
     }
     captureNamedExpressionValueSnapshot() {
+        if (this.namedExpressions.size === 0) {
+            return EMPTY_NAMED_EXPRESSION_VALUES;
+        }
         const snapshot = new Map();
         [...this.namedExpressions.values()].forEach((expression) => {
             snapshot.set(makeNamedExpressionKey(expression.publicName, expression.scope), cloneNamedExpressionValue(this.evaluateNamedExpression(expression)));
         });
         return snapshot;
     }
-    computeChanges(beforeVisibility, afterVisibility, beforeNames, afterNames) {
+    computeCellChanges(beforeVisibility, afterVisibility) {
         const cellChanges = [];
         afterVisibility.forEach((afterSheet, sheetId) => {
             const beforeSheet = beforeVisibility.get(sheetId);
-            const addresses = new Set([
+            const cellKeys = new Set([
                 ...(beforeSheet?.cells.keys() ?? []),
                 ...afterSheet.cells.keys(),
             ]);
-            [...addresses].toSorted(compareSheetNames).forEach((address) => {
-                const beforeValue = beforeSheet?.cells.get(address) ?? emptyValue();
-                const afterValue = afterSheet.cells.get(address) ?? emptyValue();
+            [...cellKeys]
+                .toSorted((left, right) => left - right)
+                .forEach((cellKey) => {
+                const beforeValue = beforeSheet?.cells.get(cellKey) ?? emptyValue();
+                const afterValue = afterSheet.cells.get(cellKey) ?? emptyValue();
                 if (valuesEqual(beforeValue, afterValue)) {
                     return;
                 }
-                const parsed = parseCellAddress(address, afterSheet.sheetName);
+                const localKey = cellKey - afterSheet.sheetId * VISIBILITY_SHEET_STRIDE;
+                const row = Math.floor(localKey / MAX_COLS);
+                const col = localKey % MAX_COLS;
+                const address = formatAddress(row, col);
                 cellChanges.push({
                     kind: "cell",
-                    address: { sheet: sheetId, row: parsed.row, col: parsed.col },
+                    address: { sheet: sheetId, row, col },
                     sheetName: afterSheet.sheetName,
                     a1: address,
-                    newValue: cloneCellValue(afterValue),
+                    newValue: afterValue,
                 });
             });
         });
+        return orderWorkPaperCellChanges(cellChanges, this.listSheetRecords());
+    }
+    computeCellChangesFromTrackedEvents(beforeVisibility, events) {
+        if (events.some((event) => event.invalidation === "full" ||
+            event.hasInvalidatedRanges ||
+            event.hasInvalidatedRows ||
+            event.hasInvalidatedColumns)) {
+            return null;
+        }
+        const cellStore = this.engine.workbook.cellStore;
+        const strings = this.engine.strings;
+        const nextVisibility = beforeVisibility;
+        const sheetNames = new Map();
+        const ensureSheetName = (sheetId) => {
+            const cached = sheetNames.get(sheetId);
+            if (cached !== undefined) {
+                return cached;
+            }
+            const sheet = this.engine.workbook.getSheetById(sheetId);
+            if (!sheet) {
+                return null;
+            }
+            sheetNames.set(sheetId, sheet.name);
+            return sheet.name;
+        };
+        const ensureMutableSheet = (sheetId, sheetName) => {
+            const existing = nextVisibility.get(sheetId);
+            if (existing) {
+                return existing;
+            }
+            const created = {
+                sheetId,
+                sheetName,
+                order: this.sheetRecord(sheetId).order,
+                cells: new Map(),
+            };
+            nextVisibility.set(sheetId, created);
+            return created;
+        };
+        const collectDirectChanges = (changedCellIndices, seen) => {
+            const changes = [];
+            let previousSheetId = -1;
+            let previousRow = -1;
+            let previousCol = -1;
+            let isSorted = true;
+            for (let index = 0; index < changedCellIndices.length; index += 1) {
+                const cellIndex = changedCellIndices[index];
+                const sheetId = cellStore.sheetIds[cellIndex];
+                const row = cellStore.rows[cellIndex];
+                const col = cellStore.cols[cellIndex];
+                if (sheetId === undefined || row === undefined || col === undefined) {
+                    return null;
+                }
+                if (seen) {
+                    const logicalCellKey = makeCellKey(sheetId, row, col);
+                    if (seen.has(logicalCellKey)) {
+                        continue;
+                    }
+                    seen.add(logicalCellKey);
+                }
+                const sheetName = ensureSheetName(sheetId);
+                if (!sheetName) {
+                    return null;
+                }
+                const cellKey = makeCellKey(sheetId, row, col);
+                const address = formatAddress(row, col);
+                const beforeValue = beforeVisibility.get(sheetId)?.cells.get(cellKey) ?? emptyValue();
+                const afterValue = cellStore.getValue(cellIndex, (id) => strings.get(id));
+                if (valuesEqual(beforeValue, afterValue)) {
+                    continue;
+                }
+                if (previousSheetId > sheetId ||
+                    (previousSheetId === sheetId &&
+                        (previousRow > row || (previousRow === row && previousCol > col)))) {
+                    isSorted = false;
+                }
+                previousSheetId = sheetId;
+                previousRow = row;
+                previousCol = col;
+                const sheet = ensureMutableSheet(sheetId, sheetName);
+                if (afterValue.tag === ValueTag.Empty) {
+                    sheet.cells.delete(cellKey);
+                }
+                else {
+                    sheet.cells.set(cellKey, afterValue);
+                }
+                changes.push({
+                    kind: "cell",
+                    address: { sheet: sheetId, row, col },
+                    sheetName,
+                    a1: address,
+                    newValue: afterValue,
+                });
+            }
+            return { changes, isSorted };
+        };
+        if (events.length === 1) {
+            const event = events[0];
+            const direct = collectDirectChanges(event.changedCellIndices, new Set());
+            if (direct === null) {
+                return null;
+            }
+            return {
+                changes: direct.isSorted
+                    ? direct.changes
+                    : orderWorkPaperCellChanges(direct.changes, this.listSheetRecords(), event.explicitChangedCount),
+                nextVisibility,
+            };
+        }
+        const latestCellIndicesByKey = new Map();
+        for (const event of events) {
+            for (let index = 0; index < event.changedCellIndices.length; index += 1) {
+                const cellIndex = event.changedCellIndices[index];
+                const sheetId = cellStore.sheetIds[cellIndex];
+                const row = cellStore.rows[cellIndex];
+                const col = cellStore.cols[cellIndex];
+                if (sheetId === undefined || row === undefined || col === undefined) {
+                    return null;
+                }
+                latestCellIndicesByKey.set(makeCellKey(sheetId, row, col), cellIndex);
+            }
+        }
+        const direct = collectDirectChanges(Uint32Array.from(latestCellIndicesByKey.values()), null);
+        if (direct === null) {
+            return null;
+        }
+        return {
+            changes: direct.isSorted
+                ? direct.changes
+                : orderWorkPaperCellChanges(direct.changes, this.listSheetRecords()),
+            nextVisibility,
+        };
+    }
+    computeNamedExpressionChanges(beforeNames, afterNames) {
         const namedExpressionChanges = [];
         afterNames.forEach((afterValue, key) => {
             const beforeValue = beforeNames.get(key);
@@ -2205,40 +2465,73 @@ export class HeadlessWorkbook {
                 newValue: cloneNamedExpressionValue(afterValue),
             });
         });
-        return [
-            ...cellChanges.toSorted(compareHeadlessCellChanges(this.listSheetRecords())),
-            ...namedExpressionChanges.toSorted(compareHeadlessNamedExpressionChanges),
-        ];
+        return namedExpressionChanges.toSorted(compareWorkPaperNamedExpressionChanges);
+    }
+    computeChangesAfterMutation(beforeVisibility, beforeNames) {
+        const hasNamedExpressions = this.namedExpressions.size > 0;
+        const afterNames = hasNamedExpressions
+            ? this.captureNamedExpressionValueSnapshot()
+            : EMPTY_NAMED_EXPRESSION_VALUES;
+        const fastPath = this.computeCellChangesFromTrackedEvents(beforeVisibility, this.drainTrackedEngineEvents());
+        let cellChanges;
+        if (fastPath) {
+            cellChanges = fastPath.changes;
+            this.visibilityCache = fastPath.nextVisibility;
+        }
+        else {
+            const afterVisibility = this.captureVisibilitySnapshot();
+            cellChanges = this.computeCellChanges(beforeVisibility, afterVisibility);
+            this.visibilityCache = afterVisibility;
+        }
+        this.namedExpressionValueCache = afterNames;
+        return hasNamedExpressions
+            ? [...cellChanges, ...this.computeNamedExpressionChanges(beforeNames, afterNames)]
+            : cellChanges;
     }
     captureChanges(semanticEvent, mutate) {
         this.assertNotDisposed();
         if (semanticEvent !== undefined) {
             this.flushPendingBatchOps();
         }
-        if (semanticEvent === undefined && this.shouldSuppressEvents()) {
+        if (this.shouldSuppressEvents()) {
             try {
                 mutate();
             }
             catch (error) {
-                if (error instanceof Error && HEADLESS_PUBLIC_ERROR_NAMES.has(error.name)) {
+                if (error instanceof Error && WORKPAPER_PUBLIC_ERROR_NAMES.has(error.name)) {
                     throw error;
                 }
-                throw new HeadlessOperationError(this.messageOf(error, "Mutation failed"));
+                throw new WorkPaperOperationError(this.messageOf(error, "Mutation failed"));
+            }
+            if (semanticEvent) {
+                this.queuedEvents.push(semanticEvent);
             }
             return [];
         }
-        const beforeVisibility = this.captureVisibilitySnapshot();
-        const beforeNames = this.captureNamedExpressionValueSnapshot();
+        const beforeVisibility = this.ensureVisibilityCache();
+        const beforeNames = this.ensureNamedExpressionValueCache();
+        this.drainTrackedEngineEvents();
         try {
             mutate();
         }
         catch (error) {
-            if (error instanceof Error && HEADLESS_PUBLIC_ERROR_NAMES.has(error.name)) {
+            if (error instanceof Error && WORKPAPER_PUBLIC_ERROR_NAMES.has(error.name)) {
                 throw error;
             }
-            throw new HeadlessOperationError(this.messageOf(error, "Mutation failed"));
-        }
-        const changes = this.computeChanges(beforeVisibility, this.captureVisibilitySnapshot(), beforeNames, this.captureNamedExpressionValueSnapshot());
+            throw new WorkPaperOperationError(this.messageOf(error, "Mutation failed"));
+        }
+        const changes = semanticEvent === undefined
+            ? this.computeChangesAfterMutation(beforeVisibility, beforeNames)
+            : (() => {
+                const afterVisibility = this.captureVisibilitySnapshot();
+                const afterNames = this.captureNamedExpressionValueSnapshot();
+                this.visibilityCache = afterVisibility;
+                this.namedExpressionValueCache = afterNames;
+                return [
+                    ...this.computeCellChanges(beforeVisibility, afterVisibility),
+                    ...this.computeNamedExpressionChanges(beforeNames, afterNames),
+                ];
+            })();
         if (semanticEvent) {
             const event = withEventChanges(semanticEvent, changes);
             if (this.shouldSuppressEvents()) {
@@ -2325,99 +2618,109 @@ export class HeadlessWorkbook {
                     if (typeof raw === "string" && raw.startsWith("=")) {
                         nextValue = `=${translateFormulaReferences(raw.slice(1), destination.row - (sourceAnchor.row + rowOffset), destination.col - (sourceAnchor.col + columnOffset))}`;
                     }
-                    this.applyRawContent(this.sheetName(destination.sheet), this.a1(destination), nextValue, destination.sheet);
+                    this.applyRawContent(destination, nextValue);
                 });
             });
             return;
         }
-        const sheetName = this.sheetName(targetLeftCorner.sheet);
-        const { ops, potentialNewCells } = buildMatrixMutationPlan({
+        const { refs, potentialNewCells } = buildMatrixMutationPlan({
             target: targetLeftCorner,
-            targetSheetName: sheetName,
             content: serialized,
             rewriteFormula: (formula, destination, rowOffset, columnOffset) => this.rewriteFormulaForStorage(translateFormulaReferences(stripLeadingEquals(formula), destination.row - (sourceAnchor.row + rowOffset), destination.col - (sourceAnchor.col + columnOffset)), destination.sheet),
         });
-        if (ops.length === 0) {
+        if (refs.length === 0) {
             return;
         }
-        this.engine.applyOps(ops, { potentialNewCells });
+        this.engine.applyCellMutationsAtWithOptions(refs, {
+            captureUndo: true,
+            potentialNewCells,
+            source: "local",
+        });
     }
     applyMatrixContents(address, content, options = {}) {
         this.flushPendingBatchOps();
-        if (matrixContainsFormulaContent(content)) {
-            content.forEach((row, rowOffset) => {
-                row.forEach((raw, columnOffset) => {
-                    if (raw === null && options.skipNulls) {
-                        return;
-                    }
-                    this.applyRawContent(this.sheetName(address.sheet), formatAddress(address.row + rowOffset, address.col + columnOffset), raw, address.sheet);
-                });
-            });
-            return;
-        }
-        const sheetName = this.sheetName(address.sheet);
-        const { ops, potentialNewCells } = buildMatrixMutationPlan({
+        const { leadingRefs, formulaRefs, refs, potentialNewCells, trailingLiteralRefs } = buildMatrixMutationPlan({
             target: address,
-            targetSheetName: sheetName,
             content,
+            deferLiteralAddresses: options.deferLiteralAddresses,
             skipNulls: options.skipNulls,
             rewriteFormula: (formula, destination) => this.rewriteFormulaForStorage(stripLeadingEquals(formula), destination.sheet),
         });
-        if (ops.length === 0) {
+        if (refs.length === 0) {
+            return;
+        }
+        const applyPlannedRefs = (phaseRefs, applyOptions) => {
+            if (phaseRefs.length === 0) {
+                return;
+            }
+            this.engine.applyCellMutationsAtWithOptions(phaseRefs, applyOptions);
+        };
+        const phaseSource = options.captureUndo === false ? "restore" : "local";
+        if (formulaRefs.length === 0) {
+            applyPlannedRefs(refs, {
+                captureUndo: options.captureUndo,
+                potentialNewCells,
+                source: phaseSource,
+            });
             return;
         }
-        this.engine.applyOps(ops, {
+        applyPlannedRefs(leadingRefs, {
+            captureUndo: options.captureUndo,
+            potentialNewCells,
+            source: phaseSource,
+        });
+        applyPlannedRefs(formulaRefs, {
+            captureUndo: options.captureUndo,
+            potentialNewCells,
+            source: phaseSource,
+        });
+        applyPlannedRefs(trailingLiteralRefs, {
             captureUndo: options.captureUndo,
             potentialNewCells,
+            source: phaseSource,
         });
     }
     replaceSheetContentInternal(sheetId, content, options) {
-        const sheetName = this.sheetName(sheetId);
-        const undoStackStart = options.duringInitialization ? 0 : this.getUndoStack().length;
-        const dimensions = this.getSheetDimensions(sheetId);
-        if (dimensions.width > 0 && dimensions.height > 0) {
-            this.engine.clearRange({
-                sheetName,
-                startAddress: "A1",
-                endAddress: formatAddress(dimensions.height - 1, dimensions.width - 1),
-            });
-        }
-        this.applyMatrixContents({ sheet: sheetId, row: 0, col: 0 }, content, {
-            captureUndo: !options.duringInitialization,
-            skipNulls: true,
+        replaceWorkPaperSheetContent({
+            sheetId,
+            sheetName: this.sheetName(sheetId),
+            content,
+            duringInitialization: options.duringInitialization,
+            listSpills: () => this.engine.workbook.listSpills(),
+            getSheetDimensions: (nextSheetId) => this.getSheetDimensions(nextSheetId),
+            clearRange: (input) => this.engine.clearRange(input),
+            applyMatrixContents: (address, nextContent, applyOptions) => this.applyMatrixContents(address, nextContent, applyOptions),
+            clearHistoryStacks: () => this.clearHistoryStacks(),
+            getUndoStackLength: () => this.getUndoStack().length,
+            mergeUndoHistory: (undoStackStart) => this.mergeUndoHistory(undoStackStart),
         });
-        if (options.duringInitialization) {
-            this.clearHistoryStacks();
-            return;
-        }
-        this.mergeUndoHistory(undoStackStart);
     }
-    applyRawContent(sheetName, address, content, ownerSheetId) {
+    applyRawContent(address, content) {
         if (content === null) {
-            this.engine.clearCell(sheetName, address);
+            this.engine.clearCellAt(address.sheet, address.row, address.col);
             return;
         }
         if (typeof content === "boolean" || typeof content === "number") {
-            this.engine.setCellValue(sheetName, address, content);
+            this.engine.setCellValueAt(address.sheet, address.row, address.col, content);
             return;
         }
         if (typeof content === "string" && content.trim().startsWith("=")) {
-            this.engine.setCellFormula(sheetName, address, this.rewriteFormulaForStorage(stripLeadingEquals(content), ownerSheetId));
+            this.engine.setCellFormulaAt(address.sheet, address.row, address.col, this.rewriteFormulaForStorage(stripLeadingEquals(content), address.sheet));
             return;
         }
-        this.engine.setCellValue(sheetName, address, content);
+        this.engine.setCellValueAt(address.sheet, address.row, address.col, content);
     }
     captureFunctionRegistry() {
         const allowedPluginIds = this.config.functionPlugins && this.config.functionPlugins.length > 0
             ? new Set(this.config.functionPlugins.map((plugin) => plugin.id))
             : undefined;
-        HeadlessWorkbook.functionPluginRegistry.forEach((plugin) => {
+        WorkPaper.functionPluginRegistry.forEach((plugin) => {
             if (allowedPluginIds && !allowedPluginIds.has(plugin.id)) {
                 return;
             }
             Object.keys(plugin.implementedFunctions).forEach((functionId) => {
                 const normalized = functionId.trim().toUpperCase();
-                const internalName = `__BILIG_HEADLESS_FN_${this.workbookId}_${normalized}`;
+                const internalName = `__BILIG_WORKPAPER_FN_${this.workbookId}_${normalized}`;
                 const implementation = plugin.functions?.[normalized];
                 const binding = {
                     pluginId: plugin.id,
@@ -2450,7 +2753,7 @@ export class HeadlessWorkbook {
         this.internalFunctionLookup.clear();
     }
     rebuildWithConfig(nextConfig) {
-        validateHeadlessConfig(nextConfig);
+        validateWorkPaperConfig(nextConfig);
         const serializedSheets = this.getAllSheetsSerialized();
         Object.entries(serializedSheets).forEach(([sheetName, sheet]) => {
             validateSheetWithinLimits(sheetName, sheet, nextConfig);
@@ -2466,43 +2769,53 @@ export class HeadlessWorkbook {
             : null;
         this.clearFunctionBindings();
         this.namedExpressions.clear();
-        this.engine = new SpreadsheetEngine({ workbookName: "Workbook" });
+        this.engine = new SpreadsheetEngine({
+            workbookName: "Workbook",
+            useColumnIndex: this.config.useColumnIndex,
+            trackReplicaVersions: false,
+        });
+        this.attachEngineEventTracking();
         this.config = cloneConfig(nextConfig);
         this.captureFunctionRegistry();
-        Object.keys(serializedSheets).forEach((sheetName) => {
-            this.engine.createSheet(sheetName);
-        });
-        serializedNamedExpressions.forEach((expression) => {
-            this.upsertNamedExpressionInternal(expression, { duringInitialization: true });
-        });
-        Object.entries(serializedSheets).forEach(([sheetName, sheet]) => {
-            const sheetId = this.requireSheetId(sheetName);
-            this.replaceSheetContentInternal(sheetId, sheet, { duringInitialization: true });
+        this.withEngineEventCaptureDisabled(() => {
+            Object.keys(serializedSheets).forEach((sheetName) => {
+                this.engine.createSheet(sheetName);
+            });
+            serializedNamedExpressions.forEach((expression) => {
+                this.upsertNamedExpressionInternal(expression, { duringInitialization: true });
+            });
+            Object.entries(serializedSheets).forEach(([sheetName, sheet]) => {
+                const sheetId = this.requireSheetId(sheetName);
+                if (!tryLoadInitialLiteralSheet(this.engine, sheetId, sheet)) {
+                    this.replaceSheetContentInternal(sheetId, sheet, { duringInitialization: true });
+                }
+            });
         });
         this.clearHistoryStacks();
+        this.primeChangeTrackingCaches();
         this.clipboard = clipboard;
         if (suspended) {
-            this.suspendedVisibility = this.captureVisibilitySnapshot();
-            this.suspendedNamedValues = this.captureNamedExpressionValueSnapshot();
+            this.suspendedVisibility = this.ensureVisibilityCache();
+            this.suspendedNamedValues = this.ensureNamedExpressionValueCache();
         }
     }
     normalizeAxisIntervals(startOrInterval, countOrInterval, restIntervals = []) {
         if (typeof startOrInterval === "number") {
             if (Array.isArray(countOrInterval)) {
-                throw new HeadlessArgumentError("Axis interval count must be a number");
+                throw new WorkPaperInvalidArgumentsError("Axis interval count must be a number");
             }
             const resolvedCount = typeof countOrInterval === "number" ? countOrInterval : 1;
             return [[startOrInterval, resolvedCount]];
         }
         if (typeof countOrInterval === "number") {
-            throw new HeadlessArgumentError("Axis interval count is only valid with a numeric start");
+            throw new WorkPaperInvalidArgumentsError("Axis interval count is only valid with a numeric start");
         }
         return [startOrInterval, ...(countOrInterval ? [countOrInterval] : []), ...restIntervals].map(([start, count]) => [start, count ?? 1]);
     }
     normalizeAxisSwapMappings(label, startOrMappings, end) {
         if (typeof startOrMappings === "number") {
             if (end === undefined) {
-                throw new HeadlessArgumentError(`${label} swap requires two indexes`);
+                throw new WorkPaperInvalidArgumentsError(`${label} swap requires two indexes`);
             }
             return [[startOrMappings, end]];
         }
@@ -2531,6 +2844,9 @@ export class HeadlessWorkbook {
         return collected;
     }
     rewriteFormulaForStorage(formula, ownerSheetId) {
+        if (this.namedExpressions.size === 0 && this.functionAliasLookup.size === 0) {
+            return formula;
+        }
         try {
             const transformed = transformFormulaNode(parseFormula(stripLeadingEquals(formula)), (node) => {
                 if (node.kind === "NameRef") {
@@ -2544,10 +2860,13 @@ export class HeadlessWorkbook {
             return serializeFormula(transformed);
         }
         catch (error) {
-            throw new HeadlessParseError(this.messageOf(error, "Unable to store formula"));
+            throw new WorkPaperParseError(this.messageOf(error, "Unable to store formula"));
         }
     }
     restorePublicFormula(formula, ownerSheetId) {
+        if (this.namedExpressions.size === 0 && this.functionAliasLookup.size === 0) {
+            return formula;
+        }
         const transformed = transformFormulaNode(parseFormula(formula), (node) => {
             if (node.kind === "NameRef") {
                 return this.rewriteNameRefForPublic(node, ownerSheetId);
@@ -2594,7 +2913,7 @@ export class HeadlessWorkbook {
     validateNamedExpression(expressionName, expression, scope) {
         const trimmed = expressionName.trim();
         if (!/^[A-Za-z_][A-Za-z0-9_.]*$/.test(trimmed) || isCellReferenceText(trimmed)) {
-            throw new NamedExpressionNameIsInvalidError(expressionName);
+            throw new WorkPaperNamedExpressionNameIsInvalidError(expressionName);
         }
         if (scope !== undefined) {
             this.sheetRecord(scope);
@@ -2603,14 +2922,14 @@ export class HeadlessWorkbook {
             try {
                 const parsed = parseFormula(stripLeadingEquals(expression));
                 if (formulaHasRelativeReferences(parsed)) {
-                    throw new NoRelativeAddressesAllowedError();
+                    throw new WorkPaperNoRelativeAddressesAllowedError();
                 }
             }
             catch (error) {
-                if (error instanceof NoRelativeAddressesAllowedError) {
+                if (error instanceof WorkPaperNoRelativeAddressesAllowedError) {
                     throw error;
                 }
-                throw new UnableToParseError({
+                throw new WorkPaperUnableToParseError({
                     expressionName,
                     reason: this.messageOf(error, `Invalid named expression formula for '${expressionName}'`),
                 });
@@ -2652,7 +2971,7 @@ export class HeadlessWorkbook {
         if (direct) {
             return direct;
         }
-        throw new NamedExpressionDoesNotExistError(name);
+        throw new WorkPaperNamedExpressionDoesNotExistError(name);
     }
     evaluateNamedExpression(expression) {
         const raw = expression.expression;
@@ -2734,23 +3053,12 @@ function cloneNamedExpressionValue(value) {
     }
     return value.map((row) => row.map((cell) => cloneCellValue(cell)));
 }
-function compareHeadlessNamedExpressionChanges(left, right) {
+function compareWorkPaperNamedExpressionChanges(left, right) {
     if (left.kind !== "named-expression" || right.kind !== "named-expression") {
         return 0;
     }
     return (left.scope ?? -1) - (right.scope ?? -1) || left.name.localeCompare(right.name);
 }
-function compareHeadlessCellChanges(sheets) {
-    const orderBySheet = new Map(sheets.map((sheet) => [sheet.id, sheet.order]));
-    return (left, right) => {
-        if (left.kind !== "cell" || right.kind !== "cell") {
-            return 0;
-        }
-        return ((orderBySheet.get(left.address.sheet) ?? 0) - (orderBySheet.get(right.address.sheet) ?? 0) ||
-            left.address.row - right.address.row ||
-            left.address.col - right.address.col);
-    };
-}
 function sourceRangeRef(sheetName, range) {
     return {
         sheetName,
@@ -2765,4 +3073,4 @@ function sumNumbers(values) {
     }
     return filtered.reduce((sum, value) => sum + value, 0);
 }
-//# sourceMappingURL=headless-workbook.js.map
+//# sourceMappingURL=work-paper-runtime.js.map