mapshaper 0.7.10 → 0.7.11

package/www/mapshaper-gui.js

@@ -5472,7 +5472,7 @@
 
     function getUndoStorageLimit(name, defaultValue) {
       var opt = gui.options && gui.options[name],
-          query = getQueryValue$4(name);
+          query = getQueryValue$2(name);
       if (query !== null && +query >= 0) return +query;
       return opt >= 0 ? opt : defaultValue;
     }
@@ -5540,10 +5540,10 @@
 
   function getUndoStorageLimitLabel(store) {
     var stats = store && store.getStats ? store.getStats() : null;
-    return formatBytes$2(stats && stats.maxBytes || 1024 * 1024 * 1024);
+    return formatBytes$1(stats && stats.maxBytes || 1024 * 1024 * 1024);
   }
 
-  function formatBytes$2(bytes) {
+  function formatBytes$1(bytes) {
     var units = ['B', 'KB', 'MB', 'GB'];
     var value = bytes;
     var i = 0;
@@ -5554,7 +5554,97 @@
     return (i === 0 ? String(value) : value.toFixed(value < 10 ? 1 : 0)) + ' ' + units[i];
   }
 
-  function getQueryValue$4(key) {
+  function getQueryValue$2(key) {
+    var rxp, match;
+    if (typeof window == 'undefined' || !window.location) return null;
+    rxp = new RegExp('[?&]' + key + '=([^&]+)');
+    match = rxp.exec(window.location.search);
+    return match ? decodeURIComponent(match[1]) : null;
+  }
+
+  // Shared helpers for GUI controls that need to create app-level undo entries
+  // (the storage-backed undo flow used by console commands and a few GUI actions).
+  //
+  // The five GUI controls that grew their own copies of these helpers in the
+  // initial undo/redo commit (gui-add-layer-popup, gui-import-control,
+  // gui-layer-control, gui-simplify-control, gui-undo) should import from here
+  // instead.
+
+
+  var DEFAULT_HISTORY_LIMIT = 10;
+
+  // Returns true if the manifest, URL query, gui-installed checker, or
+  // localStorage indicates that app-level undo should be active.
+  function appUndoIsEnabled(gui) {
+    var opt = gui && gui.options && (gui.options.undoCommands || gui.options.appUndo);
+    var query = getUndoQueryValue();
+    if (opt === true || query == 'on' || query == 'commands') return true;
+    if (gui && gui.appUndoIsEnabled) return gui.appUndoIsEnabled();
+    return appUndoSettingIsOn();
+  }
+
+  // True when the undo URL flag forces app undo on regardless of UI settings.
+  // Mirrors the toggle-disable behavior in HistoryMenu.
+  function appUndoForcedByUrl() {
+    var query = getUndoQueryValue();
+    return query == 'on' || query == 'commands';
+  }
+
+  // Read the persisted localStorage opt-in. Returns false in non-browser
+  // environments or when storage is blocked.
+  function appUndoSettingIsOn() {
+    try {
+      return !!(typeof window != 'undefined' && window.localStorage &&
+        window.localStorage.getItem('mapshaper.undo') == 'on');
+    } catch(e) {
+      return false;
+    }
+  }
+
+  // Returns the per-gui-instance stored undo history, creating it on first use.
+  // Memoizing on `gui` avoids constructing parallel histories from different
+  // callers (the original code created multiple instances depending on which
+  // control ran first).
+  function getStoredUndoHistory(gui) {
+    if (!gui.storedUndoHistory) {
+      gui.storedUndoHistory = createStoredUndoHistory(gui);
+    }
+    return gui.storedUndoHistory;
+  }
+
+  function getUndoHistoryLimit(gui) {
+    var opt = gui && gui.options && gui.options.undoHistoryLimit;
+    return opt > 0 ? opt : DEFAULT_HISTORY_LIMIT;
+  }
+
+  // Construct an UndoTransaction if and only if app undo is enabled and the
+  // transaction can plausibly be added to history. Returns null when undo is
+  // off, when the gui's undo manager is missing, or when the UndoTransaction
+  // constructor cannot be located on the internal namespace.
+  function createUndoTransaction(gui, label) {
+    var Transaction;
+    if (!appUndoIsEnabled(gui)) return null;
+    if (!gui || !gui.undo || typeof gui.undo.addHistoryState != 'function') return null;
+    Transaction = internal.UndoTransaction &&
+      (internal.UndoTransaction.UndoTransaction || internal.UndoTransaction);
+    return Transaction ? new Transaction(label || '') : null;
+  }
+
+  // Add a captured transaction to gui-level history. Pass options through to
+  // stored-undo-history.addTransaction(); fills in maxStates when not provided.
+  function addUndoTransactionToHistory(gui, tx, opts) {
+    if (!tx) return Promise.resolve(null);
+    var fullOpts = Object.assign({maxStates: getUndoHistoryLimit(gui)}, opts || {});
+    return getStoredUndoHistory(gui).addTransaction(tx, fullOpts).catch(function(e) {
+      console.error(e);
+    });
+  }
+
+  function getUndoQueryValue() {
+    return getQueryValue$1('undo');
+  }
+
+  function getQueryValue$1(key) {
     var rxp, match;
     if (typeof window == 'undefined' || !window.location) return null;
     rxp = new RegExp('[?&]' + key + '=([^&]+)');
@@ -5588,7 +5678,7 @@
   function addEmptyLayer(gui, name, type) {
     var targ = gui.model.getActiveLayer();
     var crsInfo = targ && internal.getDatasetCrsInfo(targ.dataset);
-    var undoTransaction = createAddLayerUndoTransaction(gui);
+    var undoTransaction = createUndoTransaction(gui, 'add empty layer');
     var dataset = {
       layers: [{
         name: name || undefined,
@@ -5608,60 +5698,12 @@
     }
     gui.model.addDataset(dataset);
     gui.model.updated({select: true});
-    addEmptyLayerUndoHistory(gui, undoTransaction);
-  }
-
-  function createAddLayerUndoTransaction(gui) {
-    var Transaction;
-    if (!appUndoIsEnabled(gui)) return null;
-    if (!gui.undo || typeof gui.undo.addHistoryState != 'function') return null;
-    Transaction = internal.UndoTransaction && (internal.UndoTransaction.UndoTransaction || internal.UndoTransaction);
-    return Transaction ? new Transaction('add empty layer') : null;
-  }
-
-  function addEmptyLayerUndoHistory(gui, tx) {
-    if (!tx) return;
-    getStoredUndoHistory(gui).addTransaction(tx, {
+    addUndoTransactionToHistory(gui, undoTransaction, {
       flags: {select: true},
-      entryPrefix: 'add-layer',
-      maxStates: getUndoHistoryLimit(gui)
-    }).catch(function(e) {
-      console.error(e);
+      entryPrefix: 'add-layer'
     });
   }
 
-  function getStoredUndoHistory(gui) {
-    if (!gui.storedUndoHistory) {
-      gui.storedUndoHistory = createStoredUndoHistory(gui);
-    }
-    return gui.storedUndoHistory;
-  }
-
-  function getUndoHistoryLimit(gui) {
-    var opt = gui.options && gui.options.undoHistoryLimit;
-    return opt > 0 ? opt : 10;
-  }
-
-  function appUndoIsEnabled(gui) {
-    var opt = gui.options && (gui.options.undoCommands || gui.options.appUndo);
-    var query = getQueryValue$3('undo');
-    if (opt === true || query == 'on' || query == 'commands') return true;
-    if (gui.appUndoIsEnabled) return gui.appUndoIsEnabled();
-    try {
-      return window.localStorage && window.localStorage.getItem('mapshaper.undo') == 'on';
-    } catch(e) {
-      return false;
-    }
-  }
-
-  function getQueryValue$3(key) {
-    var rxp, match;
-    if (typeof window == 'undefined' || !window.location) return null;
-    rxp = new RegExp('[?&]' + key + '=([^&]+)');
-    match = rxp.exec(window.location.search);
-    return match ? decodeURIComponent(match[1]) : null;
-  }
-
   async function considerReprojecting(gui, dataset, opts) {
     var mapCRS = gui.map.getActiveLayerCRS();
     var dataCRS = internal.getDatasetCRS(dataset);
@@ -5709,7 +5751,7 @@
   }
 
   async function loadGeoParquetLib() {
-    if (!window.modules || !window.modules.hyparquet || !window.modules['hyparquet-compressors'] || !window.modules['hyparquet-writer'] || !window.modules['zstd-codec']) {
+    if (!window.modules || !window.modules.hyparquet || !window.modules['hyparquet-compressors'] || !window.modules['hyparquet-writer'] || !window.modules['@bokuweb/zstd-wasm']) {
       if (!geoParquetPromise) {
         geoParquetPromise = loadScript('geoparquet.js');
       }
@@ -5921,7 +5963,7 @@
       // gui.container.removeClass('queued-files');
       hideImportMenu();
       var files = queuedFiles;
-      var undoTransaction = createImportUndoTransaction();
+      var undoTransaction = model.isEmpty() ? null : createUndoTransaction(gui, 'import files');
       var imported = false;
       try {
         if (files.length > 0) {
@@ -5941,7 +5983,10 @@
         gui.clearMode();
       }
       if (undoTransaction && imported) {
-        addImportUndoHistory(undoTransaction);
+        addUndoTransactionToHistory(gui, undoTransaction, {
+          flags: {select: true, arc_count: true},
+          entryPrefix: 'import'
+        });
       }
     }
 
@@ -6174,56 +6219,6 @@
       return imported;
     }
 
-    function createImportUndoTransaction() {
-      var Transaction;
-      if (model.isEmpty() || !appUndoIsEnabled()) return null;
-      if (!gui.undo || typeof gui.undo.addHistoryState != 'function') return null;
-      Transaction = internal.UndoTransaction && (internal.UndoTransaction.UndoTransaction || internal.UndoTransaction);
-      return Transaction ? new Transaction('import files') : null;
-    }
-
-    function addImportUndoHistory(tx) {
-      getStoredUndoHistory().addTransaction(tx, {
-        flags: {select: true, arc_count: true},
-        entryPrefix: 'import',
-        maxStates: getUndoHistoryLimit()
-      }).catch(function(e) {
-        console.error(e);
-      });
-    }
-
-    function getStoredUndoHistory() {
-      if (!gui.storedUndoHistory) {
-        gui.storedUndoHistory = createStoredUndoHistory(gui);
-      }
-      return gui.storedUndoHistory;
-    }
-
-    function getUndoHistoryLimit() {
-      var opt = gui.options && gui.options.undoHistoryLimit;
-      return opt > 0 ? opt : 10;
-    }
-
-    function appUndoIsEnabled() {
-      var opt = gui.options && (gui.options.undoCommands || gui.options.appUndo);
-      var query = getQueryValue('undo');
-      if (opt === true || query == 'on' || query == 'commands') return true;
-      if (gui.appUndoIsEnabled) return gui.appUndoIsEnabled();
-      try {
-        return window.localStorage && window.localStorage.getItem('mapshaper.undo') == 'on';
-      } catch(e) {
-        return false;
-      }
-    }
-
-    function getQueryValue(key) {
-      var rxp, match;
-      if (typeof window == 'undefined' || !window.location) return null;
-      rxp = new RegExp('[?&]' + key + '=([^&]+)');
-      match = rxp.exec(window.location.search);
-      return match ? decodeURIComponent(match[1]) : null;
-    }
-
 
 
     function filesMayContainPaths(files) {
@@ -7789,8 +7784,8 @@
 
     function startSimplifyUndoSession(dataset) {
       var tx;
-      if (!dataset || !dataset.arcs || !appUndoIsEnabled()) return;
-      tx = createSimplifyUndoTransaction();
+      if (!dataset || !dataset.arcs || !appUndoIsEnabled(gui)) return;
+      tx = createUndoTransaction(gui, 'simplify');
       if (!tx) return;
       tx.captureArcsSimplificationBefore(dataset.arcs, {operation: 'simplifyTool'});
       tx.captureDatasetInfoBefore(dataset, {operation: 'simplifyTool'});
@@ -7808,54 +7803,12 @@
       var session = undoSession;
       undoSession = null;
       if (!session || !session.changed) return;
-      getStoredUndoHistory().addTransaction(session.tx, {
+      addUndoTransactionToHistory(gui, session.tx, {
         flags: {simplify: true, info: true},
-        entryPrefix: 'simplify-tool',
-        maxStates: getUndoHistoryLimit()
-      }).catch(function(e) {
-        console.error(e);
+        entryPrefix: 'simplify-tool'
       });
     }
 
-    function createSimplifyUndoTransaction() {
-      var Transaction;
-      if (!gui.undo || typeof gui.undo.addHistoryState != 'function') return null;
-      Transaction = internal.UndoTransaction && (internal.UndoTransaction.UndoTransaction || internal.UndoTransaction);
-      return Transaction ? new Transaction('simplify') : null;
-    }
-
-    function getStoredUndoHistory() {
-      if (!gui.storedUndoHistory) {
-        gui.storedUndoHistory = createStoredUndoHistory(gui);
-      }
-      return gui.storedUndoHistory;
-    }
-
-    function getUndoHistoryLimit() {
-      var opt = gui.options && gui.options.undoHistoryLimit;
-      return opt > 0 ? opt : 10;
-    }
-
-    function appUndoIsEnabled() {
-      var opt = gui.options && (gui.options.undoCommands || gui.options.appUndo);
-      var query = getQueryValue('undo');
-      if (opt === true || query == 'on' || query == 'commands') return true;
-      if (gui.appUndoIsEnabled) return gui.appUndoIsEnabled();
-      try {
-        return window.localStorage && window.localStorage.getItem('mapshaper.undo') == 'on';
-      } catch(e) {
-        return false;
-      }
-    }
-
-    function getQueryValue(key) {
-      var rxp, match;
-      if (typeof window == 'undefined' || !window.location) return null;
-      rxp = new RegExp('[?&]' + key + '=([^&]+)');
-      match = rxp.exec(window.location.search);
-      return match ? decodeURIComponent(match[1]) : null;
-    }
-
     function updateSliderDisplay() {
       // TODO: display resolution and vertex count
       // var dataset = model.getActiveLayer().dataset;
@@ -7973,599 +7926,6 @@
     return internal.formatOptionValue(internal.getLayerTargetId(gui.model, lyr));
   }
 
-  // Diagnostic-only scaffolding for app-wide undo/redo R&D.
-  // It is intentionally dormant unless explicitly enabled.
-
-  var DEFAULT_POLICY = {
-    maxStates: 20,
-    maxBytes: 256 * 1024 * 1024,
-    largeChangeBytes: 64 * 1024 * 1024,
-    captureMode: 'diagnostic',
-    sessionHistory: 'audit-log'
-  };
-
-  var EDITOR_UNDO_INVENTORY = [
-    {
-      name: 'attributes',
-      events: ['data_preupdate', 'data_postupdate'],
-      capture: 'record copies',
-      reusable: true
-    },
-    {
-      name: 'labels',
-      events: ['label_dragstart', 'label_dragend'],
-      capture: 'record copies',
-      reusable: true
-    },
-    {
-      name: 'points and symbols',
-      events: ['symbol_dragend', 'point_add', 'feature_delete'],
-      capture: 'coordinate and feature inserts/deletes',
-      reusable: true
-    },
-    {
-      name: 'vertices and rectangles',
-      events: ['vertex_dragend', 'vertex_delete', 'rectangle_dragend'],
-      capture: 'coordinate and vertex inserts/deletes',
-      reusable: true
-    },
-    {
-      name: 'path drawing',
-      events: ['path_add', 'path_extend'],
-      capture: 'editor events replayed through drawing mode',
-      reusable: false
-    }
-  ];
-
-  function createUndoFeasibilityMonitor(gui, opts) {
-    opts = Object.assign({}, DEFAULT_POLICY, opts || {});
-    var tracker = createRuntimeIdTracker();
-    var enabled = isUndoFeasibilityEnabled(gui);
-    var lastReport = null;
-
-    return {
-      beforeCommand,
-      afterCommand,
-      isEnabled: function() { return enabled; },
-      setEnabled: function(val) { enabled = !!val; },
-      getPolicy: function() { return Object.assign({}, opts); },
-      getLastReport: function() { return lastReport; },
-      getEditorUndoInventory: function() { return EDITOR_UNDO_INVENTORY.slice(); }
-    };
-
-    function beforeCommand(commands, commandString) {
-      var start, before;
-      if (!enabled || !gui.model || gui.model.isEmpty()) return null;
-      start = Date.now();
-      before = captureModelState(gui.model, tracker);
-      return {
-        commandString: commandString || '',
-        commandNames: commands.map(function(cmd) { return cmd.name; }),
-        before: before,
-        beforeCaptureMillis: Date.now() - start,
-        startedAt: start
-      };
-    }
-
-    function afterCommand(token, o) {
-      var start, after, report;
-      if (!token) return null;
-      start = Date.now();
-      after = captureModelState(gui.model, tracker);
-      report = diffModelStates(token.before, after, {
-        commandString: token.commandString,
-        commandNames: token.commandNames,
-        error: o && o.error,
-        flags: o && o.flags,
-        policy: opts,
-        timings: {
-          beforeCaptureMillis: token.beforeCaptureMillis,
-          afterCaptureMillis: Date.now() - start,
-          elapsedMillis: Date.now() - token.startedAt
-        }
-      });
-      lastReport = report;
-      gui.dispatchEvent('undo_feasibility_change', report);
-      logUndoFeasibilityReport(report);
-      return report;
-    }
-  }
-
-  function captureModelState(model, tracker) {
-    tracker = tracker || createRuntimeIdTracker();
-    var datasets = model.getDatasets();
-    var active = model.getActiveLayer && model.getActiveLayer();
-    var targets = model.getDefaultTargets ? model.getDefaultTargets() : [];
-    var state = {
-      datasets: [],
-      datasetsById: {},
-      layersById: {},
-      activeLayerId: active && active.layer ? tracker.layerId(active.layer) : null,
-      activeDatasetId: active && active.dataset ? tracker.datasetId(active.dataset) : null,
-      targetHash: hashStableValue(targets.map(function(target) {
-        return {
-          dataset: tracker.datasetId(target.dataset),
-          layers: target.layers.map(function(lyr) {
-            return tracker.layerId(lyr);
-          })
-        };
-      })),
-      editorUndo: EDITOR_UNDO_INVENTORY.slice(),
-      policy: Object.assign({}, DEFAULT_POLICY)
-    };
-
-    datasets.forEach(function(dataset, i) {
-      var datasetState = captureDatasetState(dataset, i, tracker);
-      state.datasets.push(datasetState);
-      state.datasetsById[datasetState.id] = datasetState;
-      datasetState.layers.forEach(function(layerState) {
-        state.layersById[layerState.id] = layerState;
-      });
-    });
-    state.catalogHash = hashStableValue({
-      datasets: state.datasets.map(function(dataset) {
-        return {
-          id: dataset.id,
-          index: dataset.index,
-          layers: dataset.layerIds
-        };
-      }),
-      activeLayerId: state.activeLayerId,
-      activeDatasetId: state.activeDatasetId,
-      targetHash: state.targetHash
-    });
-    state.bytes = estimateStateBytes(state);
-    return state;
-  }
-
-  function diffModelStates(before, after, opts) {
-    opts = opts || {};
-    var changes = {
-      catalog: before.catalogHash != after.catalogHash,
-      selection: before.activeLayerId != after.activeLayerId ||
-        before.activeDatasetId != after.activeDatasetId ||
-        before.targetHash != after.targetHash,
-      datasets: [],
-      layers: []
-    };
-    var ids = mergeKeys(before.datasetsById, after.datasetsById);
-    var layerIds = mergeKeys(before.layersById, after.layersById);
-
-    ids.forEach(function(id) {
-      var a = before.datasetsById[id];
-      var b = after.datasetsById[id];
-      var change = diffDatasetState(a, b);
-      if (change) changes.datasets.push(change);
-    });
-
-    layerIds.forEach(function(id) {
-      var a = before.layersById[id];
-      var b = after.layersById[id];
-      var change = diffLayerState(a, b);
-      if (change) changes.layers.push(change);
-    });
-
-    return {
-      type: 'undo-feasibility',
-      command: opts.commandString || '',
-      commandNames: opts.commandNames || [],
-      failed: !!(opts.error),
-      error: opts.error ? String(opts.error.message || opts.error) : null,
-      changes: changes,
-      storage: estimateUndoStorage(before, after, changes, opts.policy || DEFAULT_POLICY),
-      timings: opts.timings || null,
-      restore: getRestoreContract(changes),
-      policy: getUndoPolicy(opts.policy || DEFAULT_POLICY)
-    };
-  }
-
-  function getUndoPolicy(policy) {
-    policy = Object.assign({}, DEFAULT_POLICY, policy || {});
-    return {
-      optIn: true,
-      enableWith: ['gui option undoFeasibility', 'URL parameter undo=diagnostic', 'localStorage mapshaper.undo=diagnostic'],
-      stackLimits: {
-        maxStates: policy.maxStates,
-        maxBytes: policy.maxBytes,
-        largeChangeBytes: policy.largeChangeBytes
-      },
-      coexistence: 'Existing editor undo remains event-based; app-wide command undo should use the same UI state events after it graduates from diagnostics.',
-      sessionHistory: 'Session history remains an audit log and is not rewound by undo/redo.'
-    };
-  }
-
-  function getRestoreContract(changes) {
-    var flags = {
-      select: changes.selection || changes.catalog,
-      arc_count: false
-    };
-    var levels = [];
-
-    changes.datasets.forEach(function(change) {
-      if (change.status != 'changed') {
-        levels.push('catalog');
-      } else {
-        if (change.arcs) {
-          levels.push('dataset');
-          flags.arc_count = true;
-        }
-        if (change.info) levels.push('dataset-info');
-        if (change.layerOrder) levels.push('layer-order');
-      }
-    });
-    changes.layers.forEach(function(change) {
-      if (change.status != 'changed') {
-        levels.push('catalog');
-      } else {
-        if (change.shapes) levels.push('layer-shapes');
-        if (change.data) levels.push('layer-data');
-        if (change.meta) levels.push('layer-meta');
-      }
-    });
-
-    return {
-      levels: unique(levels),
-      updateFlags: flags,
-      redoInvalidation: 'Discard redo entries when a new command report contains data, catalog, or selection changes.',
-      failureHandling: 'Capture starts before command execution, so partial success after an error can still be rolled back.'
-    };
-  }
-
-  function createRuntimeIdTracker() {
-    var datasetIds = new WeakMap();
-    var layerIds = new WeakMap();
-    var datasetId = 0;
-    var layerId = 0;
-    return {
-      datasetId: function(dataset) {
-        if (!datasetIds.has(dataset)) datasetIds.set(dataset, 'd' + (++datasetId));
-        return datasetIds.get(dataset);
-      },
-      layerId: function(layer) {
-        if (!layerIds.has(layer)) layerIds.set(layer, 'l' + (++layerId));
-        return layerIds.get(layer);
-      }
-    };
-  }
-
-  function captureDatasetState(dataset, i, tracker) {
-    var layers = dataset.layers.map(function(lyr, j) {
-      return captureLayerState(lyr, j, tracker, dataset);
-    });
-    var arcs = captureArcsState(dataset.arcs);
-    var info = captureValueState(dataset.info || null);
-    var state = {
-      id: tracker.datasetId(dataset),
-      index: i,
-      layerIds: layers.map(function(lyr) { return lyr.id; }),
-      layerOrderHash: hashStableValue(layers.map(function(lyr) { return lyr.id; })),
-      arcs: arcs,
-      info: info,
-      layers: layers
-    };
-    state.bytes = arcs.bytes + info.bytes + layers.reduce(function(memo, lyr) {
-      return memo + lyr.bytes;
-    }, 0);
-    return state;
-  }
-
-  function captureLayerState(lyr, i, tracker, dataset) {
-    var data = captureDataState(lyr.data);
-    var shapes = captureValueState(lyr.shapes || null);
-    var meta = captureValueState(getLayerMeta(lyr));
-    return {
-      id: tracker.layerId(lyr),
-      datasetId: tracker.datasetId(dataset),
-      index: i,
-      name: lyr.name || '',
-      geometry_type: lyr.geometry_type || null,
-      data: data,
-      shapes: shapes,
-      meta: meta,
-      bytes: data.bytes + shapes.bytes + meta.bytes
-    };
-  }
-
-  function captureDataState(data) {
-    var records = data ? data.getRecords() : null;
-    var state = captureValueState(records);
-    state.recordCount = data ? data.size() : 0;
-    state.fields = data ? data.getFields() : [];
-    return state;
-  }
-
-  function captureArcsState(arcs) {
-    var data, bytes;
-    if (!arcs) {
-      return {
-        exists: false,
-        arcCount: 0,
-        pointCount: 0,
-        retainedInterval: 0,
-        hash: 'null',
-        bytes: 0
-      };
-    }
-    data = arcs.getVertexData();
-    bytes = typedBytes(data.nn) + typedBytes(data.xx) + typedBytes(data.yy) + typedBytes(data.zz);
-    return {
-      exists: true,
-      arcCount: arcs.size(),
-      pointCount: arcs.getPointCount(),
-      retainedInterval: arcs.getRetainedInterval(),
-      hash: hashStableValue({
-        nn: hashTypedArray(data.nn),
-        xx: hashTypedArray(data.xx),
-        yy: hashTypedArray(data.yy),
-        zz: data.zz ? hashTypedArray(data.zz) : null,
-        zlimit: arcs.getRetainedInterval()
-      }),
-      bytes: bytes
-    };
-  }
-
-  function captureValueState(obj) {
-    var str = stableStringify$1(obj);
-    return {
-      hash: hashString$1(str),
-      bytes: estimateStringBytes(str)
-    };
-  }
-
-  function diffDatasetState(a, b) {
-    if (!a) return {id: b.id, status: 'added', bytes: b.bytes};
-    if (!b) return {id: a.id, status: 'removed', bytes: a.bytes};
-    var change = {
-      id: a.id,
-      status: 'changed',
-      index: a.index != b.index,
-      layerOrder: a.layerOrderHash != b.layerOrderHash,
-      arcs: a.arcs.hash != b.arcs.hash,
-      info: a.info.hash != b.info.hash,
-      beforeBytes: a.bytes,
-      afterBytes: b.bytes
-    };
-    return change.index || change.layerOrder || change.arcs || change.info ? change : null;
-  }
-
-  function diffLayerState(a, b) {
-    if (!a) return {id: b.id, datasetId: b.datasetId, status: 'added', bytes: b.bytes};
-    if (!b) return {id: a.id, datasetId: a.datasetId, status: 'removed', bytes: a.bytes};
-    var change = {
-      id: a.id,
-      datasetId: b.datasetId,
-      status: 'changed',
-      index: a.index != b.index,
-      data: a.data.hash != b.data.hash,
-      shapes: a.shapes.hash != b.shapes.hash,
-      meta: a.meta.hash != b.meta.hash,
-      beforeBytes: a.bytes,
-      afterBytes: b.bytes,
-      recordCount: b.data.recordCount,
-      fields: b.data.fields
-    };
-    return change.index || change.data || change.shapes || change.meta ? change : null;
-  }
-
-  function estimateUndoStorage(before, after, changes, policy) {
-    var bytes = 0;
-    var strategy = 'none';
-    var changedDatasets = {};
-    var changedLayers = {};
-    var alternatives = estimateStorageAlternatives(before, after, changes);
-
-    changes.datasets.forEach(function(change) {
-      var beforeState = before.datasetsById[change.id];
-      var afterState = after.datasetsById[change.id];
-      if (change.status != 'changed' || change.arcs || change.layerOrder) {
-        bytes += (beforeState ? beforeState.bytes : 0) + (afterState ? afterState.bytes : 0);
-        changedDatasets[change.id] = true;
-      } else if (change.info) {
-        bytes += (beforeState ? beforeState.info.bytes : 0) + (afterState ? afterState.info.bytes : 0);
-        strategy = strategy == 'none' ? 'dataset-info' : strategy;
-      }
-    });
-    changes.layers.forEach(function(change) {
-      var beforeState = before.layersById[change.id];
-      var afterState = after.layersById[change.id];
-      if (changedDatasets[change.datasetId]) return;
-      if (change.data && !change.shapes && !change.meta) {
-        bytes += (beforeState ? beforeState.data.bytes : 0) + (afterState ? afterState.data.bytes : 0);
-        strategy = strategy == 'none' ? 'table' : strategy;
-      } else {
-        bytes += (beforeState ? beforeState.bytes : 0) + (afterState ? afterState.bytes : 0);
-        changedLayers[change.id] = true;
-      }
-    });
-
-    if (Object.keys(changedDatasets).length > 0) {
-      strategy = 'dataset';
-    } else if (Object.keys(changedLayers).length > 0) {
-      strategy = strategy == 'none' ? 'layer' : 'mixed';
-    }
-
-    return {
-      strategy: strategy,
-      estimatedBytes: bytes,
-      displaySize: formatBytes$1(bytes),
-      alternatives: alternatives,
-      exceedsLargeChangeLimit: bytes > policy.largeChangeBytes,
-      exceedsStackLimit: bytes > policy.maxBytes
-    };
-  }
-
-  function estimateStorageAlternatives(before, after, changes) {
-    var alternatives = {
-      fullSession: before.bytes + after.bytes,
-      changedDatasets: 0,
-      changedLayers: 0,
-      changedTables: 0,
-      changedArcs: 0
-    };
-    var datasetIds = {};
-
-    changes.datasets.forEach(function(change) {
-      var beforeState = before.datasetsById[change.id];
-      var afterState = after.datasetsById[change.id];
-      var datasetBytes = (beforeState ? beforeState.bytes : 0) + (afterState ? afterState.bytes : 0);
-      alternatives.changedDatasets += datasetBytes;
-      datasetIds[change.id] = true;
-      if (change.arcs) {
-        alternatives.changedArcs += (beforeState ? beforeState.arcs.bytes : 0) +
-          (afterState ? afterState.arcs.bytes : 0);
-      }
-    });
-    changes.layers.forEach(function(change) {
-      var beforeState = before.layersById[change.id];
-      var afterState = after.layersById[change.id];
-      if (datasetIds[change.datasetId]) return;
-      alternatives.changedLayers += (beforeState ? beforeState.bytes : 0) +
-        (afterState ? afterState.bytes : 0);
-      if (change.data) {
-        alternatives.changedTables += (beforeState ? beforeState.data.bytes : 0) +
-          (afterState ? afterState.data.bytes : 0);
-      }
-    });
-    Object.keys(alternatives).forEach(function(key) {
-      alternatives[key] = {
-        estimatedBytes: alternatives[key],
-        displaySize: formatBytes$1(alternatives[key])
-      };
-    });
-    return alternatives;
-  }
-
-  function estimateStateBytes(state) {
-    return state.datasets.reduce(function(memo, dataset) {
-      return memo + dataset.bytes;
-    }, 0);
-  }
-
-  function getLayerMeta(lyr) {
-    var meta = {};
-    Object.keys(lyr).sort().forEach(function(key) {
-      if (key == 'data' || key == 'shapes') return;
-      meta[key] = lyr[key];
-    });
-    return meta;
-  }
-
-  function isUndoFeasibilityEnabled(gui) {
-    var opt = gui.options && gui.options.undoFeasibility;
-    var query = getQueryValue$2('undo');
-    if (opt === true || opt == 'diagnostic') return true;
-    if (query == 'diagnostic' || query == 'debug') return true;
-    try {
-      return window.localStorage && window.localStorage.getItem('mapshaper.undo') == 'diagnostic';
-    } catch(e) {
-      return false;
-    }
-  }
-
-  function getQueryValue$2(key) {
-    var rxp, match;
-    if (typeof window == 'undefined' || !window.location) return null;
-    rxp = new RegExp('[?&]' + key + '=([^&]+)');
-    match = rxp.exec(window.location.search);
-    return match ? decodeURIComponent(match[1]) : null;
-  }
-
-  function logUndoFeasibilityReport(report) {
-    if (typeof console == 'undefined' || !console.log) return;
-    console.log('[mapshaper undo feasibility]', {
-      command: report.command,
-      failed: report.failed,
-      changes: report.changes,
-      storage: report.storage,
-      restore: report.restore
-    });
-  }
-
-  function mergeKeys(a, b) {
-    var index = {};
-    Object.keys(a).forEach(function(key) { index[key] = true; });
-    Object.keys(b).forEach(function(key) { index[key] = true; });
-    return Object.keys(index);
-  }
-
-  function unique(arr) {
-    var index = {};
-    arr.forEach(function(item) { index[item] = true; });
-    return Object.keys(index);
-  }
-
-  function hashStableValue(obj) {
-    return hashString$1(stableStringify$1(obj));
-  }
-
-  function stableStringify$1(obj) {
-    var seen = [];
-    return stringify(obj, 0);
-
-    function stringify(val, depth) {
-      var keys;
-      if (val === null) return 'null';
-      if (val === undefined) return 'undefined';
-      if (typeof val == 'number') return Number.isNaN(val) ? 'NaN' : String(val);
-      if (typeof val == 'string') return JSON.stringify(val);
-      if (typeof val == 'boolean') return String(val);
-      if (typeof val == 'function') return '[Function]';
-      if (ArrayBuffer.isView(val)) return hashTypedArray(val);
-      if (seen.indexOf(val) > -1) return '[Circular]';
-      if (depth > 8) return '[MaxDepth]';
-      seen.push(val);
-      if (Array.isArray(val)) {
-        return '[' + val.map(function(item) {
-          return stringify(item, depth + 1);
-        }).join(',') + ']';
-      }
-      keys = Object.keys(val).sort();
-      return '{' + keys.map(function(key) {
-        return JSON.stringify(key) + ':' + stringify(val[key], depth + 1);
-      }).join(',') + '}';
-    }
-  }
-
-  function hashTypedArray(arr) {
-    var hash, view;
-    if (!arr) return 'null';
-    view = new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
-    hash = hashBytes(view);
-    return arr.constructor.name + ':' + arr.length + ':' + hash;
-  }
-
-  function hashBytes(bytes) {
-    var hash = 2166136261;
-    for (var i=0, n=bytes.length; i<n; i++) {
-      hash ^= bytes[i];
-      hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
-    }
-    return (hash >>> 0).toString(16);
-  }
-
-  function hashString$1(str) {
-    var hash = 2166136261;
-    for (var i=0, n=str.length; i<n; i++) {
-      hash ^= str.charCodeAt(i);
-      hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
-    }
-    return (hash >>> 0).toString(16);
-  }
-
-  function typedBytes(arr) {
-    return arr ? arr.byteLength : 0;
-  }
-
-  function estimateStringBytes(str) {
-    return str.length * 2;
-  }
-
-  function formatBytes$1(bytes) {
-    if (bytes > 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(1) + 'MB';
-    if (bytes > 1024) return Math.round(bytes / 1024) + 'KB';
-    return bytes + 'B';
-  }
-
   function Console(gui) {
     var model = gui.model;
     var CURSOR = '$ ';
@@ -8595,9 +7955,6 @@
       });
     var globals = {}; // share user-defined globals (job.defs) between runs
     var sharedVars = {}; // share -vars / -defaults templating scope between runs
-    var undoFeasibility = createUndoFeasibilityMonitor(gui);
-    var storedUndoHistory = createStoredUndoHistory(gui);
-    gui.undoFeasibility = undoFeasibility;
 
     // expose this function, so other components can run commands (e.g. box tool)
     this.runMapshaperCommands = runMapshaperCommands;
@@ -8999,7 +8356,6 @@
           prevTable = active?.layer.data,
           prevTableSize = prevTable ? prevTable.size() : 0,
           prevArcCount = prevArcs ? prevArcs.size() : 0,
-          undoCapture = undoFeasibility.beforeCommand(commands, commandString),
           undoTransaction = createCommandUndoTransaction(commandString),
           job = new internal.Job(model),
           commandStart = Date.now();
@@ -9048,7 +8404,6 @@
         // signal the map to update even if an error has occured, because the
         // commands may have partially succeeded and changes may have occured to
         // the data.
-        undoFeasibility.afterCommand(undoCapture, {error: err, flags: flags});
         if (!err) {
           commandString = internal.standardizeConsoleCommands(commandString);
           historyIds.push(gui.session.consoleCommands(commandString));
@@ -9074,7 +8429,7 @@
     function createCommandUndoTransaction(commandString) {
       var Transaction;
       if (!isCommandUndoEnabled()) return null;
-      storedUndoHistory.getPayloadStore();
+      getStoredUndoHistory(gui).getPayloadStore();
       Transaction = internal.UndoTransaction.UndoTransaction || internal.UndoTransaction;
       return new Transaction(commandString);
     }
@@ -9098,7 +8453,7 @@
     }
 
     async function addCommandUndoHistory(tx, err, flags, historyIds) {
-      return storedUndoHistory.addTransaction(tx, {
+      return getStoredUndoHistory(gui).addTransaction(tx, {
         error: err,
         flags: flags,
         entryPrefix: 'command',
@@ -9113,15 +8468,8 @@
     }
 
     function isCommandUndoEnabled() {
-      var opt = gui.options && (gui.options.undoCommands || gui.options.appUndo);
-      var query = getQueryValue('undo');
       if (!gui.undo || typeof gui.undo.addHistoryState != 'function') return false;
-      if (opt === true || query == 'on' || query == 'commands') return true;
-      try {
-        return window.localStorage && window.localStorage.getItem('mapshaper.undo') == 'on';
-      } catch(e) {
-        return false;
-      }
+      return appUndoIsEnabled(gui);
     }
 
     function getCommandUndoHistoryLimit() {
@@ -9130,8 +8478,8 @@
     }
 
     function logCommandTiming(commandString, commands, err, totalMillis, undoTiming) {
-      var enabled = getQueryValue('command-timing') == 'on' ||
-        getQueryValue('undo-timing') == 'on';
+      var enabled = getQueryFlag('command-timing') == 'on' ||
+        getQueryFlag('undo-timing') == 'on';
       var undoMillis = undoTiming && undoTiming.undoMillis || 0;
       if (!enabled || typeof console == 'undefined' || !console.log) return;
       console.log('[mapshaper command timing]', {
@@ -9147,7 +8495,7 @@
       });
     }
 
-    function getQueryValue(key) {
+    function getQueryFlag(key) {
       var rxp, match;
       if (typeof window == 'undefined' || !window.location) return null;
       rxp = new RegExp('[?&]' + key + '=([^&]+)');
@@ -10264,8 +9612,9 @@
 
       function deleteLayer() {
         var target = findLayerById(id);
-        var undoTransaction = createDeleteLayerUndoTransaction(target);
+        var undoTransaction;
         if (!target) return;
+        undoTransaction = createUndoTransaction(gui, 'delete layer');
         if (map.isVisibleLayer(target.layer)) {
           // TODO: check for double map refresh after model.deleteLayer() below
           setLayerPinning(target.layer, false);
@@ -10274,7 +9623,10 @@
           undoTransaction.run(function() {
             model.deleteLayer(target.layer, target.dataset);
           });
-          addDeleteLayerUndoHistory(undoTransaction);
+          addUndoTransactionToHistory(gui, undoTransaction, {
+            flags: {select: true, arc_count: true},
+            entryPrefix: 'delete-layer'
+          });
         } else {
           model.deleteLayer(target.layer, target.dataset);
         }
@@ -10375,41 +9727,18 @@
       return str;
     }
 
-    function createDeleteLayerUndoTransaction(target) {
-      return createLayerMenuUndoTransaction(target, 'delete layer');
-    }
-
-    function createLayerRenameUndoTransaction(target) {
-      return createLayerMenuUndoTransaction(target, 'rename layer');
-    }
-
-    function createLayerMenuUndoTransaction(target, label) {
-      var Transaction;
-      if (!target || !appUndoIsEnabled()) return null;
-      if (!gui.undo || typeof gui.undo.addHistoryState != 'function') return null;
-      Transaction = internal.UndoTransaction && (internal.UndoTransaction.UndoTransaction || internal.UndoTransaction);
-      return Transaction ? new Transaction(label) : null;
-    }
-
-    function addDeleteLayerUndoHistory(tx) {
-      getStoredUndoHistory().addTransaction(tx, {
-        flags: {select: true, arc_count: true},
-        entryPrefix: 'delete-layer',
-        maxStates: getUndoHistoryLimit()
-      }).catch(function(e) {
-        console.error(e);
-      });
-    }
-
     function renameLayer(target, name) {
       var undoTransaction;
       if (!target || target.layer.name == name) return;
-      undoTransaction = createLayerRenameUndoTransaction(target);
+      undoTransaction = createUndoTransaction(gui, 'rename layer');
       if (undoTransaction) {
         undoTransaction.captureLayerMetadataBefore(target.layer, {operation: 'renameLayer', unit: 'name'});
         target.layer.name = name;
         markLayerChanged(target.layer, {operation: 'renameLayer', unit: 'name'});
-        addLayerRenameUndoHistory(undoTransaction);
+        addUndoTransactionToHistory(gui, undoTransaction, {
+          flags: {select: true},
+          entryPrefix: 'rename-layer'
+        });
       } else {
         target.layer.name = name;
       }
@@ -10417,54 +9746,12 @@
       updateMenuBtn();
     }
 
-    function addLayerRenameUndoHistory(tx) {
-      getStoredUndoHistory().addTransaction(tx, {
-        flags: {select: true},
-        entryPrefix: 'rename-layer',
-        maxStates: getUndoHistoryLimit()
-      }).catch(function(e) {
-        console.error(e);
-      });
-    }
-
     function markLayerChanged(layer, detail) {
       if (internal.UndoTracking && internal.UndoTracking.markLayerChanged) {
         internal.UndoTracking.markLayerChanged(layer, detail);
       }
     }
 
-    function getStoredUndoHistory() {
-      if (!gui.storedUndoHistory) {
-        gui.storedUndoHistory = createStoredUndoHistory(gui);
-      }
-      return gui.storedUndoHistory;
-    }
-
-    function getUndoHistoryLimit() {
-      var opt = gui.options && gui.options.undoHistoryLimit;
-      return opt > 0 ? opt : 10;
-    }
-
-    function appUndoIsEnabled() {
-      var opt = gui.options && (gui.options.undoCommands || gui.options.appUndo);
-      var query = getQueryValue('undo');
-      if (opt === true || query == 'on' || query == 'commands') return true;
-      if (gui.appUndoIsEnabled) return gui.appUndoIsEnabled();
-      try {
-        return window.localStorage && window.localStorage.getItem('mapshaper.undo') == 'on';
-      } catch(e) {
-        return false;
-      }
-    }
-
-    function getQueryValue(key) {
-      var rxp, match;
-      if (typeof window == 'undefined' || !window.location) return null;
-      rxp = new RegExp('[?&]' + key + '=([^&]+)');
-      match = rxp.exec(window.location.search);
-      return match ? decodeURIComponent(match[1]) : null;
-    }
-
     function getWarnings(lyr, dataset) {
       var file = internal.getLayerSourceFile(lyr, dataset);
       var missing = [];
@@ -10674,19 +9961,6 @@
     el.attr('aria-disabled', enabled ? 'false' : 'true');
   }
 
-  function appUndoForcedByUrl() {
-    var query = getQueryValue$1('undo');
-    return query == 'on' || query == 'commands';
-  }
-
-  function appUndoSettingIsOn() {
-    try {
-      return window.localStorage && window.localStorage.getItem(APP_UNDO_KEY) == 'on';
-    } catch(e) {
-      return false;
-    }
-  }
-
   function setAppUndoEnabled(enabled) {
     try {
       if (window.localStorage) {
@@ -10698,9 +9972,6 @@
   function getRestoreDataNote(gui) {
     var stats = getUndoPayloadStats(gui);
     var bytes = stats ? stats.ownBytes || 0 : 0;
-    if (bytes === 0) {
-      return 'estimated on-disk restore data: none';
-    }
     return 'estimated on-disk restore data: ' + formatBytes(bytes);
   }
 
@@ -10710,22 +9981,14 @@
   }
 
   function formatBytes(bytes) {
-    var units = ['B', 'KB', 'MB', 'GB'];
-    var value = bytes;
+    var units = ['KB', 'MB', 'GB'];
+    var value = bytes / 1000;
     var i = 0;
     while (value >= 1000 && i < units.length - 1) {
       value /= 1000;
       i++;
     }
-    return (i === 0 ? String(value) : value.toFixed(value < 10 ? 1 : 0)) + ' ' + units[i];
-  }
-
-  function getQueryValue$1(key) {
-    var rxp, match;
-    if (typeof window == 'undefined' || !window.location) return null;
-    rxp = new RegExp('[?&]' + key + '=([^&]+)');
-    match = rxp.exec(window.location.search);
-    return match ? decodeURIComponent(match[1]) : null;
+    return value.toFixed(value < 10 && value >= 0.5 ? 1 : 0) + ' ' + units[i];
   }
 
   function SessionHistory(gui) {
@@ -10955,8 +10218,7 @@
   }
 
   function Undo(gui) {
-    var history, offset, stashedUndo, storedUndoHistory, editSession;
-    storedUndoHistory = createStoredUndoHistory(gui);
+    var history, offset, stashedUndo, editSession;
     editSession = createEditSessionUndo();
     reset();
 
@@ -11318,7 +10580,7 @@
       function start(nextMode) {
         var target, Transaction;
         if (!isEditSessionMode(nextMode)) return;
-        if (!appUndoIsEnabled()) return;
+        if (!appUndoIsEnabled(gui)) return;
         target = gui.model.getActiveLayer();
         if (!target || !target.layer) return;
         Transaction = getUndoTransactionConstructor();
@@ -11337,7 +10599,7 @@
         }
         resetSession();
         if (!wasChanged) return;
-        storedUndoHistory.addTransaction(finishedTx, {
+        getStoredUndoHistory(gui).addTransaction(finishedTx, {
           flags: {select: true},
           entryPrefix: 'edit-session',
           maxStates: getEditSessionUndoHistoryLimit()
@@ -11392,26 +10654,6 @@
       return opt > 0 ? opt : 10;
     }
 
-    function appUndoIsEnabled() {
-      var opt = gui.options && (gui.options.undoCommands || gui.options.appUndo);
-      var query = getQueryValue('undo');
-      if (opt === true || query == 'on' || query == 'commands') return true;
-      if (gui.appUndoIsEnabled) return gui.appUndoIsEnabled();
-      try {
-        return window.localStorage && window.localStorage.getItem('mapshaper.undo') == 'on';
-      } catch(e) {
-        return false;
-      }
-    }
-
-    function getQueryValue(key) {
-      var rxp, match;
-      if (typeof window == 'undefined' || !window.location) return null;
-      rxp = new RegExp('[?&]' + key + '=([^&]+)');
-      match = rxp.exec(window.location.search);
-      return match ? decodeURIComponent(match[1]) : null;
-    }
-
   }
 
   function SidebarButtons(gui) {