chromium-tabs 0.1.0 → 0.2.0

package/dist/session/index.js

@@ -0,0 +1,1320 @@
+import {
+  AddTabFlags,
+  NO_TAB,
+  TAB_GROUP_COLORS
+} from "../chunk-NDM7JYY6.js";
+
+// src/session/command-storage-manager.ts
+var SAVE_DELAY_MS = 2500;
+var CommandStorageManager = class {
+  backend_;
+  delegate_;
+  saveDelayMs_;
+  pendingCommands_ = [];
+  /** Starts true: the first save is always a complete rewrite (cc:117). */
+  pendingReset_ = true;
+  commandsSinceReset_ = 0;
+  saveTimer_ = null;
+  /** Sequenced "task runner" for backend writes. */
+  queue_ = Promise.resolve();
+  /** Backend operations started but not yet settled. */
+  inflight_ = 0;
+  constructor(options) {
+    this.backend_ = options.backend;
+    this.delegate_ = options.delegate ?? {};
+    this.saveDelayMs_ = options.saveDelayMs ?? SAVE_DELAY_MS;
+    if (options.ready) {
+      this.inflight_++;
+      this.queue_ = options.ready.then(
+        () => {
+          this.inflight_--;
+        },
+        () => {
+          this.inflight_--;
+        }
+      );
+    }
+  }
+  /**
+   * Runs a backend operation. When nothing is in flight it runs inline — a
+   * synchronous backend then completes before this returns, which is what
+   * makes a pagehide flush reliable (the web stand-in for Chrome's
+   * BLOCK_SHUTDOWN task traits). Otherwise it is sequenced behind the queue.
+   */
+  enqueue_(operation) {
+    const wasIdle = this.inflight_ === 0;
+    this.inflight_++;
+    if (wasIdle) {
+      let result;
+      try {
+        result = operation();
+      } catch {
+        this.inflight_--;
+        this.delegate_.onErrorWritingSessionCommands?.();
+        return this.queue_;
+      }
+      if (result && typeof result.then === "function") {
+        this.queue_ = result.then(
+          () => {
+            this.inflight_--;
+          },
+          () => {
+            this.inflight_--;
+            this.delegate_.onErrorWritingSessionCommands?.();
+          }
+        );
+      } else {
+        this.inflight_--;
+      }
+      return this.queue_;
+    }
+    this.queue_ = this.queue_.then(() => operation()).then(
+      () => {
+        this.inflight_--;
+      },
+      () => {
+        this.inflight_--;
+        this.delegate_.onErrorWritingSessionCommands?.();
+      }
+    );
+    return this.queue_;
+  }
+  get pendingReset() {
+    return this.pendingReset_;
+  }
+  /** Mirrors set_pending_reset (command_storage_manager.h:77). */
+  setPendingReset(value) {
+    this.pendingReset_ = value;
+  }
+  get commandsSinceReset() {
+    return this.commandsSinceReset_;
+  }
+  /** Buffers a command and starts the save timer. Mirrors cc:192. */
+  scheduleCommand(command) {
+    this.commandsSinceReset_++;
+    this.pendingCommands_.push(command);
+    this.startSaveTimer();
+  }
+  /** Buffers rebuild commands without starting the timer. Mirrors cc:207. */
+  appendRebuildCommands(commands) {
+    this.commandsSinceReset_ += commands.length;
+    this.pendingCommands_.push(...commands);
+  }
+  appendRebuildCommand(command) {
+    this.appendRebuildCommands([command]);
+  }
+  /** Removes a not-yet-saved command. Mirrors EraseCommand (cc:216). */
+  eraseCommand(command) {
+    const i = this.pendingCommands_.indexOf(command);
+    if (i === -1) throw new Error("eraseCommand: command is not pending");
+    this.pendingCommands_.splice(i, 1);
+    this.commandsSinceReset_--;
+  }
+  /** Replaces a not-yet-saved command in place. Mirrors SwapCommand (cc:225). */
+  swapCommand(oldCommand, newCommand) {
+    const i = this.pendingCommands_.indexOf(oldCommand);
+    if (i === -1) throw new Error("swapCommand: command is not pending");
+    this.pendingCommands_[i] = newCommand;
+  }
+  /** Mirrors ClearPendingCommands (cc:233) — note it does not zero the reset counter. */
+  clearPendingCommands() {
+    this.commandsSinceReset_ -= this.pendingCommands_.length;
+    this.pendingCommands_ = [];
+  }
+  /** Read-only view for ReplacePendingCommand-style optimizations. */
+  get pendingCommands() {
+    return this.pendingCommands_;
+  }
+  /** True between startSaveTimer() and the save it scheduled. Mirrors cc:316. */
+  get hasPendingSave() {
+    return this.saveTimer_ !== null;
+  }
+  /** Schedules a save in saveDelayMs unless one is already pending. Mirrors cc:239. */
+  startSaveTimer() {
+    if (this.saveTimer_ !== null) return;
+    this.saveTimer_ = setTimeout(() => {
+      this.saveTimer_ = null;
+      this.save();
+    }, this.saveDelayMs_);
+  }
+  /**
+   * Flushes pending commands to the backend. Mirrors Save (cc:251): the
+   * buffer and reset flag are snapshotted synchronously; the write itself is
+   * sequenced behind earlier writes. Returns once this write has settled.
+   */
+  save() {
+    if (this.saveTimer_ !== null) {
+      clearTimeout(this.saveTimer_);
+      this.saveTimer_ = null;
+    }
+    this.delegate_.onWillSaveCommands?.();
+    if (this.pendingCommands_.length === 0) return this.queue_;
+    const commands = this.pendingCommands_;
+    const truncate = this.pendingReset_;
+    this.pendingCommands_ = [];
+    if (this.pendingReset_) {
+      this.commandsSinceReset_ = 0;
+      this.pendingReset_ = false;
+    }
+    return this.enqueue_(() => this.backend_.appendCommands(commands, truncate));
+  }
+  /** Cancels any timer and flushes immediately. */
+  saveNow() {
+    return this.save();
+  }
+  /**
+   * Promotes the current session to "last". Pending commands are flushed
+   * first, mirroring MoveCurrentSessionToLastSession (cc:320). The caller is
+   * expected to follow up with setPendingReset(true) plus a full re-emit of
+   * live state, since the current session is now empty.
+   */
+  moveCurrentSessionToLastSession() {
+    this.save();
+    return this.enqueue_(() => this.backend_.moveCurrentSessionToLastSession());
+  }
+  /** Stops the save timer without flushing. */
+  dispose() {
+    if (this.saveTimer_ !== null) {
+      clearTimeout(this.saveTimer_);
+      this.saveTimer_ = null;
+    }
+  }
+};
+
+// src/session/backends/in-memory.ts
+var InMemoryStorageBackend = class {
+  current_ = null;
+  last_ = null;
+  appendCommands(commands, truncate) {
+    if (truncate || this.current_ === null) this.current_ = [];
+    this.current_.push(...commands.map((c) => ({ ...c })));
+  }
+  readLastSessionCommands() {
+    return { commands: (this.last_ ?? []).map((c) => ({ ...c })), errorReading: false };
+  }
+  moveCurrentSessionToLastSession() {
+    if (this.current_ !== null) {
+      this.last_ = this.current_;
+      this.current_ = null;
+    }
+  }
+  /** Test hook: the commands persisted for the current session, if any. */
+  get currentSessionCommands() {
+    return this.current_;
+  }
+  /** Test hook: the commands persisted for the last session, if any. */
+  get lastSessionCommands() {
+    return this.last_;
+  }
+};
+
+// src/session/process-singleton.ts
+var CLAIM_ATTEMPT_DELAYS_MS = [0, 0, 50];
+var WebLocksProcessSingleton = class {
+  name_;
+  locks_;
+  acquirePromise_ = null;
+  releaseHold_ = null;
+  released_ = false;
+  constructor(options) {
+    this.name_ = options.name;
+    this.locks_ = options.locks ?? (typeof navigator !== "undefined" ? navigator.locks : void 0);
+  }
+  acquire() {
+    if (!this.acquirePromise_) this.acquirePromise_ = this.acquireWithRetries_();
+    return this.acquirePromise_;
+  }
+  /**
+   * Claim with bounded retries. Chrome's POSIX singleton retries its claim
+   * the same way — kRetryAttempts with timeout/retry_attempts sleeps
+   * (process_singleton_posix.cc:137-140, :794) — because a dying holder's
+   * lock disappears asynchronously. Web Lock releases also propagate
+   * asynchronously (the holder resolves its callback promise), so a realm
+   * booting right after another one released (HMR, dispose-then-reconstruct)
+   * needs a beat before the lock reads as free. A lock still held after the
+   * final attempt belongs to a live realm: stand down.
+   */
+  async acquireWithRetries_() {
+    const locks = this.locks_;
+    if (!locks) {
+      return this.released_ ? "secondary" : "owner";
+    }
+    for (const delayMs of CLAIM_ATTEMPT_DELAYS_MS) {
+      if (delayMs > 0) await new Promise((resolve) => setTimeout(resolve, delayMs));
+      if (this.released_) return "secondary";
+      const result = await this.tryClaim_(locks);
+      if (result === "owner") return "owner";
+    }
+    return "secondary";
+  }
+  tryClaim_(locks) {
+    return new Promise((resolve) => {
+      locks.request(this.name_, { ifAvailable: true }, (lock) => {
+        if (lock === null) {
+          resolve("secondary");
+          return void 0;
+        }
+        if (this.released_) {
+          resolve("secondary");
+          return void 0;
+        }
+        return new Promise((releaseHold) => {
+          this.releaseHold_ = releaseHold;
+          resolve("owner");
+        });
+      }).catch(() => {
+        resolve("owner");
+      });
+    });
+  }
+  release() {
+    this.released_ = true;
+    if (this.releaseHold_) {
+      this.releaseHold_();
+      this.releaseHold_ = null;
+    }
+  }
+};
+function createDefaultProcessSingleton(profileLockName) {
+  if (!profileLockName) return null;
+  if (typeof navigator === "undefined" || !navigator.locks) return null;
+  return new WebLocksProcessSingleton({ name: profileLockName });
+}
+
+// src/session/backends/web-storage.ts
+var ENVELOPE_VERSION = 1;
+var WebStorageBackend = class {
+  /** Two realms over the same key contend for the same profile singleton. */
+  profileLockName;
+  storage_;
+  currentKey_;
+  lastKey_;
+  /** Parsed mirror of the current slot, so appends don't re-parse. */
+  currentCache_ = null;
+  constructor(options = {}) {
+    const key = options.key ?? "chromium-tabs/session";
+    const storage = options.storage ?? (typeof localStorage !== "undefined" ? localStorage : void 0);
+    if (!storage) {
+      throw new Error("WebStorageBackend: no Storage available; pass options.storage");
+    }
+    this.storage_ = storage;
+    this.profileLockName = `chromium-tabs-profile/${key}`;
+    this.currentKey_ = `${key}/current`;
+    this.lastKey_ = `${key}/last`;
+  }
+  appendCommands(commands, truncate) {
+    const existing = truncate ? [] : this.currentCache_ ?? this.readSlot_(this.currentKey_).commands;
+    existing.push(...commands);
+    this.currentCache_ = existing;
+    this.storage_.setItem(
+      this.currentKey_,
+      JSON.stringify({ version: ENVELOPE_VERSION, commands: existing })
+    );
+  }
+  readLastSessionCommands() {
+    return this.readSlot_(this.lastKey_);
+  }
+  moveCurrentSessionToLastSession() {
+    const current = this.storage_.getItem(this.currentKey_);
+    if (current !== null) {
+      this.storage_.setItem(this.lastKey_, current);
+      this.storage_.removeItem(this.currentKey_);
+    }
+    this.currentCache_ = null;
+  }
+  readSlot_(key) {
+    const raw = this.storage_.getItem(key);
+    if (raw === null) return { commands: [], errorReading: false };
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed === null || parsed.version !== ENVELOPE_VERSION || !Array.isArray(parsed.commands)) {
+        return { commands: [], errorReading: true };
+      }
+      return { commands: parsed.commands, errorReading: false };
+    } catch {
+      return { commands: [], errorReading: true };
+    }
+  }
+};
+
+// src/session/session-service-commands.ts
+var SessionCommandId = {
+  SET_TAB_WINDOW: 0,
+  // cc:58
+  SET_TAB_INDEX_IN_WINDOW: 2,
+  // cc:61
+  UPDATE_TAB_NAVIGATION: 6,
+  // cc:68
+  SET_SELECTED_NAVIGATION_INDEX: 7,
+  // cc:69
+  SET_SELECTED_TAB_IN_INDEX: 8,
+  // cc:70
+  SET_PINNED_STATE: 12,
+  // cc:80
+  TAB_CLOSED: 16,
+  // cc:84
+  WINDOW_CLOSED: 17,
+  // cc:85
+  SET_ACTIVE_WINDOW: 20,
+  // cc:89
+  LAST_ACTIVE_TIME: 21,
+  // cc:90
+  TAB_NAVIGATION_PATH_PRUNED: 24,
+  // cc:94
+  SET_TAB_GROUP: 25,
+  // cc:95
+  SET_TAB_GROUP_METADATA2: 27,
+  // cc:98
+  SET_TAB_DATA: 30,
+  // cc:101
+  ADD_TAB_EXTRA_DATA: 33,
+  // cc:105
+  ADD_WINDOW_EXTRA_DATA: 34
+  // cc:106
+};
+function createSetTabWindowCommand(windowId, tabId) {
+  return { id: SessionCommandId.SET_TAB_WINDOW, windowId, tabId };
+}
+function createSetTabIndexInWindowCommand(tabId, index) {
+  return { id: SessionCommandId.SET_TAB_INDEX_IN_WINDOW, tabId, index };
+}
+function createUpdateTabNavigationCommand(tabId, navigation) {
+  return { id: SessionCommandId.UPDATE_TAB_NAVIGATION, tabId, navigation };
+}
+function createSetSelectedNavigationIndexCommand(tabId, index) {
+  return { id: SessionCommandId.SET_SELECTED_NAVIGATION_INDEX, tabId, index };
+}
+function createSetSelectedTabInWindowCommand(windowId, index) {
+  return { id: SessionCommandId.SET_SELECTED_TAB_IN_INDEX, windowId, index };
+}
+function createPinnedStateCommand(tabId, pinned) {
+  return { id: SessionCommandId.SET_PINNED_STATE, tabId, pinned };
+}
+function createTabClosedCommand(tabId, closeTime = Date.now()) {
+  return { id: SessionCommandId.TAB_CLOSED, tabId, closeTime };
+}
+function createWindowClosedCommand(windowId, closeTime = Date.now()) {
+  return { id: SessionCommandId.WINDOW_CLOSED, windowId, closeTime };
+}
+function createSetActiveWindowCommand(windowId) {
+  return { id: SessionCommandId.SET_ACTIVE_WINDOW, windowId };
+}
+function createLastActiveTimeCommand(tabId, lastActiveTime) {
+  return { id: SessionCommandId.LAST_ACTIVE_TIME, tabId, lastActiveTime };
+}
+function createTabNavigationPathPrunedCommand(tabId, index, count) {
+  return { id: SessionCommandId.TAB_NAVIGATION_PATH_PRUNED, tabId, index, count };
+}
+function createTabGroupCommand(tabId, groupId) {
+  return { id: SessionCommandId.SET_TAB_GROUP, tabId, groupId };
+}
+function createTabGroupMetadataUpdateCommand(groupId, visualData) {
+  return { id: SessionCommandId.SET_TAB_GROUP_METADATA2, groupId, visualData: { ...visualData } };
+}
+function createSetTabDataCommand(tabId, data) {
+  return { id: SessionCommandId.SET_TAB_DATA, tabId, data };
+}
+function createAddTabExtraDataCommand(tabId, key, value) {
+  return { id: SessionCommandId.ADD_TAB_EXTRA_DATA, tabId, key, value };
+}
+function createAddWindowExtraDataCommand(windowId, key, value) {
+  return { id: SessionCommandId.ADD_WINDOW_EXTRA_DATA, windowId, key, value };
+}
+function isClosingCommand(command) {
+  return command.id === SessionCommandId.TAB_CLOSED || command.id === SessionCommandId.WINDOW_CLOSED;
+}
+function getTab(tabs, tabId) {
+  let tab = tabs.get(tabId);
+  if (!tab) {
+    tab = {
+      tabId,
+      windowId: "",
+      hasWindow: false,
+      visualIndex: -1,
+      pinned: false,
+      groupId: null,
+      data: void 0,
+      navigations: [],
+      currentNavigationIndex: -1,
+      extraData: {}
+    };
+    tabs.set(tabId, tab);
+  }
+  return tab;
+}
+function getWindow(windows, windowId) {
+  let window2 = windows.get(windowId);
+  if (!window2) {
+    window2 = { windowId, selectedTabIndex: -1, tabs: [], tabGroups: [], extraData: {} };
+    windows.set(windowId, window2);
+  }
+  return window2;
+}
+function findClosestNavigationWithIndex(navigations, index) {
+  for (let i = 0; i < navigations.length; i++) {
+    if (navigations[i].index >= index) return i;
+  }
+  return navigations.length;
+}
+function processTabNavigationPathPruned(tab, index, count) {
+  if (tab.currentNavigationIndex >= index && tab.currentNavigationIndex < index + count) {
+    tab.currentNavigationIndex = index - 1;
+  } else if (tab.currentNavigationIndex >= index + count) {
+    tab.currentNavigationIndex -= count;
+  }
+  const from = findClosestNavigationWithIndex(tab.navigations, index);
+  const to = findClosestNavigationWithIndex(tab.navigations, index + count);
+  tab.navigations.splice(from, to - from);
+  for (const navigation of tab.navigations) {
+    if (navigation.index >= index) navigation.index -= count;
+  }
+}
+var isStr = (v) => typeof v === "string";
+var isNum = (v) => typeof v === "number" && Number.isFinite(v);
+var isBool = (v) => typeof v === "boolean";
+function isValidNavigation(nav) {
+  if (typeof nav !== "object" || nav === null) return false;
+  const n = nav;
+  return isNum(n.index) && isStr(n.url);
+}
+function isValidVisualData(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const d = v;
+  return isStr(d.title) && TAB_GROUP_COLORS.includes(d.color) && isBool(d.isCollapsed);
+}
+function processCommand(state, command) {
+  const { tabs, tabGroups, windows } = state;
+  const c = command;
+  switch (c.id) {
+    case SessionCommandId.SET_TAB_WINDOW: {
+      if (!isStr(c.tabId) || !isStr(c.windowId)) return false;
+      const tab = getTab(tabs, c.tabId);
+      tab.windowId = c.windowId;
+      tab.hasWindow = true;
+      return true;
+    }
+    case SessionCommandId.SET_TAB_INDEX_IN_WINDOW: {
+      if (!isStr(c.tabId) || !isNum(c.index)) return false;
+      getTab(tabs, c.tabId).visualIndex = c.index;
+      return true;
+    }
+    case SessionCommandId.UPDATE_TAB_NAVIGATION: {
+      if (!isStr(c.tabId) || !isValidNavigation(c.navigation)) return false;
+      const tab = getTab(tabs, c.tabId);
+      const navigation = { ...c.navigation };
+      const i = findClosestNavigationWithIndex(tab.navigations, navigation.index);
+      if (i < tab.navigations.length && tab.navigations[i].index === navigation.index) {
+        tab.navigations[i] = navigation;
+      } else {
+        tab.navigations.splice(i, 0, navigation);
+      }
+      return true;
+    }
+    case SessionCommandId.SET_SELECTED_NAVIGATION_INDEX: {
+      if (!isStr(c.tabId) || !isNum(c.index)) return false;
+      getTab(tabs, c.tabId).currentNavigationIndex = c.index;
+      return true;
+    }
+    case SessionCommandId.SET_SELECTED_TAB_IN_INDEX: {
+      if (!isStr(c.windowId) || !isNum(c.index)) return false;
+      getWindow(windows, c.windowId).selectedTabIndex = c.index;
+      return true;
+    }
+    case SessionCommandId.SET_PINNED_STATE: {
+      if (!isStr(c.tabId) || !isBool(c.pinned)) return false;
+      getTab(tabs, c.tabId).pinned = c.pinned;
+      return true;
+    }
+    case SessionCommandId.TAB_CLOSED: {
+      if (!isStr(c.tabId)) return false;
+      tabs.delete(c.tabId);
+      return true;
+    }
+    case SessionCommandId.WINDOW_CLOSED: {
+      if (!isStr(c.windowId)) return false;
+      windows.delete(c.windowId);
+      return true;
+    }
+    case SessionCommandId.SET_ACTIVE_WINDOW: {
+      if (!isStr(c.windowId)) return false;
+      state.activeWindowId = c.windowId;
+      return true;
+    }
+    case SessionCommandId.LAST_ACTIVE_TIME: {
+      if (!isStr(c.tabId) || !isNum(c.lastActiveTime)) return false;
+      getTab(tabs, c.tabId).lastActiveTime = c.lastActiveTime;
+      return true;
+    }
+    case SessionCommandId.TAB_NAVIGATION_PATH_PRUNED: {
+      if (!isStr(c.tabId) || !isNum(c.index) || !isNum(c.count)) return false;
+      if (c.index < 0 || c.count < 1) return false;
+      processTabNavigationPathPruned(getTab(tabs, c.tabId), c.index, c.count);
+      return true;
+    }
+    case SessionCommandId.SET_TAB_GROUP: {
+      if (!isStr(c.tabId) || !(c.groupId === null || isStr(c.groupId))) return false;
+      getTab(tabs, c.tabId).groupId = c.groupId;
+      return true;
+    }
+    case SessionCommandId.SET_TAB_GROUP_METADATA2: {
+      if (!isStr(c.groupId) || !isValidVisualData(c.visualData)) return false;
+      tabGroups.set(c.groupId, { groupId: c.groupId, visualData: { ...c.visualData } });
+      return true;
+    }
+    case SessionCommandId.SET_TAB_DATA: {
+      if (!isStr(c.tabId)) return false;
+      getTab(tabs, c.tabId).data = c.data;
+      return true;
+    }
+    case SessionCommandId.ADD_TAB_EXTRA_DATA: {
+      if (!isStr(c.tabId) || !isStr(c.key) || !isStr(c.value)) return false;
+      getTab(tabs, c.tabId).extraData[c.key] = c.value;
+      return true;
+    }
+    case SessionCommandId.ADD_WINDOW_EXTRA_DATA: {
+      if (!isStr(c.windowId) || !isStr(c.key) || !isStr(c.value)) return false;
+      getWindow(windows, c.windowId).extraData[c.key] = c.value;
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+function restoreSessionFromCommands(commands) {
+  const state = {
+    tabs: /* @__PURE__ */ new Map(),
+    tabGroups: /* @__PURE__ */ new Map(),
+    windows: /* @__PURE__ */ new Map(),
+    activeWindowId: null
+  };
+  let errorReading = false;
+  for (const command of commands) {
+    if (!processCommand(state, command)) {
+      errorReading = true;
+      break;
+    }
+  }
+  for (const tab of state.tabs.values()) {
+    if (!tab.hasWindow) continue;
+    if (tab.navigations.length === 0 && tab.data === void 0) continue;
+    const window2 = getWindow(state.windows, tab.windowId);
+    window2.tabs.push(tab);
+    if (tab.navigations.length > 0) {
+      const j = findClosestNavigationWithIndex(tab.navigations, tab.currentNavigationIndex);
+      tab.currentNavigationIndex = j === tab.navigations.length ? tab.navigations.length - 1 : j;
+    } else {
+      tab.currentNavigationIndex = -1;
+    }
+  }
+  for (const window2 of state.windows.values()) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const tab of window2.tabs) {
+      if (tab.groupId === null || seen.has(tab.groupId)) continue;
+      seen.add(tab.groupId);
+      window2.tabGroups.push(
+        state.tabGroups.get(tab.groupId) ?? {
+          groupId: tab.groupId,
+          visualData: { title: "", color: "grey", isCollapsed: false }
+        }
+      );
+    }
+  }
+  const validWindows = [...state.windows.values()].filter((w) => w.tabs.length > 0);
+  for (const window2 of validWindows) {
+    window2.tabs.sort((a, b) => a.visualIndex - b.visualIndex);
+  }
+  validWindows.sort((a, b) => a.windowId < b.windowId ? -1 : a.windowId > b.windowId ? 1 : 0);
+  for (const window2 of validWindows) {
+    const i = window2.tabs.findIndex((t) => t.visualIndex === window2.selectedTabIndex);
+    window2.selectedTabIndex = i === -1 ? 0 : i;
+  }
+  for (const window2 of validWindows) {
+    for (const tab of window2.tabs) delete tab.hasWindow;
+  }
+  return {
+    windows: validWindows,
+    activeWindowId: state.activeWindowId,
+    errorReading
+  };
+}
+
+// src/session/session-restore.ts
+function restoreSessionWindow(model, window2, options = {}) {
+  const createTabData = options.createTabData ?? ((tab) => tab.data);
+  const preserveIds = options.preserveTabIds !== false;
+  const tabIdMap = /* @__PURE__ */ new Map();
+  const groupIdMap = /* @__PURE__ */ new Map();
+  const liveTabs = [];
+  for (const sessionTab of window2.tabs) {
+    const id = preserveIds && model.getTabById(sessionTab.tabId) === null ? sessionTab.tabId : void 0;
+    const tab = model.insertTabAt(model.count, createTabData(sessionTab), {
+      ...id !== void 0 ? { id } : {},
+      flags: sessionTab.pinned ? AddTabFlags.PINNED : AddTabFlags.NONE
+    });
+    liveTabs.push(tab);
+    tabIdMap.set(sessionTab.tabId, tab.id);
+  }
+  if (model.supportsTabGroups) {
+    for (const sessionGroup of window2.tabGroups) {
+      const indices = [];
+      window2.tabs.forEach((sessionTab, i) => {
+        if (sessionTab.groupId === sessionGroup.groupId) indices.push(model.indexOfTab(liveTabs[i]));
+      });
+      if (indices.length === 0) continue;
+      const liveGroupId = model.addToNewGroup(indices, sessionGroup.visualData);
+      groupIdMap.set(sessionGroup.groupId, liveGroupId);
+    }
+  }
+  if (liveTabs.length > 0) {
+    const selected = Math.max(0, Math.min(window2.selectedTabIndex, liveTabs.length - 1));
+    model.activateTabAt(model.indexOfTab(liveTabs[selected]));
+    if (options.deferLoading) {
+      for (let i = 0; i < liveTabs.length; i++) {
+        if (i === selected) continue;
+        model.discardTabAt(model.indexOfTab(liveTabs[i]));
+      }
+    }
+  }
+  return { tabsRestored: liveTabs.length, tabIdMap, groupIdMap };
+}
+
+// src/session/session-types.ts
+var DEFAULT_WINDOW_ID = "window-1";
+function currentNavigationEntry(tab) {
+  if (tab.navigations.length === 0) return null;
+  const i = Math.max(0, Math.min(tab.currentNavigationIndex, tab.navigations.length - 1));
+  return tab.navigations[i];
+}
+
+// src/session/session-service.ts
+var WRITES_PER_RESET = 250;
+var MAX_PERSISTED_NAVIGATIONS = 6;
+var SessionService = class {
+  storage_;
+  manager_;
+  serializeTabData_;
+  deserializeTabData_;
+  writesPerReset_;
+  maxPersistedNavigations_;
+  onError_;
+  /**
+   * Resolves once the profile claim is settled and, for the owner, the
+   * previous session has been rotated to the last slot.
+   */
+  ready_;
+  windows_ = /* @__PURE__ */ new Map();
+  navState_ = /* @__PURE__ */ new Map();
+  tabExtraData_ = /* @__PURE__ */ new Map();
+  windowExtraData_ = /* @__PURE__ */ new Map();
+  activeWindowId_ = null;
+  /** Mirrors rebuild_on_next_save_ (session_service_base.cc). */
+  rebuildOnNextSave_ = false;
+  pageHideListener_ = null;
+  disposed_ = false;
+  singleton_;
+  ownership_ = "pending";
+  /** Mirrors is_saving_enabled_ (session_service_base.h:337). */
+  savingEnabled_ = false;
+  constructor(options) {
+    this.storage_ = options.storage;
+    this.serializeTabData_ = options.serializeTabData ?? ((data) => data);
+    this.deserializeTabData_ = options.deserializeTabData ?? ((raw) => raw);
+    this.writesPerReset_ = options.writesPerReset ?? WRITES_PER_RESET;
+    this.maxPersistedNavigations_ = options.maxPersistedNavigations ?? MAX_PERSISTED_NAVIGATIONS;
+    this.onError_ = options.onError ?? ((error) => console.error("chromium-tabs session:", error));
+    this.singleton_ = options.processSingleton !== void 0 ? options.processSingleton : createDefaultProcessSingleton(this.storage_.profileLockName);
+    let gate = null;
+    if (this.singleton_ === null) {
+      this.ownership_ = "owner";
+      gate = this.rotateNow_();
+      this.ready_ = gate ?? Promise.resolve();
+    } else {
+      gate = this.singleton_.acquire().then(async (result) => {
+        this.ownership_ = result;
+        if (result === "owner" && !this.disposed_) {
+          const rotation = this.rotateNow_();
+          if (rotation) await rotation;
+          this.setSavingEnabled_(true);
+        }
+      });
+      this.ready_ = gate;
+    }
+    this.manager_ = new CommandStorageManager({
+      backend: this.storage_,
+      saveDelayMs: options.saveDelayMs,
+      ...gate ? { ready: gate } : {},
+      delegate: {
+        // RebuildCommandsIfRequired (session_service_base.cc:856).
+        onWillSaveCommands: () => {
+          if (this.rebuildOnNextSave_) this.scheduleResetCommands();
+        },
+        onErrorWritingSessionCommands: () => {
+          this.rebuildOnNextSave_ = true;
+          this.manager_.startSaveTimer();
+        }
+      }
+    });
+    if (this.singleton_ === null) this.setSavingEnabled_(true);
+    const flushOnPageHide = options.flushOnPageHide ?? true;
+    if (flushOnPageHide && typeof window !== "undefined" && typeof window.addEventListener === "function") {
+      this.pageHideListener_ = () => {
+        void this.saveNow();
+      };
+      window.addEventListener("pagehide", this.pageHideListener_);
+    }
+  }
+  /**
+   * Which side of the profile claim this service landed on: 'pending' until
+   * resolved, then 'owner' (this realm persists the session) or 'secondary'
+   * (another realm owns the storage area; this service records and restores
+   * nothing). Settled by the time getLastSession/restoreInto resolve.
+   */
+  get ownership() {
+    return this.ownership_;
+  }
+  /** Starts rotation; returns the pending promise when async, else null. */
+  rotateNow_() {
+    let rotation;
+    try {
+      rotation = this.storage_.moveCurrentSessionToLastSession();
+    } catch (error) {
+      this.onError_(error);
+      rotation = void 0;
+    }
+    if (rotation && typeof rotation.then === "function") {
+      return rotation.then(
+        () => void 0,
+        (error) => {
+          this.onError_(error);
+        }
+      );
+    }
+    return null;
+  }
+  /** Port of SetSavingEnabled (session_service_base.cc:877). */
+  setSavingEnabled_(enabled) {
+    if (this.savingEnabled_ === enabled) return;
+    this.savingEnabled_ = enabled;
+    if (!this.savingEnabled_) {
+      this.manager_.clearPendingCommands();
+    } else {
+      this.scheduleResetCommands();
+    }
+  }
+  // Attach / detach ////////////////////////////////////////////////////////
+  /**
+   * Starts recording a model under the given window id and schedules a full
+   * snapshot of its current state (the SetSavingEnabled(true) startup path,
+   * session_service_base.cc:412). Returns a detach function.
+   */
+  attach(model, options = {}) {
+    this.checkNotDisposed_();
+    const windowId = options.windowId ?? DEFAULT_WINDOW_ID;
+    if (this.windows_.has(windowId)) {
+      throw new Error(`session: window "${windowId}" is already attached`);
+    }
+    for (const entry2 of this.windows_.values()) {
+      if (entry2.model === model) throw new Error("session: model is already attached");
+    }
+    const entry = { model, unsubscribe: () => {
+    }, lastSelectedIndex: NO_TAB };
+    entry.unsubscribe = model.addObserver(this.createObserver_(windowId, entry));
+    this.windows_.set(windowId, entry);
+    if (this.activeWindowId_ === null) this.activeWindowId_ = windowId;
+    this.scheduleResetCommands();
+    return () => this.detach(windowId);
+  }
+  /**
+   * Stops recording a window. The window's commands stay in the log until
+   * the next full rewrite; use markWindowClosed first to drop it eagerly.
+   */
+  detach(windowId) {
+    const entry = this.windows_.get(windowId);
+    if (!entry) return;
+    entry.unsubscribe();
+    this.windows_.delete(windowId);
+    for (const tab of entry.model.getTabs()) {
+      this.navState_.delete(tab.id);
+      this.tabExtraData_.delete(tab.id);
+    }
+    this.windowExtraData_.delete(windowId);
+    if (this.activeWindowId_ === windowId) this.activeWindowId_ = null;
+  }
+  /**
+   * Records the window as closed and detaches it. Tab closes are committed
+   * alongside kCommandWindowClosed, mirroring CommitPendingCloses
+   * (session_service.cc) — otherwise the tabs' surviving commands would
+   * resurrect the window husk during rebuild.
+   */
+  markWindowClosed(windowId) {
+    const entry = this.windows_.get(windowId);
+    if (!entry) return;
+    const tabs = entry.model.getTabs();
+    this.detach(windowId);
+    for (const tab of tabs) this.scheduleCommand_(createTabClosedCommand(tab.id));
+    this.scheduleCommand_(createWindowClosedCommand(windowId));
+  }
+  /** Records which window is active (kCommandSetActiveWindow). */
+  setActiveWindow(windowId) {
+    if (!this.windows_.has(windowId)) return;
+    this.activeWindowId_ = windowId;
+    this.scheduleCommand_(createSetActiveWindowCommand(windowId));
+  }
+  // Navigation tracking (the SessionTabHelper surface) /////////////////////
+  /**
+   * Records that a tab committed a new navigation: forward history is pruned
+   * and the new entry becomes current — normal browser semantics. Untracked
+   * tab ids are ignored, like commands for untracked windows in Chrome.
+   */
+  navigateTab(tabId, entry) {
+    if (!this.findTab_(tabId)) return;
+    let nav = this.navState_.get(tabId);
+    if (!nav) {
+      nav = { navigations: [], currentNavigationIndex: -1 };
+      this.navState_.set(tabId, nav);
+    }
+    const newIndex = nav.currentNavigationIndex + 1;
+    const last = nav.navigations[nav.navigations.length - 1];
+    if (last && last.index >= newIndex) {
+      const count = last.index - newIndex + 1;
+      processTabNavigationPathPruned(nav, newIndex, count);
+      this.scheduleCommand_(createTabNavigationPathPrunedCommand(tabId, newIndex, count));
+    }
+    const navigation = {
+      index: newIndex,
+      url: entry.url,
+      ...entry.title !== void 0 ? { title: entry.title } : {},
+      ...entry.state !== void 0 ? { state: entry.state } : {},
+      timestamp: entry.timestamp ?? Date.now()
+    };
+    this.insertNavigation_(nav, navigation);
+    nav.currentNavigationIndex = newIndex;
+    this.scheduleCommand_(createUpdateTabNavigationCommand(tabId, navigation));
+    this.scheduleCommand_(createSetSelectedNavigationIndexCommand(tabId, newIndex));
+  }
+  /**
+   * Replaces-or-inserts one navigation entry by its index — e.g. the current
+   * page's title or scroll state changed in place. Mirrors
+   * UpdateTabNavigation (session_service.cc).
+   */
+  updateTabNavigation(tabId, navigation) {
+    if (!this.findTab_(tabId)) return;
+    let nav = this.navState_.get(tabId);
+    if (!nav) {
+      nav = { navigations: [], currentNavigationIndex: -1 };
+      this.navState_.set(tabId, nav);
+    }
+    this.insertNavigation_(nav, { ...navigation });
+    this.scheduleCommand_(createUpdateTabNavigationCommand(tabId, { ...navigation }));
+  }
+  /** Records back/forward movement. Mirrors SetSelectedNavigationIndex. */
+  setSelectedNavigationIndex(tabId, index) {
+    if (!this.findTab_(tabId)) return;
+    const nav = this.navState_.get(tabId);
+    if (!nav || !nav.navigations.some((n) => n.index === index)) return;
+    nav.currentNavigationIndex = index;
+    this.scheduleCommand_(createSetSelectedNavigationIndexCommand(tabId, index));
+  }
+  /** Removes `count` entries from index value `index`. Mirrors TabNavigationPathPruned. */
+  pruneTabNavigations(tabId, index, count) {
+    if (!this.findTab_(tabId)) return;
+    const nav = this.navState_.get(tabId);
+    if (!nav || index < 0 || count < 1) return;
+    processTabNavigationPathPruned(nav, index, count);
+    this.scheduleCommand_(createTabNavigationPathPrunedCommand(tabId, index, count));
+  }
+  // Extra data (kCommandAddTabExtraData / kCommandAddWindowExtraData) //////
+  setTabExtraData(tabId, key, value) {
+    if (!this.findTab_(tabId)) return;
+    let map = this.tabExtraData_.get(tabId);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      this.tabExtraData_.set(tabId, map);
+    }
+    map.set(key, value);
+    this.scheduleCommand_(createAddTabExtraDataCommand(tabId, key, value));
+  }
+  setWindowExtraData(windowId, key, value) {
+    if (!this.windows_.has(windowId)) return;
+    let map = this.windowExtraData_.get(windowId);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      this.windowExtraData_.set(windowId, map);
+    }
+    map.set(key, value);
+    this.scheduleCommand_(createAddWindowExtraDataCommand(windowId, key, value));
+  }
+  // Reading and restoring //////////////////////////////////////////////////
+  /** Replays the previous session's log. Mirrors GetLastSession. */
+  async getLastSession() {
+    this.checkNotDisposed_();
+    await this.ready_;
+    if (this.ownership_ === "secondary") {
+      return { windows: [], activeWindowId: null, errorReading: false };
+    }
+    let commands;
+    let errorReading;
+    try {
+      const result = await this.storage_.readLastSessionCommands();
+      commands = result.commands;
+      errorReading = result.errorReading;
+    } catch (error) {
+      this.onError_(error);
+      return { windows: [], activeWindowId: null, errorReading: true };
+    }
+    const snapshot = restoreSessionFromCommands(commands);
+    return { ...snapshot, errorReading: snapshot.errorReading || errorReading };
+  }
+  /**
+   * The one-call integration: restores the previous session's window into
+   * `model` (when there is one) and attaches the model so the new session is
+   * recorded. Restored navigation histories and extra data are re-adopted so
+   * they survive future log rewrites.
+   */
+  async restoreInto(model, options = {}) {
+    this.checkNotDisposed_();
+    const snapshot = await this.getLastSession();
+    const window2 = options.windowId ? snapshot.windows.find((w) => w.windowId === options.windowId) : snapshot.windows[0];
+    const windowId = options.windowId ?? window2?.windowId ?? DEFAULT_WINDOW_ID;
+    let result = { tabsRestored: 0, tabIdMap: /* @__PURE__ */ new Map(), groupIdMap: /* @__PURE__ */ new Map() };
+    if (window2) {
+      result = restoreSessionWindow(model, window2, {
+        createTabData: options.createTabData ?? ((tab) => this.deserializeTabData_(tab.data)),
+        preserveTabIds: options.preserveTabIds,
+        deferLoading: options.deferLoading
+      });
+      for (const sessionTab of window2.tabs) {
+        const liveId = result.tabIdMap.get(sessionTab.tabId);
+        if (liveId === void 0) continue;
+        if (sessionTab.navigations.length > 0) {
+          const position = Math.max(
+            0,
+            Math.min(sessionTab.currentNavigationIndex, sessionTab.navigations.length - 1)
+          );
+          this.navState_.set(liveId, {
+            navigations: sessionTab.navigations.map((n) => ({ ...n })),
+            currentNavigationIndex: sessionTab.navigations[position].index
+          });
+        }
+        const extra = Object.entries(sessionTab.extraData);
+        if (extra.length > 0) this.tabExtraData_.set(liveId, new Map(extra));
+      }
+      const windowExtra = Object.entries(window2.extraData);
+      if (windowExtra.length > 0) this.windowExtraData_.set(windowId, new Map(windowExtra));
+    }
+    this.attach(model, { windowId });
+    return {
+      ...result,
+      restored: window2 !== void 0,
+      snapshot,
+      ownership: this.ownership_ === "secondary" ? "secondary" : "owner"
+    };
+  }
+  // Persistence control /////////////////////////////////////////////////////
+  /** Flushes buffered commands now (e.g. before an intentional teardown). */
+  saveNow() {
+    return this.manager_.save();
+  }
+  /** True while commands are buffered awaiting the save timer. */
+  get hasPendingSave() {
+    return this.manager_.hasPendingSave;
+  }
+  /**
+   * Discards the log and rewrites it from live state. Mirrors
+   * ScheduleResetCommands (session_service_base.cc:404) +
+   * BuildCommandsFromBrowsers (cc:767).
+   */
+  scheduleResetCommands() {
+    if (!this.savingEnabled_) return;
+    this.manager_.setPendingReset(true);
+    this.manager_.clearPendingCommands();
+    this.rebuildOnNextSave_ = false;
+    for (const [windowId, entry] of this.windows_) {
+      this.buildCommandsForWindow_(windowId, entry);
+    }
+    if (this.activeWindowId_ !== null) {
+      this.manager_.appendRebuildCommand(createSetActiveWindowCommand(this.activeWindowId_));
+    }
+    this.manager_.startSaveTimer();
+  }
+  /** Detaches everything and stops timers. Does not flush — saveNow() first if needed. */
+  dispose() {
+    if (this.disposed_) return;
+    this.disposed_ = true;
+    for (const windowId of [...this.windows_.keys()]) this.detach(windowId);
+    if (this.pageHideListener_ !== null) {
+      window.removeEventListener("pagehide", this.pageHideListener_);
+      this.pageHideListener_ = null;
+    }
+    this.manager_.dispose();
+    this.singleton_?.release();
+  }
+  // Internals ///////////////////////////////////////////////////////////////
+  checkNotDisposed_() {
+    if (this.disposed_) throw new Error("session: service is disposed");
+  }
+  findTab_(tabId) {
+    for (const [windowId, entry] of this.windows_) {
+      const tab = entry.model.getTabById(tabId);
+      if (tab) return { windowId, tab, index: entry.model.indexOfTab(tab) };
+    }
+    return null;
+  }
+  /** Replace-or-insert by navigation index (session_service_commands.cc:664). */
+  insertNavigation_(nav, navigation) {
+    const i = findClosestNavigationWithIndex(nav.navigations, navigation.index);
+    if (i < nav.navigations.length && nav.navigations[i].index === navigation.index) {
+      nav.navigations[i] = navigation;
+    } else {
+      nav.navigations.splice(i, 0, navigation);
+    }
+  }
+  serializeTab_(tab) {
+    try {
+      return this.serializeTabData_(tab.data, tab);
+    } catch (error) {
+      this.onError_(error);
+      return void 0;
+    }
+  }
+  /**
+   * Coalesces a new command with a buffered one when only the latest value
+   * matters. Port of ReplacePendingCommand (session_service_commands.cc:1344)
+   * — Chrome only handles UpdateTabNavigation and SetActiveWindow; the other
+   * last-write-wins commands here are this port's extension, safe because the
+   * rebuild treats each of them as a keyed assignment.
+   */
+  replacePendingCommand_(command) {
+    const pending = this.manager_.pendingCommands;
+    for (let i = pending.length - 1; i >= 0; i--) {
+      const existing = pending[i];
+      if (existing.id !== command.id) continue;
+      switch (command.id) {
+        case SessionCommandId.UPDATE_TAB_NAVIGATION: {
+          const old = existing;
+          if (old.tabId === command.tabId && old.navigation.index === command.navigation.index) {
+            this.manager_.eraseCommand(existing);
+            this.manager_.appendRebuildCommand(command);
+            return true;
+          }
+          continue;
+        }
+        case SessionCommandId.SET_ACTIVE_WINDOW:
+          this.manager_.swapCommand(existing, command);
+          return true;
+        case SessionCommandId.SET_TAB_DATA:
+        case SessionCommandId.SET_TAB_INDEX_IN_WINDOW:
+        case SessionCommandId.LAST_ACTIVE_TIME:
+        case SessionCommandId.SET_PINNED_STATE:
+        case SessionCommandId.SET_TAB_GROUP: {
+          if (existing.tabId === command.tabId) {
+            this.manager_.swapCommand(existing, command);
+            return true;
+          }
+          continue;
+        }
+        case SessionCommandId.SET_SELECTED_TAB_IN_INDEX: {
+          if (existing.windowId === command.windowId) {
+            this.manager_.swapCommand(existing, command);
+            return true;
+          }
+          continue;
+        }
+        case SessionCommandId.SET_TAB_GROUP_METADATA2: {
+          if (existing.groupId === command.groupId) {
+            this.manager_.swapCommand(existing, command);
+            return true;
+          }
+          continue;
+        }
+        default:
+          return false;
+      }
+    }
+    return false;
+  }
+  /** Mirrors SessionServiceBase::ScheduleCommand (session_service_base.cc:788). */
+  scheduleCommand_(command) {
+    if (this.disposed_ || !this.savingEnabled_) return;
+    if (this.replacePendingCommand_(command)) return;
+    const closing = isClosingCommand(command);
+    this.manager_.scheduleCommand(command);
+    if (!this.manager_.pendingReset && this.manager_.commandsSinceReset >= this.writesPerReset_ && !closing) {
+      this.scheduleResetCommands();
+    }
+  }
+  /** SetTabIndexInWindow for every tab in [lo, hi] — see the header comment. */
+  emitIndexRange_(model, lo, hi) {
+    const tabs = model.getTabs();
+    const last = Math.min(hi, tabs.length - 1);
+    for (let i = Math.max(0, lo); i <= last; i++) {
+      this.scheduleCommand_(createSetTabIndexInWindowCommand(tabs[i].id, i));
+    }
+  }
+  /** Dedup-cached SetSelectedTabInWindow, like session_service.cc. */
+  maybeEmitSelectedTab_(windowId, entry) {
+    const index = entry.model.activeIndex;
+    if (index === entry.lastSelectedIndex || index === NO_TAB) return;
+    entry.lastSelectedIndex = index;
+    this.scheduleCommand_(createSetSelectedTabInWindowCommand(windowId, index));
+  }
+  /**
+   * BuildCommandsForBrowser + BuildCommandsForTab
+   * (session_service_base.cc:672, :592), adapted to one TabStripModel.
+   */
+  buildCommandsForWindow_(windowId, entry) {
+    const model = entry.model;
+    const m = this.manager_;
+    const windowExtra = this.windowExtraData_.get(windowId);
+    if (windowExtra) {
+      for (const [key, value] of windowExtra) {
+        m.appendRebuildCommand(createAddWindowExtraDataCommand(windowId, key, value));
+      }
+    }
+    const tabs = model.getTabs();
+    tabs.forEach((tab, index) => {
+      m.appendRebuildCommand(createSetTabWindowCommand(windowId, tab.id));
+      if (Number.isFinite(tab.lastActiveAt)) {
+        m.appendRebuildCommand(createLastActiveTimeCommand(tab.id, tab.lastActiveAt));
+      }
+      const nav = this.navState_.get(tab.id);
+      if (nav && nav.navigations.length > 0) {
+        const position = findClosestNavigationWithIndex(nav.navigations, nav.currentNavigationIndex);
+        const lo = Math.max(position - this.maxPersistedNavigations_, 0);
+        const hi = Math.min(position + this.maxPersistedNavigations_, nav.navigations.length);
+        for (let i = lo; i < hi; i++) {
+          m.appendRebuildCommand(createUpdateTabNavigationCommand(tab.id, { ...nav.navigations[i] }));
+        }
+        m.appendRebuildCommand(createSetSelectedNavigationIndexCommand(tab.id, nav.currentNavigationIndex));
+      }
+      m.appendRebuildCommand(createSetTabIndexInWindowCommand(tab.id, index));
+      if (tab.pinned) m.appendRebuildCommand(createPinnedStateCommand(tab.id, true));
+      if (tab.group !== null) m.appendRebuildCommand(createTabGroupCommand(tab.id, tab.group));
+      m.appendRebuildCommand(createSetTabDataCommand(tab.id, this.serializeTab_(tab)));
+      const extra = this.tabExtraData_.get(tab.id);
+      if (extra) {
+        for (const [key, value] of extra) {
+          m.appendRebuildCommand(createAddTabExtraDataCommand(tab.id, key, value));
+        }
+      }
+    });
+    for (const group of model.getGroups()) {
+      m.appendRebuildCommand(createTabGroupMetadataUpdateCommand(group.id, group.visualData));
+    }
+    if (model.activeIndex !== NO_TAB) {
+      m.appendRebuildCommand(createSetSelectedTabInWindowCommand(windowId, model.activeIndex));
+    }
+    entry.lastSelectedIndex = model.activeIndex;
+  }
+  createObserver_(windowId, entry) {
+    const guarded = (fn) => {
+      return (...args) => {
+        try {
+          fn(...args);
+        } catch (error) {
+          this.onError_(error);
+        }
+      };
+    };
+    return {
+      onTabStripModelChanged: guarded(
+        (change, selection) => {
+          switch (change.type) {
+            case "inserted": {
+              let minIndex = Infinity;
+              for (const { tab, index } of change.contents) {
+                this.scheduleCommand_(createSetTabWindowCommand(windowId, tab.id));
+                this.scheduleCommand_(createSetTabDataCommand(tab.id, this.serializeTab_(tab)));
+                if (tab.pinned) this.scheduleCommand_(createPinnedStateCommand(tab.id, true));
+                if (tab.group !== null) this.scheduleCommand_(createTabGroupCommand(tab.id, tab.group));
+                minIndex = Math.min(minIndex, index);
+              }
+              this.emitIndexRange_(entry.model, minIndex, entry.model.count - 1);
+              break;
+            }
+            case "removed": {
+              let minIndex = Infinity;
+              for (const { tab, index } of change.contents) {
+                this.scheduleCommand_(createTabClosedCommand(tab.id));
+                this.navState_.delete(tab.id);
+                this.tabExtraData_.delete(tab.id);
+                minIndex = Math.min(minIndex, index);
+              }
+              this.emitIndexRange_(entry.model, minIndex, entry.model.count - 1);
+              break;
+            }
+            case "moved":
+              this.emitIndexRange_(
+                entry.model,
+                Math.min(change.fromIndex, change.toIndex),
+                Math.max(change.fromIndex, change.toIndex)
+              );
+              break;
+            case "replaced":
+              this.scheduleCommand_(createSetTabDataCommand(change.tab.id, this.serializeTab_(change.tab)));
+              break;
+            case "selectionOnly":
+              break;
+          }
+          if (selection.activeTabChanged && selection.oldTab && Number.isFinite(selection.oldTab.lastActiveAt)) {
+            this.scheduleCommand_(createLastActiveTimeCommand(selection.oldTab.id, selection.oldTab.lastActiveAt));
+          }
+          this.maybeEmitSelectedTab_(windowId, entry);
+        }
+      ),
+      onTabPinnedStateChanged: guarded((tab) => {
+        this.scheduleCommand_(createPinnedStateCommand(tab.id, tab.pinned));
+      }),
+      onTabGroupedStateChanged: guarded((_old, _new, tab) => {
+        this.scheduleCommand_(createTabGroupCommand(tab.id, tab.group));
+      }),
+      onTabGroupChanged: guarded((change) => {
+        if (change.type === "created" || change.type === "visualsChanged") {
+          const visuals = entry.model.getGroupVisualData(change.groupId);
+          if (visuals) {
+            this.scheduleCommand_(createTabGroupMetadataUpdateCommand(change.groupId, visuals));
+          }
+        }
+      }),
+      onTabChanged: guarded((tab) => {
+        this.scheduleCommand_(createSetTabDataCommand(tab.id, this.serializeTab_(tab)));
+      })
+    };
+  }
+};
+export {
+  CommandStorageManager,
+  DEFAULT_WINDOW_ID,
+  InMemoryStorageBackend,
+  MAX_PERSISTED_NAVIGATIONS,
+  SAVE_DELAY_MS,
+  SessionCommandId,
+  SessionService,
+  WRITES_PER_RESET,
+  WebLocksProcessSingleton,
+  WebStorageBackend,
+  createAddTabExtraDataCommand,
+  createAddWindowExtraDataCommand,
+  createDefaultProcessSingleton,
+  createLastActiveTimeCommand,
+  createPinnedStateCommand,
+  createSetActiveWindowCommand,
+  createSetSelectedNavigationIndexCommand,
+  createSetSelectedTabInWindowCommand,
+  createSetTabDataCommand,
+  createSetTabIndexInWindowCommand,
+  createSetTabWindowCommand,
+  createTabClosedCommand,
+  createTabGroupCommand,
+  createTabGroupMetadataUpdateCommand,
+  createTabNavigationPathPrunedCommand,
+  createUpdateTabNavigationCommand,
+  createWindowClosedCommand,
+  currentNavigationEntry,
+  findClosestNavigationWithIndex,
+  isClosingCommand,
+  processTabNavigationPathPruned,
+  restoreSessionFromCommands,
+  restoreSessionWindow
+};
+//# sourceMappingURL=index.js.map