@buoy-gg/network 7.0.36 → 7.0.39

package/lib/commonjs/network/conditions/NetworkConditionsControl.test.js

@@ -0,0 +1,136 @@
+"use strict";
+
+var _react = require("react");
+var _client = require("react-dom/client");
+var _vitest = require("vitest");
+var _NetworkConditionsControl = require("./NetworkConditionsControl");
+// @vitest-environment jsdom
+
+_vitest.vi.mock("@buoy-gg/shared-ui", async () => ({
+  ChevronDown: () => null,
+  Check: () => null,
+  night: (await _vitest.vi.importActual("../../../../shared/src/ui/night/nightTheme")).night
+}));
+_vitest.vi.mock("react-native", () => ({
+  StyleSheet: {
+    create: value => value
+  },
+  View: ({
+    children
+  }) => /*#__PURE__*/(0, _react.createElement)("div", null, children),
+  Text: ({
+    children
+  }) => /*#__PURE__*/(0, _react.createElement)("span", null, children),
+  ActivityIndicator: () => /*#__PURE__*/(0, _react.createElement)("span", null, "pending"),
+  TouchableOpacity: ({
+    children,
+    onPress,
+    disabled,
+    accessibilityLabel,
+    accessibilityState,
+    testID
+  }) => /*#__PURE__*/(0, _react.createElement)("button", {
+    onClick: onPress,
+    disabled,
+    "aria-label": accessibilityLabel,
+    "aria-checked": accessibilityState?.checked,
+    "data-testid": testID
+  }, children)
+}));
+_vitest.vi.mock("./store", () => ({
+  NETWORK_CONDITIONS: {
+    normal: {
+      label: "Normal"
+    },
+    slow: {
+      label: "Slow"
+    },
+    verySlow: {
+      label: "Very slow"
+    },
+    offline: {
+      label: "Offline"
+    }
+  },
+  getNetworkCondition: () => "normal",
+  conditionsCanApply: () => true,
+  subscribeNetworkConditions: () => () => {},
+  setNetworkCondition: _vitest.vi.fn()
+}));
+let root;
+let container;
+(0, _vitest.beforeEach)(() => {
+  globalThis.IS_REACT_ACT_ENVIRONMENT = true;
+  container = document.createElement("div");
+  root = (0, _client.createRoot)(container);
+});
+(0, _vitest.afterEach)(() => (0, _react.act)(() => root.unmount()));
+const button = profile => container.querySelector(`[data-testid="buoy-network-condition-${profile}"]`);
+function render(remote) {
+  (0, _react.act)(() => root.render(/*#__PURE__*/(0, _react.createElement)(_NetworkConditionsControl.NetworkConditionsControl, {
+    remote
+  })));
+}
+const dropdown = () => container.querySelector('[data-testid="buoy-network-conditions"]');
+const open = () => (0, _react.act)(() => dropdown().click());
+(0, _vitest.it)("defaults to a closed No throttling dropdown and closes when the current option is chosen", () => {
+  const onChange = _vitest.vi.fn();
+  render({
+    profile: "normal",
+    available: true,
+    onChange
+  });
+  (0, _vitest.expect)(dropdown().textContent).toBe("No throttling");
+  (0, _vitest.expect)(button("normal")).toBeNull();
+  open();
+  (0, _vitest.expect)(["normal", "slow", "verySlow", "offline"].every(value => !!button(value))).toBe(true);
+  (0, _react.act)(() => button("normal").click());
+  (0, _vitest.expect)(button("normal")).toBeNull();
+  (0, _vitest.expect)(onChange).not.toHaveBeenCalled();
+});
+(0, _vitest.it)("blocks duplicate remote changes and waits for the device profile before selecting it", async () => {
+  let finish;
+  const onChange = _vitest.vi.fn(() => new Promise(resolve => {
+    finish = resolve;
+  }));
+  render({
+    profile: "normal",
+    available: true,
+    onChange
+  });
+  open();
+  (0, _react.act)(() => button("slow").click());
+  (0, _vitest.expect)(button("offline").disabled).toBe(true);
+  (0, _vitest.expect)(button("normal").getAttribute("aria-checked")).toBe("true");
+  (0, _react.act)(() => button("offline").click());
+  (0, _vitest.expect)(onChange).toHaveBeenCalledExactlyOnceWith("slow");
+  await (0, _react.act)(async () => finish());
+  render({
+    profile: "slow",
+    available: true,
+    onChange
+  });
+  (0, _vitest.expect)(dropdown().textContent).toBe("Slow");
+  (0, _vitest.expect)(button("slow")).toBeNull();
+  open();
+  (0, _vitest.expect)(button("slow").getAttribute("aria-checked")).toBe("true");
+});
+(0, _vitest.it)("reports a remote error, permits retry, and disables unavailable devices", async () => {
+  const onChange = _vitest.vi.fn().mockRejectedValue(new Error("Device disconnected"));
+  render({
+    profile: "normal",
+    available: true,
+    onChange
+  });
+  open();
+  await (0, _react.act)(async () => button("offline").click());
+  (0, _vitest.expect)(container.textContent).toContain("Device disconnected");
+  (0, _vitest.expect)(button("offline").disabled).toBe(false);
+  render({
+    profile: null,
+    available: false,
+    onChange
+  });
+  (0, _vitest.expect)(button("normal").disabled).toBe(true);
+  (0, _vitest.expect)(container.textContent).toContain("Conditions unavailable on this device");
+});

