From 4d6b9b52e35282c31dddcc427025cc8c556a6f6b Mon Sep 17 00:00:00 2001
From: Danielv123 <danielv@danielv.no>
Date: Sat, 31 Oct 2026 23:07:34 +0100
Subject: [PATCH 01/11] Share one connect and close listener between
 subscribers

Every EventSubscriber added its own connect and close listener to the
connector, and Link caps the connector at 20 listeners per event. The
web Control and App use 13 close listeners, so the 8th plugin
subscriber made the browser log MaxListenersExceededWarning on every
page load. Subscribers on a connector now share one listener for each
event, which leaves the cap in place for everything else.
---
 packages/lib/src/subscriptions.ts | 38 ++++++++++++++++++++++------
 test/lib/subscriptions.test.js    | 41 +++++++++++++++++++++++++++++++
 2 files changed, 72 insertions(+), 7 deletions(-)

diff --git a/packages/lib/src/subscriptions.ts b/packages/lib/src/subscriptions.ts
index cc66781e..e8595fa9 100644
--- a/packages/lib/src/subscriptions.ts
+++ b/packages/lib/src/subscriptions.ts
@@ -455,6 +455,36 @@ export interface SubscribableValue {
 	isDeleted: boolean,
 }
 
+/** Subscribers created on each connector, they share one connect and one close listener on it */
+const connectorSubscribers = new WeakMap<object, Set<EventSubscriber<any, any>>>();
+
+/**
+ * Pass connect and close events of a connector on to a subscriber
+ * Uses one listener for all subscribers, so that plugins creating many subscribers do not go past the
+ * listener limit set on the connector.
+ * @param connector - connector of the link the subscriber was created on
+ * @param subscriber - subscriber to pass the events to
+ */
+function addConnectorSubscriber(connector: WebSocketBaseConnector, subscriber: EventSubscriber<any, any>) {
+	let subscribers = connectorSubscribers.get(connector);
+	if (!subscribers) {
+		const created = new Set<EventSubscriber<any, any>>();
+		connectorSubscribers.set(connector, created);
+		connector.on("connect", () => {
+			for (const entry of created) {
+				entry.handleConnectionEvent("connect");
+			}
+		});
+		connector.on("close", () => {
+			for (const entry of created) {
+				entry.handleConnectionEvent("close");
+			}
+		});
+		subscribers = created;
+	}
+	subscribers.add(subscriber);
+}
+
 /**
  * Component for subscribing to and tracking updates of a remote resource
  * Multiple handlers can be subscribed at the same time
@@ -483,13 +513,7 @@ export class EventSubscriber<E, S = null> {
 	) {
 		control.handle(Event, this._handleEvent.bind(this));
 		// The events below exist only on websocket connectors, we can't early return because of test mocking
-		const webSocketConnector = control.connector as WebSocketBaseConnector;
-		webSocketConnector.on("connect", () => {
-			this.handleConnectionEvent("connect");
-		});
-		webSocketConnector.on("close", () => {
-			this.handleConnectionEvent("close");
-		});
+		addConnectorSubscriber(control.connector as WebSocketBaseConnector, this);
 		// Only the web Control reports account changes
 		const accountControl = control as Link & { onAccountUpdate?: (handler: () => void) => void };
 		if (typeof accountControl.onAccountUpdate === "function") {
diff --git a/test/lib/subscriptions.test.js b/test/lib/subscriptions.test.js
index 461ca0ee..45f30078 100644
--- a/test/lib/subscriptions.test.js
+++ b/test/lib/subscriptions.test.js
@@ -1021,6 +1021,47 @@ describe("lib/subscriptions", function() {
 			it("should handle the provided event", function() {
 				assert.equal(mockControl._eventHandlers.has(RegisteredEvent), true);
 			});
+
+			it("should share one connect and close listener on the connector", function() {
+				const connector = mockControl.connector;
+				const connectListeners = connector.listenerCount("connect");
+				const closeListeners = connector.listenerCount("close");
+				const subscribers = [
+					new lib.EventSubscriber(StringPermissionEvent, mockControl),
+					new lib.EventSubscriber(FunctionPermissionEvent, mockControl),
+				];
+				assert.equal(subscribers.length, 2);
+				assert.equal(connector.listenerCount("connect"), connectListeners);
+				assert.equal(connector.listenerCount("close"), closeListeners);
+			});
+
+			it("should pass connect and close to every subscriber on the connector", function() {
+				const subscribers = [
+					eventSubscriber,
+					new lib.EventSubscriber(StringPermissionEvent, mockControl),
+					new lib.EventSubscriber(FunctionPermissionEvent, mockControl),
+				];
+				const received = subscribers.map(() => []);
+				subscribers.forEach((subscriber, index) => {
+					subscriber.handleConnectionEvent = event => { received[index].push(event); };
+				});
+				mockControl.connector.emit("close");
+				mockControl.connector.emit("connect");
+				assert.deepEqual(received, [["close", "connect"], ["close", "connect"], ["close", "connect"]]);
+			});
+
+			it("should only pass events to subscribers on the same connector", function() {
+				const otherControl = new MockControl(new MockConnector(
+					addr({ controlId: 1 }),
+					addr("controller"),
+				));
+				const other = new lib.EventSubscriber(RegisteredEvent, otherControl);
+				const received = [];
+				eventSubscriber.handleConnectionEvent = event => { received.push(["first", event]); };
+				other.handleConnectionEvent = event => { received.push(["other", event]); };
+				otherControl.connector.emit("close");
+				assert.deepEqual(received, [["other", "close"]]);
+			});
 		});
 
 		describe("subscribe()", function() {

From 3868efceadf9303e3d4ee664808106fecd0e89a5 Mon Sep 17 00:00:00 2001
From: bbassie <17990055+bbassie@users.noreply.github.com>
Date: Wed, 11 Nov 2026 09:38:11 +0000
Subject: [PATCH 02/11] Focus the mod search inputs when they open

The "Add mods" card on the mod pack view mounts when shown, so autoFocus
is enough there. The Search Mod Portal modal stays mounted after the
first open, so it focuses the name input from afterOpenChange instead.

Fixes #1194

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 packages/web_ui/src/components/ModPackViewPage.tsx | 1 +
 packages/web_ui/src/components/ModsPage.tsx        | 9 ++++++---
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/packages/web_ui/src/components/ModPackViewPage.tsx b/packages/web_ui/src/components/ModPackViewPage.tsx
index 3bd8558f..99cad1d0 100644
--- a/packages/web_ui/src/components/ModPackViewPage.tsx
+++ b/packages/web_ui/src/components/ModPackViewPage.tsx
@@ -182,6 +182,7 @@ function SearchModsTable(props: SearchModsTableProps) {
 
 	return <>
 		<Input
+			autoFocus
 			placeholder="Search Mods"
 			style={{ marginBottom: 8 }}
 			onChange={(event) => {
diff --git a/packages/web_ui/src/components/ModsPage.tsx b/packages/web_ui/src/components/ModsPage.tsx
index 9f22a1a1..731a90a0 100644
--- a/packages/web_ui/src/components/ModsPage.tsx
+++ b/packages/web_ui/src/components/ModsPage.tsx
@@ -1,7 +1,8 @@
-import React, { Fragment, useState, useContext, useEffect, useMemo } from "react";
+import React, { Fragment, useState, useContext, useEffect, useMemo, useRef } from "react";
 import { useNavigate } from "react-router-dom";
 import {
-	Button, Form, Input, Modal, Popconfirm, Space, Table, Typography, Upload, Alert, Select, Tooltip, notification,
+	Button, Form, Input, InputRef, Modal, Popconfirm, Space, Table, Typography, Upload, Alert, Select, Tooltip,
+	notification,
 } from "antd";
 import {
 	ImportOutlined, PlusOutlined, SearchOutlined, DownloadOutlined,
@@ -147,6 +148,7 @@ function SearchModsButton() {
 	const account = useAccount();
 	const [open, setOpen] = useState(false);
 	const [form] = Form.useForm();
+	const nameInputRef = useRef<InputRef>(null);
 	const [searchText, setSearchText] = useState("");
 	const [factorioVersion, setFactorioVersion] = useState<lib.MajorMinorVersion>("2.0");
 
@@ -333,6 +335,7 @@ function SearchModsButton() {
 			title="Search Mod Portal"
 			open={open}
 			onCancel={() => { setOpen(false); }}
+			afterOpenChange={visible => { if (visible) { nameInputRef.current?.focus(); } }}
 			width={1000}
 			footer={[
 				<Button key="close" onClick={() => { setOpen(false); }}>
@@ -349,7 +352,7 @@ function SearchModsButton() {
 				initialValues={{ factorioVersion: factorioVersion, name: searchText }}
 			>
 				<Form.Item name="name" label="Filter by Name or Title">
-					<Input placeholder="Start typing to filter..." />
+					<Input ref={nameInputRef} placeholder="Start typing to filter..." />
 				</Form.Item>
 				<Form.Item
 					name="factorioVersion"

From f86ebb6e66eb1e10d7a3a272c2c5044dbda34f0b Mon Sep 17 00:00:00 2001
From: Danielv123 <danielv@danielv.no>
Date: Wed, 11 Nov 2026 11:22:08 +0100
Subject: [PATCH 03/11] Keep the connector subscribers as a static on
 EventSubscriber

---
 packages/lib/src/subscriptions.ts | 65 ++++++++++++++++---------------
 1 file changed, 34 insertions(+), 31 deletions(-)

diff --git a/packages/lib/src/subscriptions.ts b/packages/lib/src/subscriptions.ts
index e8595fa9..71ba825e 100644
--- a/packages/lib/src/subscriptions.ts
+++ b/packages/lib/src/subscriptions.ts
@@ -455,41 +455,44 @@ export interface SubscribableValue {
 	isDeleted: boolean,
 }
 
-/** Subscribers created on each connector, they share one connect and one close listener on it */
-const connectorSubscribers = new WeakMap<object, Set<EventSubscriber<any, any>>>();
-
-/**
- * Pass connect and close events of a connector on to a subscriber
- * Uses one listener for all subscribers, so that plugins creating many subscribers do not go past the
- * listener limit set on the connector.
- * @param connector - connector of the link the subscriber was created on
- * @param subscriber - subscriber to pass the events to
- */
-function addConnectorSubscriber(connector: WebSocketBaseConnector, subscriber: EventSubscriber<any, any>) {
-	let subscribers = connectorSubscribers.get(connector);
-	if (!subscribers) {
-		const created = new Set<EventSubscriber<any, any>>();
-		connectorSubscribers.set(connector, created);
-		connector.on("connect", () => {
-			for (const entry of created) {
-				entry.handleConnectionEvent("connect");
-			}
-		});
-		connector.on("close", () => {
-			for (const entry of created) {
-				entry.handleConnectionEvent("close");
-			}
-		});
-		subscribers = created;
-	}
-	subscribers.add(subscriber);
-}
-
 /**
  * Component for subscribing to and tracking updates of a remote resource
  * Multiple handlers can be subscribed at the same time
  */
 export class EventSubscriber<E, S = null> {
+	/** Subscribers created on each connector, they share one connect and one close listener on it */
+	private static connectorSubscribers = new WeakMap<object, Set<EventSubscriber<any, any>>>();
+
+	/**
+	 * Pass connect and close events of a connector on to a subscriber
+	 * Uses one listener for all subscribers, so that plugins creating many subscribers do not go past the
+	 * listener limit set on the connector.
+	 * @param connector - connector of the link the subscriber was created on
+	 * @param subscriber - subscriber to pass the events to
+	 */
+	private static addConnectorSubscriber(
+		connector: WebSocketBaseConnector,
+		subscriber: EventSubscriber<any, any>,
+	) {
+		let subscribers = EventSubscriber.connectorSubscribers.get(connector);
+		if (!subscribers) {
+			const created = new Set<EventSubscriber<any, any>>();
+			EventSubscriber.connectorSubscribers.set(connector, created);
+			connector.on("connect", () => {
+				for (const entry of created) {
+					entry.handleConnectionEvent("connect");
+				}
+			});
+			connector.on("close", () => {
+				for (const entry of created) {
+					entry.handleConnectionEvent("close");
+				}
+			});
+			subscribers = created;
+		}
+		subscribers.add(subscriber);
+	}
+
 	/** The time at which an event was last received, is less than 0 when there have been no events */
 	lastUpdatedMs = -1;
 	/** True if this subscriber is currently synced with the source */
@@ -513,7 +516,7 @@ export class EventSubscriber<E, S = null> {
 	) {
 		control.handle(Event, this._handleEvent.bind(this));
 		// The events below exist only on websocket connectors, we can't early return because of test mocking
-		addConnectorSubscriber(control.connector as WebSocketBaseConnector, this);
+		EventSubscriber.addConnectorSubscriber(control.connector as WebSocketBaseConnector, this);
 		// Only the web Control reports account changes
 		const accountControl = control as Link & { onAccountUpdate?: (handler: () => void) => void };
 		if (typeof accountControl.onAccountUpdate === "function") {

From 484cffc13656551df25561c42137ef517154a3b3 Mon Sep 17 00:00:00 2001
From: Bastiaan <17990055+bbassie@users.noreply.github.com>
Date: Wed, 11 Nov 2026 18:37:13 +0100
Subject: [PATCH 04/11] Add controller metrics for WebSocket session events
 (#1199)

Counts ready, resume, drop and session timeout per connection type
(host or control), plus resume attempts rejected for an unknown or
expired session. Lets a dashboard show hosts or users reconnecting.

Fixes #1192

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 packages/controller/src/WsServer.ts          | 43 ++++++++++++++++
 packages/controller/src/WsServerConnector.ts |  7 ++-
 test/controller/WsServer.js                  | 52 ++++++++++++++++++++
 3 files changed, 101 insertions(+), 1 deletion(-)

diff --git a/packages/controller/src/WsServer.ts b/packages/controller/src/WsServer.ts
index 7fcc85b0..3db50248 100644
--- a/packages/controller/src/WsServer.ts
+++ b/packages/controller/src/WsServer.ts
@@ -30,6 +30,42 @@ const wsRejectedConnectionsCounter = new lib.Counter(
 	"How many WebSocket connections have been rejected during the handshake on the controller"
 );
 
+const wsReadyCounter = new lib.Counter(
+	"clusterio_controller_websocket_ready_total",
+	"How many WebSocket sessions have been established on the controller",
+	{ labels: ["type"] }
+);
+
+const wsResumeCounter = new lib.Counter(
+	"clusterio_controller_websocket_resume_total",
+	"How many WebSocket sessions have been resumed on the controller",
+	{ labels: ["type"] }
+);
+
+const wsDropCounter = new lib.Counter(
+	"clusterio_controller_websocket_drop_total",
+	"How many WebSocket sessions have lost their connection without closing on the controller",
+	{ labels: ["type"] }
+);
+
+const wsSessionTimeoutCounter = new lib.Counter(
+	"clusterio_controller_websocket_session_timeout_total",
+	"How many WebSocket sessions have timed out waiting for a resume on the controller",
+	{ labels: ["type"] }
+);
+
+const wsFailedResumeCounter = new lib.Counter(
+	"clusterio_controller_websocket_failed_resume_total",
+	"How many WebSocket resume attempts have been rejected due to an unknown or expired session on the controller"
+);
+
+for (const type of ["host", "control"]) {
+	wsReadyCounter.labels(type);
+	wsResumeCounter.labels(type);
+	wsDropCounter.labels(type);
+	wsSessionTimeoutCounter.labels(type);
+}
+
 /**
  * WebSocket server
  * @alias module:controller/src/WsServer
@@ -240,6 +276,12 @@ ${err.stack}`
 			this.activeConnectors.delete(sessionId);
 		});
 
+		const type = dst.type === lib.Address.host ? "host" : "control";
+		connector.on("connect", () => wsReadyCounter.labels(type).inc());
+		connector.on("resume", () => wsResumeCounter.labels(type).inc());
+		connector.on("drop", () => wsDropCounter.labels(type).inc());
+		connector.on("timeout", () => wsSessionTimeoutCounter.labels(type).inc());
+
 		return [connector, sessionToken];
 	}
 
@@ -367,6 +409,7 @@ ${err.stack}`
 			}
 
 		} catch (err) {
+			wsFailedResumeCounter.inc();
 			socket.send(JSON.stringify(new lib.MessageInvalidate()));
 			this.attachHandler(socket, req);
 			return;
diff --git a/packages/controller/src/WsServerConnector.ts b/packages/controller/src/WsServerConnector.ts
index 3793a651..7b8fcff6 100644
--- a/packages/controller/src/WsServerConnector.ts
+++ b/packages/controller/src/WsServerConnector.ts
@@ -7,13 +7,17 @@ import * as lib from "@clusterio/lib";
 import { logger } from "@clusterio/lib";
 
 
+type WsServerConnectorEvents = {
+	"timeout": [],
+};
+
 /**
  * Connector for controller connections
  *
  * @extends module:lib.WebSocketBaseConnector
  * @alias module:controller/src/WsServerConnector
  */
-export default class WsServerConnector extends lib.WebSocketBaseConnector {
+export default class WsServerConnector extends lib.WebSocketBaseConnector<WsServerConnectorEvents> {
 	_timeoutId: ReturnType<typeof setTimeout> | null = null;
 
 	constructor(
@@ -119,6 +123,7 @@ export default class WsServerConnector extends lib.WebSocketBaseConnector {
 
 	_timedOut() {
 		logger.verbose(`Connector | Connection to ${this.dst} timed out`);
+		this.emit("timeout");
 		this._close();
 	}
 
diff --git a/test/controller/WsServer.js b/test/controller/WsServer.js
index f6fc513f..a7a16f98 100644
--- a/test/controller/WsServer.js
+++ b/test/controller/WsServer.js
@@ -113,6 +113,58 @@ describe("controller/src/WsServer", function() {
 			});
 		});
 	});
+	describe("connection metrics", function() {
+		const req = { socket: { remoteAddress: "10.0.0.1", remoteFamily: "IPv4" }, headers: {} };
+		/** @type {WsServer} */
+		let wsServer;
+		before(function() {
+			const config = new ControllerConfig("controller");
+			config.set("controller.auth_secret", Buffer.from("TestSecretDoNotUse").toString("base64"));
+			wsServer = new Controller(lib.logger, [], config).wsServer;
+		});
+
+		function counter(name) {
+			return lib.defaultRegistry.collectors.find(collector => collector.metric.name === name);
+		}
+		function value(name, type) {
+			const collector = counter(`clusterio_controller_websocket_${name}_total`);
+			return type ? collector.labels(type).get() : collector.get();
+		}
+
+		[["host", lib.Address.host], ["control", lib.Address.control]].forEach(([type, addressType]) => {
+			it(`should count ready, drop, resume and timeout for ${type} sessions`, function() {
+				const before = Object.fromEntries(
+					["ready", "drop", "resume", "session_timeout"].map(name => [name, value(name, type)])
+				);
+				const [connector, sessionToken] = wsServer.createSession(new lib.Address(addressType, 1));
+				connector.ready(new MockWebSocket(), new lib.Address(addressType, 1), sessionToken, undefined);
+				assert.equal(value("ready", type), before.ready + 1);
+
+				connector._socket.terminate();
+				assert.equal(value("drop", type), before.drop + 1);
+
+				wsServer.resumeSession(new lib.ResumeData(sessionToken, 0), new MockWebSocket(), req);
+				assert.equal(value("resume", type), before.resume + 1);
+
+				connector._socket.terminate();
+				connector._timedOut();
+				assert.equal(value("session_timeout", type), before.session_timeout + 1);
+				assert.equal(value("drop", type), before.drop + 2);
+				assert.equal(value("ready", type), before.ready + 1);
+			});
+		});
+		it("should count resumes of unknown sessions as failed", function() {
+			const before = value("failed_resume");
+			const socket = new MockWebSocket();
+			wsServer.resumeSession(new lib.ResumeData("invalid", 0), socket, req);
+			try {
+				assert.equal(value("failed_resume"), before + 1);
+				assert.equal(socket.sent[0].type, "invalidate");
+			} finally {
+				socket.emit("message", "not json"); // ends the handshake and its timeout
+			}
+		});
+	});
 	describe(".registerHost()", function() {
 		const secret = Buffer.from("TestSecretDoNotUse");
 		const req = { socket: { remoteAddress: "10.0.0.1", remoteFamily: "IPv4" }, headers: {} };

From ae707f77689925387576b55b7dc625e37f5aeee2 Mon Sep 17 00:00:00 2001
From: Bastiaan <17990055+bbassie@users.noreply.github.com>
Date: Wed, 11 Nov 2026 18:40:37 +0100
Subject: [PATCH 05/11] Always show the instance player list, collapsed when
 empty (#1197)

The list used to disappear when nobody was online. It is now a Collapse
that opens while players are online and closes when the last one leaves.
Once the user toggles it, their choice sticks for the page.

Fixes #1191

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../src/components/OnlinePlayersList.tsx      | 32 +++++++++++--------
 1 file changed, 18 insertions(+), 14 deletions(-)

diff --git a/packages/web_ui/src/components/OnlinePlayersList.tsx b/packages/web_ui/src/components/OnlinePlayersList.tsx
index 31e5a560..643e1743 100644
--- a/packages/web_ui/src/components/OnlinePlayersList.tsx
+++ b/packages/web_ui/src/components/OnlinePlayersList.tsx
@@ -1,4 +1,5 @@
-import React from "react";
+import React, { useState } from "react";
+import { Collapse } from "antd";
 
 import { useUsers } from "../model/user";
 import UsersTable from "./UsersTable";
@@ -9,23 +10,26 @@ type OnlinePlayersListProps = {
 
 export default function OnlinePlayersList({ instanceId }: OnlinePlayersListProps) {
 	const [users] = useUsers();
+	// undefined until the user toggles the panel, then their choice sticks.
+	const [open, setOpen] = useState<boolean>();
 
-	// Filter users to only show those online on this specific instance
-	const onlineUsers = [...users.values()].filter(user => user.instances && user.instances.has(instanceId));
+	const onlineCount = [...users.values()].filter(user => user.instances?.has(instanceId)).length;
+	const expanded = open ?? onlineCount > 0;
 
-	if (onlineUsers.length === 0) {
-		return null;
-	}
-
-	return (
-		<div style={{ marginTop: 16 }}>
-			<h4>Online Players ({onlineUsers.length})</h4>
-			<UsersTable instanceId={instanceId} onlyOnline size="small" pagination={{
+	return <Collapse
+		size="small"
+		style={{ marginTop: 16 }}
+		activeKey={expanded ? ["players"] : []}
+		onChange={keys => setOpen(keys.length > 0)}
+		items={[{
+			key: "players",
+			label: `Online Players (${onlineCount})`,
+			children: <UsersTable instanceId={instanceId} onlyOnline size="small" pagination={{
 				defaultPageSize: 10,
 				showSizeChanger: true,
 				pageSizeOptions: ["10", "20", "50", "100", "200"],
 				showTotal: (total: number) => `${total} Users`,
-			}} />
-		</div>
-	);
+			}} />,
+		}]}
+	/>;
 }

From 381d1d85735a9fdae2468dfc6d1ddc1bee6b7d80 Mon Sep 17 00:00:00 2001
From: Bastiaan <17990055+bbassie@users.noreply.github.com>
Date: Wed, 11 Nov 2026 18:42:16 +0100
Subject: [PATCH 06/11] Show online player count on the instance list (#1196)

Counts users per instance from the shared users subscription, the same
data the instance page's online players list reads, so the table adds
no per-row requests. The column is sortable and hidden without
core.user.subscribe.

Fixes #1193

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../web_ui/src/components/InstanceList.tsx    | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/packages/web_ui/src/components/InstanceList.tsx b/packages/web_ui/src/components/InstanceList.tsx
index bd54f153..0dc5baee 100644
--- a/packages/web_ui/src/components/InstanceList.tsx
+++ b/packages/web_ui/src/components/InstanceList.tsx
@@ -7,6 +7,7 @@ import type { ColumnType } from "antd/es/table/interface";
 import { useAccount } from "../model/account";
 import { useSystems } from "../model/system";
 import { useHosts } from "../model/host";
+import { useUsers } from "../model/user";
 import { useDefaultModPack, useModPacks } from "../model/mod_pack";
 import { RestartRequired } from "./system_metrics";
 import InstanceStatusTag from "./InstanceStatusTag";
@@ -33,6 +34,17 @@ export default function InstanceList(props: InstanceListProps) {
 	const [systems] = useSystems();
 	const [modPacks] = useModPacks();
 	const defaultModPack = useDefaultModPack();
+	const [users] = useUsers();
+	const canUsers = account.hasPermission("core.user.subscribe");
+	const onlineCounts = React.useMemo(() => {
+		const counts = new Map<number, number>();
+		for (const user of users.values()) {
+			for (const instanceId of user.instances ?? []) {
+				counts.set(instanceId, (counts.get(instanceId) ?? 0) + 1);
+			}
+		}
+		return counts;
+	}, [users]);
 	const tableState = useTableQueryState<lib.InstanceDetails>({
 		namespace: "instance", defaultSortKey: "name",
 	});
@@ -146,6 +158,18 @@ export default function InstanceList(props: InstanceListProps) {
 		},
 	];
 
+	if (canUsers) {
+		const playerCount = (instance: lib.InstanceDetails) => onlineCounts.get(instance.id) ?? 0;
+		columns.push({
+			title: "Players",
+			key: "players",
+			render: (_, instance) => playerCount(instance),
+			sorter: (a, b) => playerCount(a) - playerCount(b),
+			sortOrder: tableState.sortOrder("players"),
+			responsive: ["md"],
+		});
+	}
+
 	if (account.hasAnyPermission(...InstanceControlButtonPermissions)) {
 		columns.push({
 			key: "action",

From e2185e92696384fbb781004aa39559a1d72dccb5 Mon Sep 17 00:00:00 2001
From: Bastiaan <17990055+bbassie@users.noreply.github.com>
Date: Wed, 11 Nov 2026 18:43:35 +0100
Subject: [PATCH 07/11] Detect Steam's Factorio install on macOS in the
 installer (#1195)

Steam on macOS puts Factorio in ~/Library/Application Support/Steam/steamapps/common/Factorio, with the app bundle inside it. Point at factorio.app/Contents like the existing /Applications entry, since that's where data/ lives and the host finds MacOS/factorio next to it.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 packages/create/create.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/packages/create/create.js b/packages/create/create.js
index d5d91505..512dc389 100755
--- a/packages/create/create.js
+++ b/packages/create/create.js
@@ -46,6 +46,10 @@ const factorioLocations = {
 	],
 	darwin: [
 		"/Applications/factorio.app/Contents",
+		path.join(
+			os.homedir(), "Library", "Application Support", "Steam", "steamapps", "common", "Factorio",
+			"factorio.app", "Contents",
+		),
 	],
 };
 

From b781731eccf8359b65406ac2531f04b70a7dd3ba Mon Sep 17 00:00:00 2001
From: ILLISIS <jayson.harris01@gmail.com>
Date: Fri, 13 Nov 2026 22:14:46 +1100
Subject: [PATCH 08/11] Sync the page shown on each quick bar row

player_sync restored the content of the quick bar slots but not which
page each row shows, which every save keeps per player on its own. After
switching servers the rows could show other pages, and with them another
set of slots.

Fixes #1201

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01JyNnVzRW4jPWaoWTxCyhM7
---
 plugins/player_sync/README.md            |  2 +-
 plugins/player_sync/components.ts        |  2 +-
 plugins/player_sync/messages.ts          |  2 ++
 plugins/player_sync/module/serialize.lua | 27 ++++++++++++++++++++++++
 plugins/player_sync/test/plugin.js       |  3 +++
 5 files changed, 34 insertions(+), 2 deletions(-)

diff --git a/plugins/player_sync/README.md b/plugins/player_sync/README.md
index 5f7c16c3..c44c2706 100644
--- a/plugins/player_sync/README.md
+++ b/plugins/player_sync/README.md
@@ -166,7 +166,7 @@ Defaults to `true`.
 
 ### player_sync.sync_quick_bar
 
-Sync the quick bar.
+Sync the quick bar and the page shown on each of its rows.
 
 Defaults to `true`.
 
diff --git a/plugins/player_sync/components.ts b/plugins/player_sync/components.ts
index 1e1c1b03..133e039f 100644
--- a/plugins/player_sync/components.ts
+++ b/plugins/player_sync/components.ts
@@ -9,7 +9,7 @@ export const components = {
 	// inventories holds the god inventory and the hidden ghost inventory
 	inventories: ["character", "crafting_queue", "inventories"],
 	logistics: ["personal_logistic_slots"],
-	quick_bar: ["quick_bar", "hotbar"],
+	quick_bar: ["quick_bar", "quick_bar_pages", "hotbar"],
 	settings: ["flashlight", "shortcuts", "game_view_settings"],
 	recipe_notifications: ["recipe_notifications"],
 } as const;
diff --git a/plugins/player_sync/messages.ts b/plugins/player_sync/messages.ts
index 5a92591d..a3a1ce9b 100644
--- a/plugins/player_sync/messages.ts
+++ b/plugins/player_sync/messages.ts
@@ -23,6 +23,7 @@ export type IpcPlayerData = {
 	character?: any,
 	inventories?: any,
 	quick_bar?: any,
+	quick_bar_pages?: number[],
 	hotbar?: Record<string, string>,
 	personal_logistic_slots?: any,
 	crafting_queue?: any,
@@ -181,6 +182,7 @@ const jsonImportedPlayerData = Type.Object({
 	character: Type.Optional(jsonCharacter),
 	inventories: Type.Optional(jsonInventories),
 	quick_bar: Type.Optional(Type.Record(Type.String(), jsonQuickBarSlot)),
+	quick_bar_pages: Type.Optional(Type.Array(Type.Integer({ minimum: 1, maximum: 10 }), { maxItems: 10 })),
 	hotbar: Type.Optional(Type.Record(Type.String(), Type.String())),
 	personal_logistic_slots: Type.Optional(jsonPersonalLogisticSlots),
 	crafting_queue: Type.Optional(jsonCraftingQueue),
diff --git a/plugins/player_sync/module/serialize.lua b/plugins/player_sync/module/serialize.lua
index 7a79d9ed..df6dec79 100644
--- a/plugins/player_sync/module/serialize.lua
+++ b/plugins/player_sync/module/serialize.lua
@@ -713,6 +713,30 @@ function serialize.deserialize_quick_bar(player, serialized)
 	end
 end
 
+--- Quick bar page shown on each quick bar row of the screen, kept by every save on its own
+--- @param player LuaPlayer
+--- @return integer[]?
+function serialize.serialize_quick_bar_pages(player)
+	local pages = {}
+	for screen = 1, 10 do
+		-- pcall: the number of rows the API knows is not documented for older versions
+		local ok, page = pcall(player.get_active_quick_bar_page, screen)
+		if not ok or not page then
+			break
+		end
+		pages[screen] = page
+	end
+	return pages[1] and pages or nil
+end
+
+--- @param player LuaPlayer
+--- @param pages integer[]? Absent in data from before pages were synced, the rows then stay as they are here
+function serialize.deserialize_quick_bar_pages(player, pages)
+	for screen, page in ipairs(pages or {}) do
+		player.set_active_quick_bar_page(screen, page)
+	end
+end
+
 -- Crafting queue is a table with the following fields:
 --  crafting_queue
 --  ingredients
@@ -974,6 +998,7 @@ end
 --- @field inventories table<string, table>?
 --- @field hotbar table<string, string>?
 --- @field quick_bar table<string, QuickBarSlotEncoded>?
+--- @field quick_bar_pages integer[]? Page shown on each quick bar row
 --- @field personal_logistic_slots table?
 --- @field crafting_queue table?
 --- @field recipe_notifications string?
@@ -1178,6 +1203,7 @@ function serialize.serialize_player(player, failed_deserialization, components)
 	-- Serialize quick bar
 	if syncs(components, "quick_bar") then
 		serialized.quick_bar = serialize.serialize_quick_bar(player)
+		serialized.quick_bar_pages = serialize.serialize_quick_bar_pages(player)
 	end
 
 	-- Serialize crafting queue
@@ -1444,6 +1470,7 @@ function serialize.deserialize_player(player, serialized, components, local_cont
 	-- Deserialize quick bar (named hotbar in old data)
 	if syncs(components, "quick_bar") then
 		serialize.deserialize_quick_bar(player, serialized.quick_bar or serialized.hotbar)
+		serialize.deserialize_quick_bar_pages(player, serialized.quick_bar_pages)
 	end
 
 	-- Deserialize recipe notifications
diff --git a/plugins/player_sync/test/plugin.js b/plugins/player_sync/test/plugin.js
index 77516d93..2bc67904 100644
--- a/plugins/player_sync/test/plugin.js
+++ b/plugins/player_sync/test/plugin.js
@@ -117,6 +117,7 @@ describe("player_sync plugin", function() {
 					3: { t: "i", n: "main", s: 4, b: [2] },
 					4: { t: "r", p: [1], y: "blueprint" },
 				},
+				quick_bar_pages: [2, 1, 3],
 				crafting_queue: {
 					crafting_queue: [{ recipe: "iron-gear-wheel", count: 5 }],
 					crafting_queue_progress: 0.25,
@@ -172,6 +173,8 @@ describe("player_sync plugin", function() {
 					["quick_bar", { 1: { t: "i", n: "main" } }],
 					["quick_bar", { 1: { t: "r", y: "blueprint" } }],
 					["quick_bar", { 1: 5 }],
+					["quick_bar_pages", [0]],
+					["quick_bar_pages", [11]],
 					["personal_logistic_slots", { enabled: true, sections: [] }],
 					["personal_logistic_slots", { enabled: true, trash_not_requested: false, sections: [{}] }],
 					["personal_logistic_slots", { 1: { min: 50 } }],

From e37bf31cd3900f77e68a2441aeb2c2a10cc73c80 Mon Sep 17 00:00:00 2001
From: Bastiaan <17990055+bbassie@users.noreply.github.com>
Date: Fri, 13 Nov 2026 20:30:24 +0100
Subject: [PATCH 09/11] Merge pull request #1200 from
 bbassie/feature/log-retention

Delete log files older than a configurable number of days
---
 docs/configuration.md                  | 19 ++++++
 packages/controller/controller.ts      |  5 ++
 packages/host/host.ts                  |  5 ++
 packages/lib/src/config/definitions.ts | 16 +++++
 packages/lib/src/logging_utils.ts      | 83 +++++++++++++++++++++++++-
 test/lib/logging_utils.js              | 50 ++++++++++++++++
 6 files changed, 177 insertions(+), 1 deletion(-)

diff --git a/docs/configuration.md b/docs/configuration.md
index 803e51f8..2bc2e221 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -48,6 +48,16 @@ Must be greater than 0.
 Defaults to 60.
 
 
+### controller.log_retention_days
+
+Number of days to keep the controller and cluster log files in the log directory for.
+Log files are named by the UTC date they were written and a file is deleted once its date is more than this many days in the past.
+Old files are checked for on startup and every hour after that.
+Set to 0 to keep logs forever.
+
+Defaults to 30.
+
+
 ### controller.host_pairing_timeout
 
 Time in seconds a host can wait for approval before its request expires, after which the host requests again with a new code.
@@ -436,6 +446,15 @@ Must be greater than 0.
 Defaults to 60.
 
 
+### host.log_retention_days
+
+Number of days to keep the host log files in the log directory for.
+Works the same way as controller.log_retention_days.
+Set to 0 to keep logs forever.
+
+Defaults to 30.
+
+
 ### host.allow_remote_updates
 
 Whether the `host update` command in clusterioctl and the update button in the web interface are allowed to update the `@clusterio/host` package with npm.
diff --git a/packages/controller/controller.ts b/packages/controller/controller.ts
index 29334ed4..cd1364a1 100644
--- a/packages/controller/controller.ts
+++ b/packages/controller/controller.ts
@@ -492,6 +492,11 @@ async function startup() {
 		controller.stop();
 	});
 
+	lib.startLogRetention(
+		[path.join(args.logDirectory, "cluster"), path.join(args.logDirectory, "controller")],
+		() => controllerConfig.get("controller.log_retention_days"),
+	);
+
 	await controller.start(args);
 }
 
diff --git a/packages/host/host.ts b/packages/host/host.ts
index a5302b70..a250ab06 100755
--- a/packages/host/host.ts
+++ b/packages/host/host.ts
@@ -210,6 +210,11 @@ async function startHost() {
 	// From this point on the host should run
 	await hostConfigLock.acquire();
 
+	lib.startLogRetention(
+		[path.join(args.logDirectory, "host")],
+		() => hostConfig.get("host.log_retention_days"),
+	);
+
 	// If we get here the command was run
 	await fs.mkdir(hostConfig.get("host.instances_directory"), { recursive: true });
 	await fs.mkdir(hostConfig.get("host.mods_directory"), { recursive: true });
diff --git a/packages/lib/src/config/definitions.ts b/packages/lib/src/config/definitions.ts
index 5fd9e64f..ecea3400 100644
--- a/packages/lib/src/config/definitions.ts
+++ b/packages/lib/src/config/definitions.ts
@@ -37,6 +37,7 @@ export interface ControllerConfigFields {
 	"controller.default_mod_pack_id": number | null;
 	"controller.default_role_id": number | null;
 	"controller.autosave_interval": number;
+	"controller.log_retention_days": number;
 	"controller.host_pairing_timeout": number;
 	"controller.host_pairing_max_pending": number;
 	"controller.mod_portal_cache_duration_minutes": number;
@@ -100,6 +101,13 @@ export class ControllerConfig extends classes.Config<ControllerConfigFields> {
 			initialValue: 60,
 			validator: validators.greaterThanZero,
 		},
+		"controller.log_retention_days": {
+			title: "Log Retention Days",
+			description: "Days to keep controller and cluster log files for, 0 to keep them forever.",
+			type: "number",
+			initialValue: 30,
+			validator: validators.all(validators.integer, validators.greaterThanEqualZero),
+		},
 		"controller.host_pairing_timeout": {
 			title: "Host Pairing Timeout",
 			description: "Time in seconds a host can wait for approval before it has to request again, 0 for no limit.",
@@ -349,6 +357,7 @@ export interface HostConfigFields {
 	"host.factorio_username": string | null,
 	"host.factorio_token": string | null,
 	"host.max_reconnect_delay": number;
+	"host.log_retention_days": number;
 	"host.allow_remote_updates": boolean;
 	"host.allow_plugin_updates": boolean;
 	"host.allow_plugin_install": boolean;
@@ -458,6 +467,13 @@ export class HostConfig extends classes.Config<HostConfigFields> {
 			initialValue: 60,
 			validator: validators.greaterThanZero,
 		},
+		"host.log_retention_days": {
+			title: "Log Retention Days",
+			description: "Days to keep host log files for, 0 to keep them forever.",
+			type: "number",
+			initialValue: 30,
+			validator: validators.all(validators.integer, validators.greaterThanEqualZero),
+		},
 		"host.allow_remote_updates": {
 			description: "When true, allows a remote event to trigger a clusterio update via npm",
 			type: "boolean",
diff --git a/packages/lib/src/logging_utils.ts b/packages/lib/src/logging_utils.ts
index ab235182..ea062c96 100644
--- a/packages/lib/src/logging_utils.ts
+++ b/packages/lib/src/logging_utils.ts
@@ -358,8 +358,15 @@ export class LogIndex {
 	 */
 	async buildIndex() {
 		let today = new Date(Date.now() - 300e3).toISOString().slice(0, 10);
+		let files = await fs.readdir(this.logDirectory);
 
-		for (let file of await fs.readdir(this.logDirectory)) {
+		for (let file of this.index.keys()) {
+			if (!files.includes(file)) {
+				this.index.delete(file);
+			}
+		}
+
+		for (let file of files) {
 			let match = logFileGlob.exec(file);
 			if (!match || match[1] >= today || this.index.has(file)) {
 				continue;
@@ -412,6 +419,80 @@ export class LogIndex {
 	}
 }
 
+/**
+ * Delete dated log files older than the given number of days
+ *
+ * Only files named like name-YYYY-MM-DD.log are deleted, and only once
+ * every entry they can hold is older than retentionDays.
+ *
+ * @param logDirectory - Directory to delete log files from.
+ * @param retentionDays - Days to keep log files for, 0 keeps them forever.
+ * @param now - Current time in milliseconds since the epoch.
+ * @returns names of the deleted files.
+ */
+export async function deleteOldLogs(logDirectory: string, retentionDays: number, now = Date.now()) {
+	if (!(retentionDays > 0)) {
+		return [];
+	}
+
+	let files: string[];
+	try {
+		files = await fs.readdir(logDirectory);
+	} catch (err: any) {
+		if (err.code === "ENOENT") {
+			return [];
+		}
+		throw err;
+	}
+
+	const cutoff = new Date(now - retentionDays * 86400e3).toISOString().slice(0, 10);
+	const deleted: string[] = [];
+	for (const file of files) {
+		const match = logFileGlob.exec(file);
+		if (!match || match[1] >= cutoff) {
+			continue;
+		}
+		try {
+			await fs.unlink(path.join(logDirectory, file));
+		} catch (err: any) {
+			if (err.code !== "ENOENT") {
+				throw err;
+			}
+		}
+		deleted.push(file);
+	}
+	return deleted;
+}
+
+/**
+ * Delete old logs now and then every hour
+ *
+ * @param logDirectories - Directories to delete old log files from.
+ * @param getRetentionDays - Called before each run to get the retention.
+ * @returns the interval timer, which does not keep the process alive.
+ */
+export function startLogRetention(logDirectories: string[], getRetentionDays: () => number) {
+	async function run() {
+		const retentionDays = getRetentionDays();
+		for (const logDirectory of logDirectories) {
+			try {
+				const deleted = await deleteOldLogs(logDirectory, retentionDays);
+				if (deleted.length) {
+					logger.info(
+						`Deleted ${deleted.length} log files older than ${retentionDays} days from ${logDirectory}`
+					);
+				}
+			} catch (err: any) {
+				logger.error(`Failed to delete old logs from ${logDirectory}:\n${err.stack}`);
+			}
+		}
+	}
+	run();
+	const interval = setInterval(run, 3600e3);
+	interval.unref();
+	return interval;
+}
+
 /**
  * Filter object for querying logs
  */
diff --git a/test/lib/logging_utils.js b/test/lib/logging_utils.js
index 054e49e4..b8dab0b9 100644
--- a/test/lib/logging_utils.js
+++ b/test/lib/logging_utils.js
@@ -45,6 +45,19 @@ describe("lib/logging_utils.js", function() {
 				logIndex
 			);
 		});
+		it("should drop entries for files no longer present", async function() {
+			let tempDir = path.join("temp", "test", "log_index_prune");
+			await fs.rm(tempDir, { recursive: true, force: true });
+			await fs.cp(logDir, tempDir, { recursive: true });
+			let logIndex = await lib.LogIndex.load(tempDir);
+			await logIndex.buildIndex();
+			await fs.unlink(path.join(tempDir, "test-2021-12-10.log"));
+			await logIndex.buildIndex();
+			assert.deepEqual(
+				new Set(logIndex.index.keys()),
+				new Set(["test-2021-12-11.log", "test-2021-12-12.log"])
+			);
+		});
 		it("should handle loading broken index", async function() {
 			let tempDir = path.join("temp", "test", "log");
 			await fs.writeFile(path.join(tempDir, "index.json"), "Broken JSON");
@@ -53,6 +66,43 @@ describe("lib/logging_utils.js", function() {
 		});
 	});
 
+	describe("deleteOldLogs", function() {
+		let tempDir = path.join("temp", "test", "log_retention");
+		let files = [
+			"cluster-2026-10-01.log",
+			"cluster-2026-10-12.log",
+			"cluster-2026-10-13.log",
+			"cluster-2026-11-12.log",
+			"index.json",
+			"notes-2026-10-01.txt",
+			".0123abcd-audit.json",
+		];
+		let now = Date.parse("2026-11-12T08:00:00Z");
+		beforeEach(async function() {
+			await fs.rm(tempDir, { recursive: true, force: true });
+			await fs.mkdir(tempDir, { recursive: true });
+			for (let file of files) {
+				await fs.writeFile(path.join(tempDir, file), "");
+			}
+		});
+
+		it("should delete only dated log files past the retention", async function() {
+			let deleted = await lib.deleteOldLogs(tempDir, 30, now);
+			assert.deepEqual(deleted.sort(), ["cluster-2026-10-01.log", "cluster-2026-10-12.log"]);
+			assert.deepEqual(
+				(await fs.readdir(tempDir)).sort(),
+				files.filter(file => !deleted.includes(file)).sort(),
+			);
+		});
+		it("should keep everything with a retention of 0", async function() {
+			assert.deepEqual(await lib.deleteOldLogs(tempDir, 0, now), []);
+			assert.deepEqual((await fs.readdir(tempDir)).sort(), [...files].sort());
+		});
+		it("should ignore a missing directory", async function() {
+			assert.deepEqual(await lib.deleteOldLogs(path.join(tempDir, "missing"), 30, now), []);
+		});
+	});
+
 	let allLines = [];
 	let logIndex = null;
 	before(async function() {

From e32367dc0b6cc3e0e47f4956551d4147256cf4e7 Mon Sep 17 00:00:00 2001
From: Daniel <danielv@danielv.no>
Date: Fri, 13 Nov 2026 22:36:52 +0100
Subject: [PATCH 10/11] Create the character at spawn when it can't be made in
 place (#1189)

* Create the character at spawn when it can't be made in place

create_character needs a free spot within 200 tiles and does not
generate chunks to find one, so it failed for a player teleported into
a chunk that does not exist yet, and where there is only water or void.
The download then failed and left the player as a spectator.

Resolves #1187

* Cast player position to MapPosition.struct for the lint
---
 plugins/player_sync/module/serialize.lua | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/plugins/player_sync/module/serialize.lua b/plugins/player_sync/module/serialize.lua
index cab17c6d..71087c39 100644
--- a/plugins/player_sync/module/serialize.lua
+++ b/plugins/player_sync/module/serialize.lua
@@ -1271,8 +1271,23 @@ local function ensure_character(player)
 		player.teleport(force.get_spawn_position(planet_surface), planet_surface)
 	end
 
-	-- Create and return the character
+	-- create_character needs a free spot within 200 tiles and does not generate chunks to find one. It fails in a chunk
+	-- which does not exist yet, such as one the player was teleported into a moment ago, and where water or void is all
+	-- there is. The character is then made at the force's spawn. From a missing chunk it is moved back, as the game
+	-- generates the chunks around a character. Otherwise there is nowhere to stand, and it stays at the spawn.
 	if not player.create_character() then
+		surface = player.surface
+		local position = player.position --[[@as MapPosition.struct]]
+		local force = player.force --[[@as LuaForce]]
+		local missing_chunk = not surface.is_chunk_generated({ math.floor(position.x / 32), math.floor(position.y / 32) })
+		player.teleport(force.get_spawn_position(surface), surface)
+		if player.create_character() and missing_chunk then
+			player.teleport(position, surface)
+		end
+	end
+
+	-- Return the character
+	if not player.character then
 		error(string.format(
 			"Failed to create character (controller: %s, physical: %s, surface: %s, connected: %s, driving: %s)",
 			controller_to_name[player.controller_type],

From 87bdbd520f4049310d300b2ed261c072a4d59c64 Mon Sep 17 00:00:00 2001
From: Danielv123 <danielv@danielv.no>
Date: Fri, 13 Nov 2026 22:49:12 +0100
Subject: [PATCH 11/11] Sync every quick bar slot when the pages are wider than
 10

From Factorio 2.1 a quick bar page is as wide as the player set it, up to
100 slots. Only the first 100 slots were synced, so with wider pages the
later pages kept the content of the destination, and restoring the page
shown on a row could show those.
---
 plugins/player_sync/module/serialize.lua | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/plugins/player_sync/module/serialize.lua b/plugins/player_sync/module/serialize.lua
index df6dec79..88d22b23 100644
--- a/plugins/player_sync/module/serialize.lua
+++ b/plugins/player_sync/module/serialize.lua
@@ -662,13 +662,20 @@ function serialize.deserialize_quick_bar_slot(entry, player)
 	return entry --[[@as string]]
 end
 
+--- Slots over all 10 quick bar pages, a page is as wide as the player set it from 2.1 and 10 slots before
+--- @param player LuaPlayer
+--- @return integer
+local function quick_bar_slot_count(player)
+	return 10 * (v2_1_quick_bar_api and player.quick_bar_width or 10)
+end
+
 --- @param player LuaPlayer
 --- @return table<string, QuickBarSlotEncoded>?
 function serialize.serialize_quick_bar(player)
 	local serialized
 	local width = v2_1_quick_bar_api and player.quick_bar_width
 
-	for i = 1, 100 do
+	for i = 1, quick_bar_slot_count(player) do
 		local slot
 
 		if v2_1_quick_bar_api then
@@ -699,7 +706,7 @@ function serialize.deserialize_quick_bar(player, serialized)
 	-- previous server does not come back from this server's old copy
 	serialized = serialized or {}
 	local width = v2_1_quick_bar_api and player.quick_bar_width
-	for i = 1, 100 do
+	for i = 1, quick_bar_slot_count(player) do
 		local entry = serialized[tostring(i)]
 		local slot = entry ~= nil and serialize.deserialize_quick_bar_slot(entry, player) or nil
 		if v2_1_quick_bar_api then