package/lib/commonjs/network/conditions/NetworkConditionsIcon.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NetworkConditionsIcon = NetworkConditionsIcon;
+var _react = require("react");
+var _reactNative = require("react-native");
+var _sharedUi = require("@buoy-gg/shared-ui");
+var _store = require("./store");
+var _jsxRuntime = require("react/jsx-runtime");
+function NetworkConditionsIcon({
+  size
+}) {
+  const profile = (0, _react.useSyncExternalStore)(_store.subscribeNetworkConditions, _store.getNetworkCondition, _store.getNetworkCondition);
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
+    accessibilityLabel: profile === "normal" ? "Network" : `Network: ${_store.NETWORK_CONDITIONS[profile].label}`,
+    children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_sharedUi.NetworkIcon, {
+      size: size
+    }), profile !== "normal" && /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
+      testID: "buoy-network-condition-indicator",
+      style: {
+        position: "absolute",
+        top: -6,
+        right: -8,
+        color: "#FFCC66",
+        fontSize: 10,
+        fontWeight: "700"
+      },
+      children: profile === "offline" ? "OFF" : `+${_store.NETWORK_CONDITIONS[profile].delayMs}`
+    })]
+  });
+}

package/lib/commonjs/network/conditions/NetworkFloatingTool.js

@@ -0,0 +1,310 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NetworkFloatingTool = NetworkFloatingTool;
+exports.createRemoteConditionsSource = createRemoteConditionsSource;
+exports.openNetworkFloatingTool = openNetworkFloatingTool;
+var _react = require("react");
+var _reactNative = require("react-native");
+var _sharedUi = require("@buoy-gg/shared-ui");
+var _store = require("./store");
+var _jsxRuntime = require("react/jsx-runtime");
+/** A live source keeps the desktop strip current after its launching panel closes. */
+function createRemoteConditionsSource() {
+  let value;
+  const listeners = new Set();
+  return {
+    getSnapshot: () => value,
+    subscribe: listener => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    update(next) {
+      value = next;
+      listeners.forEach(listener => listener());
+    }
+  };
+}
+const noSubscribe = () => () => {};
+const noRemote = () => undefined;
+const options = [{
+  id: "normal",
+  label: "No throttling",
+  detail: "No added delay"
+}, {
+  id: "slow",
+  label: "Slow",
+  detail: "+500 ms before sending"
+}, {
+  id: "verySlow",
+  label: "Very slow",
+  detail: "+2 seconds before sending"
+}, {
+  id: "offline",
+  label: "Offline",
+  detail: "New requests fail"
+}];
+const localRegistration = {
+  id: "network-throttling",
+  render: context => /*#__PURE__*/(0, _jsxRuntime.jsx)(NetworkFloatingTool, {
+    ...context
+  })
+};
+if (typeof __DEV__ !== "undefined" && __DEV__ && typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+  (0, _sharedUi.registerPersistentFloatingTool)(localRegistration, _sharedUi.persistentStorage);
+}
+function openNetworkFloatingTool(source) {
+  (0, _sharedUi.openFloatingTool)({
+    id: "network-throttling",
+    render: context => /*#__PURE__*/(0, _jsxRuntime.jsx)(NetworkFloatingTool, {
+      ...context,
+      source: source
+    })
+  });
+}
+function NetworkFloatingTool({
+  id,
+  revealToken,
+  dismiss,
+  source
+}) {
+  const local = (0, _react.useSyncExternalStore)(_store.subscribeNetworkConditions, _store.getNetworkCondition, _store.getNetworkCondition);
+  const localAvailable = (0, _react.useSyncExternalStore)(_store.subscribeNetworkConditions, _store.conditionsCanApply, _store.conditionsCanApply);
+  const remote = (0, _react.useSyncExternalStore)(source?.subscribe ?? noSubscribe, source?.getSnapshot ?? noRemote, noRemote);
+  const profile = source ? remote?.profile ?? null : local;
+  const available = source ? remote?.available === true : localAvailable;
+  const [pending, setPending] = (0, _react.useState)(false);
+  const [error, setError] = (0, _react.useState)();
+  const busy = (0, _react.useRef)(false);
+  const operation = (0, _react.useRef)(0);
+  const mounted = (0, _react.useRef)(true);
+  const {
+    width
+  } = (0, _reactNative.useWindowDimensions)();
+  (0, _react.useEffect)(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+  (0, _react.useEffect)(() => {
+    operation.current += 1;
+    busy.current = false;
+    setPending(false);
+    setError(undefined);
+  }, [source, remote?.targetId]);
+  const active = profile !== null && profile !== "normal";
+  const selected = profile ?? "normal";
+  const choice = options.find(option => option.id === selected);
+  const next = options[(options.findIndex(option => option.id === selected) + 1) % options.length];
+  const bars = !available || selected === "offline" ? 0 : selected === "verySlow" ? 1 : selected === "slow" ? 2 : 4;
+  const detail = pending ? "Applying…" : !available ? "Unavailable" : selected === "normal" ? "0 ms" : selected === "slow" ? "+500 ms" : selected === "verySlow" ? "+2000 ms" : "Blocked";
+  async function apply(next, close = false) {
+    if (busy.current) return;
+    const currentOperation = ++operation.current;
+    busy.current = true;
+    setPending(true);
+    setError(undefined);
+    const startingRemote = source?.getSnapshot();
+    try {
+      if (source) {
+        if (!startingRemote?.available) throw new Error("Device unavailable. Open Network again to reconnect these controls.");
+        await startingRemote.onChange(next);
+      } else (0, _store.setNetworkCondition)(next);
+      if (mounted.current && operation.current === currentOperation) {
+        if (close) dismiss();
+      }
+    } catch (failure) {
+      if (mounted.current && operation.current === currentOperation) setError(failure instanceof Error ? failure.message : String(failure));
+    } finally {
+      if (operation.current === currentOperation) {
+        busy.current = false;
+        if (mounted.current) setPending(false);
+      }
+    }
+  }
+  const accessory = error ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+    style: styles.menu,
+    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
+      accessibilityRole: "alert",
+      style: styles.error,
+      children: error
+    })
+  }) : undefined;
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_sharedUi.FloatingTool, {
+    id: id,
+    revealToken: revealToken,
+    variant: "strip",
+    dragFromSurface: true,
+    accessibilityLabel: `Move or hide network throttling. ${active ? "Active" : "Off"}`,
+    accessory: accessory,
+    children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
+      style: [styles.row, {
+        width: Math.max(220, Math.min(292, width - 64))
+      }],
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.TouchableOpacity, {
+        testID: "throttling-cycle",
+        accessibilityRole: "button",
+        accessibilityLabel: `Network: ${choice.label}. Switch to ${next.label}`,
+        accessibilityState: {
+          disabled: pending || !available
+        },
+        disabled: pending || !available,
+        onPress: () => void apply(next.id),
+        style: styles.signalButton,
+        children: pending ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.ActivityIndicator, {
+          size: "small",
+          color: _sharedUi.night.color.accent
+        }) : /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
+          testID: `throttling-signal-${selected}`,
+          style: styles.signal,
+          children: [[7, 12, 18, 24].map((height, index) => /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+            style: {
+              width: 4,
+              height,
+              borderRadius: 2,
+              backgroundColor: index < bars ? selected === "offline" ? _sharedUi.night.color.danger : _sharedUi.night.color.accent : _sharedUi.night.color.fillTertiary
+            }
+          }, height)), selected === "offline" && /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+            style: styles.slash
+          })]
+        })
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+        style: styles.profile,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
+          testID: "throttling-profile",
+          accessibilityLabel: `Connection profile: ${choice.label}`,
+          accessibilityLiveRegion: "polite",
+          numberOfLines: 1,
+          style: styles.profileLabel,
+          children: choice.label
+        })
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
+        testID: "throttling-status",
+        numberOfLines: 1,
+        accessibilityLiveRegion: "polite",
+        style: styles.status,
+        children: detail
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+        style: styles.separator
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.TouchableOpacity, {
+        testID: "throttling-close",
+        accessibilityRole: "button",
+        accessibilityLabel: "Close and turn off throttling",
+        disabled: pending,
+        accessibilityState: {
+          disabled: pending
+        },
+        onPress: () => {
+          if (profile === "normal") dismiss();else void apply("normal", true);
+        },
+        style: [styles.action, pending && styles.disabled],
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
+          style: styles.actionText,
+          children: "Close"
+        })
+      })]
+    })
+  });
+}
+const styles = _reactNative.StyleSheet.create({
+  row: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 6,
+    paddingVertical: 4,
+    minHeight: 48
+  },
+  signalButton: {
+    width: 36,
+    minHeight: 44,
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  signal: {
+    flexDirection: "row",
+    alignItems: "flex-end",
+    gap: 3,
+    height: 24
+  },
+  slash: {
+    position: "absolute",
+    width: 30,
+    height: 2,
+    backgroundColor: _sharedUi.night.color.danger,
+    top: 11,
+    left: -2,
+    transform: [{
+      rotate: "-45deg"
+    }]
+  },
+  separator: {
+    height: 20,
+    width: 1,
+    backgroundColor: _sharedUi.night.color.separator,
+    marginHorizontal: 2
+  },
+  status: {
+    color: _sharedUi.night.color.textSecondary,
+    fontSize: 10,
+    lineHeight: 15,
+    flexShrink: 1
+  },
+  profile: {
+    flex: 1,
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 6,
+    minHeight: 44
+  },
+  profileLabel: {
+    color: _sharedUi.night.color.text,
+    fontSize: 13,
+    fontWeight: "500",
+    flexShrink: 1
+  },
+  action: {
+    minHeight: 36,
+    minWidth: 52,
+    borderRadius: _sharedUi.night.radius.input,
+    borderWidth: 1,
+    borderColor: _sharedUi.night.color.accentBorderStrong,
+    alignItems: "center",
+    justifyContent: "center",
+    paddingHorizontal: 10
+  },
+  actionText: {
+    color: _sharedUi.night.color.accent,
+    fontSize: 12,
+    fontWeight: "600"
+  },
+  disabled: {
+    opacity: 0.4
+  },
+  menu: {
+    marginVertical: 8,
+    padding: 6,
+    borderRadius: _sharedUi.night.radius.card,
+    borderWidth: 1,
+    borderColor: _sharedUi.night.color.separator,
+    backgroundColor: _sharedUi.night.color.surface,
+    shadowColor: "#000",
+    shadowOffset: {
+      width: 0,
+      height: 6
+    },
+    shadowOpacity: 0.25,
+    shadowRadius: 16,
+    elevation: 8
+  },
+  error: {
+    color: _sharedUi.night.color.danger,
+    fontSize: 12,
+    lineHeight: 18,
+    padding: 10
+  }
+});

package/lib/commonjs/network/conditions/NetworkFloatingTool.test.js

@@ -0,0 +1,219 @@
+"use strict";
+
+var _react = require("react");
+var _client = require("react-dom/client");
+var _vitest = require("vitest");
+var _NetworkFloatingTool = require("./NetworkFloatingTool");
+// @vitest-environment jsdom
+
+const state = _vitest.vi.hoisted(() => ({
+  profile: "normal",
+  available: true,
+  listeners: new Set(),
+  set: _vitest.vi.fn()
+}));
+_vitest.vi.mock("./store", () => ({
+  getNetworkCondition: () => state.profile,
+  conditionsCanApply: () => state.available,
+  subscribeNetworkConditions: listener => {
+    state.listeners.add(listener);
+    return () => state.listeners.delete(listener);
+  },
+  setNetworkCondition: profile => {
+    state.set(profile);
+    state.profile = profile;
+    state.listeners.forEach(listener => listener());
+  }
+}));
+_vitest.vi.mock("@buoy-gg/shared-ui", async () => ({
+  night: (await _vitest.vi.importActual("../../../../shared/src/ui/night/nightTheme")).night,
+  ChevronDown: () => null,
+  Check: () => null,
+  openFloatingTool: _vitest.vi.fn(),
+  FloatingTool: ({
+    children,
+    accessory
+  }) => /*#__PURE__*/(0, _react.createElement)("div", null, children, accessory)
+}));
+_vitest.vi.mock("react-native", () => ({
+  StyleSheet: {
+    create: value => value
+  },
+  useWindowDimensions: () => ({
+    width: 390,
+    height: 844
+  }),
+  View: ({
+    children,
+    testID
+  }) => /*#__PURE__*/(0, _react.createElement)("div", {
+    "data-testid": testID
+  }, children),
+  Text: ({
+    children,
+    testID
+  }) => /*#__PURE__*/(0, _react.createElement)("span", {
+    "data-testid": testID
+  }, children),
+  ActivityIndicator: () => null,
+  TouchableOpacity: ({
+    children,
+    onPress,
+    disabled,
+    testID,
+    accessibilityLabel
+  }) => /*#__PURE__*/(0, _react.createElement)("button", {
+    onClick: onPress,
+    disabled,
+    "data-testid": testID,
+    "aria-label": accessibilityLabel
+  }, children)
+}));
+let root;
+let container;
+const dismiss = _vitest.vi.fn();
+(0, _vitest.beforeEach)(() => {
+  globalThis.IS_REACT_ACT_ENVIRONMENT = true;
+  state.profile = "normal";
+  state.available = true;
+  state.set.mockClear();
+  dismiss.mockClear();
+  container = document.createElement("div");
+  root = (0, _client.createRoot)(container);
+});
+(0, _vitest.afterEach)(() => (0, _react.act)(() => root.unmount()));
+const button = id => container.querySelector(`[data-testid="${id}"]`);
+const tap = async id => (0, _react.act)(async () => button(id).click());
+const status = () => container.querySelector('[data-testid="throttling-status"]')?.textContent;
+function render(source) {
+  (0, _react.act)(() => root.render(/*#__PURE__*/(0, _react.createElement)(_NetworkFloatingTool.NetworkFloatingTool, {
+    id: "network-throttling",
+    revealToken: 1,
+    dismiss,
+    source
+  })));
+}
+async function choose(value) {
+  const order = ["normal", "slow", "verySlow", "offline"];
+  const count = (order.indexOf(value) - order.indexOf(state.profile) + order.length) % order.length;
+  for (let i = 0; i < count; i++) await tap("throttling-cycle");
+}
+(0, _vitest.it)("cycles and applies every profile immediately, including wrapping to normal", async () => {
+  render();
+  for (const [profile, label] of [["slow", "+500 ms"], ["verySlow", "+2000 ms"], ["offline", "Blocked"], ["normal", "0 ms"]]) {
+    await tap("throttling-cycle");
+    (0, _vitest.expect)(state.profile).toBe(profile);
+    (0, _vitest.expect)(container.querySelector(`[data-testid="throttling-signal-${profile}"]`)).not.toBeNull();
+    (0, _vitest.expect)(status()).toBe(label);
+  }
+  (0, _vitest.expect)(state.set).toHaveBeenCalledTimes(4);
+});
+(0, _vitest.it)("keeps the profile label informational when tapped", async () => {
+  render();
+  await tap("throttling-profile");
+  (0, _vitest.expect)(state.set).not.toHaveBeenCalled();
+  (0, _vitest.expect)(state.profile).toBe("normal");
+  (0, _vitest.expect)(button("throttling-profile").closest("button")).toBeNull();
+});
+(0, _vitest.it)("changes active profiles and stops before dismissal", async () => {
+  state.profile = "slow";
+  render();
+  await choose("offline");
+  (0, _vitest.expect)(state.profile).toBe("offline");
+  await tap("throttling-close");
+  (0, _vitest.expect)(state.profile).toBe("normal");
+  (0, _vitest.expect)(dismiss).toHaveBeenCalledOnce();
+});
+(0, _vitest.it)("reflects external changes and disables cycling when account admission is revoked", () => {
+  render();
+  (0, _react.act)(() => {
+    state.profile = "offline";
+    state.listeners.forEach(listener => listener());
+  });
+  (0, _vitest.expect)(status()).toBe("Blocked");
+  (0, _react.act)(() => {
+    state.profile = "normal";
+    state.available = false;
+    state.listeners.forEach(listener => listener());
+  });
+  (0, _vitest.expect)(status()).toBe("Unavailable");
+  (0, _vitest.expect)(button("throttling-cycle").disabled).toBe(true);
+});
+(0, _vitest.it)("keeps remote failures visible and does not claim a profile was applied", async () => {
+  const source = (0, _NetworkFloatingTool.createRemoteConditionsSource)();
+  const onChange = _vitest.vi.fn().mockRejectedValue(new Error("Connection lost"));
+  source.update({
+    profile: "normal",
+    available: true,
+    onChange
+  });
+  render(source);
+  await choose("slow");
+  (0, _vitest.expect)(container.textContent).toContain("Connection lost");
+  (0, _vitest.expect)(status()).toBe("0 ms");
+  (0, _vitest.expect)(state.set).not.toHaveBeenCalled();
+});
+(0, _vitest.it)("prevents duplicate remote operations and follows confirmed snapshots", async () => {
+  const source = (0, _NetworkFloatingTool.createRemoteConditionsSource)();
+  let resolve;
+  const onChange = _vitest.vi.fn(() => new Promise(done => {
+    resolve = done;
+  }));
+  source.update({
+    profile: "normal",
+    available: true,
+    onChange
+  });
+  render(source);
+  await tap("throttling-cycle");
+  await tap("throttling-cycle");
+  (0, _vitest.expect)(onChange).toHaveBeenCalledOnce();
+  (0, _vitest.expect)(status()).toBe("Applying…");
+  await (0, _react.act)(async () => resolve());
+  (0, _vitest.expect)(status()).toBe("0 ms");
+  (0, _react.act)(() => source.update({
+    profile: "slow",
+    available: true,
+    onChange
+  }));
+  (0, _vitest.expect)(status()).toBe("+500 ms");
+  (0, _react.act)(() => source.update(undefined));
+  (0, _vitest.expect)(status()).toBe("Unavailable");
+});
+(0, _vitest.it)("ignores a previous device's completion after switching devices", async () => {
+  const source = (0, _NetworkFloatingTool.createRemoteConditionsSource)();
+  let reject;
+  source.update({
+    targetId: "first",
+    profile: "normal",
+    available: true,
+    onChange: () => new Promise((_resolve, fail) => {
+      reject = fail;
+    })
+  });
+  render(source);
+  await choose("slow");
+  (0, _react.act)(() => source.update({
+    targetId: "second",
+    profile: "normal",
+    available: true,
+    onChange: _vitest.vi.fn()
+  }));
+  await (0, _react.act)(async () => reject(new Error("Old device failed")));
+  (0, _vitest.expect)(container.textContent).not.toContain("Old device failed");
+  (0, _vitest.expect)(status()).toBe("0 ms");
+  (0, _vitest.expect)(button("throttling-profile").textContent).toBe("No throttling");
+});
+(0, _vitest.it)("keeps the strip open when stopping a remote device fails", async () => {
+  const source = (0, _NetworkFloatingTool.createRemoteConditionsSource)();
+  source.update({
+    profile: "offline",
+    available: true,
+    onChange: _vitest.vi.fn().mockRejectedValue(new Error("Could not stop"))
+  });
+  render(source);
+  await tap("throttling-close");
+  (0, _vitest.expect)(dismiss).not.toHaveBeenCalled();
+  (0, _vitest.expect)(status()).toBe("Blocked");
+  (0, _vitest.expect)(container.textContent).toContain("Could not stop");
+});