incanto 0.51.0 → 0.52.0

package/dist/split-screen-CZ9ccBBQ.js

@@ -0,0 +1,1267 @@
+import { C as diagnose, M as Signal, f as Node, n as loadScene, t as buildNodeJson } from "./loader-B-Gft32x.js";
+import { h as Engine, t as registerCoreNodes } from "./register-DVwlnZAZ.js";
+import { t as IncantoError } from "./errors-BpWbnbb_.js";
+import { n as jsonEquals, t as jsonClone } from "./json-BLk7H2Qa.js";
+import { l as registerNode } from "./registry-C7u42TID.js";
+//#region src/net/loopback.ts
+/**
+* In-memory multiplayer hub implementing the SAME kernel contract as
+* `templates/agent8-server.js` — local split-screen demos, offline development,
+* and headless tests run real multi-client flows without any infrastructure.
+*/
+var LoopbackHub = class {
+	rooms = /* @__PURE__ */ new Map();
+	accountSeq = 0;
+	roomSeq = 0;
+	entitySeq = 0;
+	/** Per-room listener registries, keyed by roomId. */
+	listeners = {
+		roomState: /* @__PURE__ */ new Map(),
+		allUsers: /* @__PURE__ */ new Map(),
+		myState: /* @__PURE__ */ new Map(),
+		collection: /* @__PURE__ */ new Map(),
+		message: /* @__PURE__ */ new Map(),
+		join: /* @__PURE__ */ new Map(),
+		leave: /* @__PURE__ */ new Map()
+	};
+	createClient(account) {
+		this.accountSeq += 1;
+		return new LoopbackTransport(this, account ?? `user${this.accountSeq}`);
+	}
+	/** @internal */
+	_room(roomId) {
+		let room = this.rooms.get(roomId);
+		if (!room) {
+			room = {
+				users: /* @__PURE__ */ new Map(),
+				state: {},
+				collections: /* @__PURE__ */ new Map()
+			};
+			this.rooms.set(roomId, room);
+		}
+		return room;
+	}
+	/** @internal The server.js kernel, in memory. */
+	_call(account, fn, args) {
+		switch (fn) {
+			case "joinRoom": {
+				const roomId = args[0] ?? `room${++this.roomSeq}`;
+				this._room(roomId).users.set(account, {});
+				this.fire(this.listeners.join.get(roomId), account);
+				this.fireAllUsers(roomId);
+				return roomId;
+			}
+			case "leaveRoom": {
+				const roomId = args[0];
+				this._room(roomId).users.delete(account);
+				this.fire(this.listeners.leave.get(roomId), account);
+				this.fireAllUsers(roomId);
+				return true;
+			}
+			case "setMyState": {
+				const [roomId, patch] = args;
+				const room = this._room(roomId);
+				const prev = room.users.get(account) ?? {};
+				room.users.set(account, {
+					...prev,
+					...jsonClone(patch)
+				});
+				for (const entry of this.listeners.myState.get(roomId) ?? []) if (entry.account === account) entry.cb(jsonClone(room.users.get(account) ?? {}));
+				this.fireAllUsers(roomId);
+				return true;
+			}
+			case "patchRoomState": {
+				const [roomId, patch] = args;
+				const room = this._room(roomId);
+				room.state = {
+					...room.state,
+					...jsonClone(patch)
+				};
+				this.fire(this.listeners.roomState.get(roomId), jsonClone(room.state));
+				return true;
+			}
+			case "addEntity": {
+				const [roomId, collectionId, entity] = args;
+				const room = this._room(roomId);
+				let coll = room.collections.get(collectionId);
+				if (!coll) {
+					coll = /* @__PURE__ */ new Map();
+					room.collections.set(collectionId, coll);
+				}
+				const id = entity.__id ?? `e${++this.entitySeq}`;
+				coll.set(id, {
+					...jsonClone(entity),
+					__id: id
+				});
+				this.fireCollection(roomId, collectionId);
+				return id;
+			}
+			case "updateEntity": {
+				const [roomId, collectionId, id, patch] = args;
+				const coll = this._room(roomId).collections.get(collectionId);
+				const prev = coll?.get(id);
+				if (coll && prev) {
+					coll.set(id, {
+						...prev,
+						...jsonClone(patch),
+						__id: id
+					});
+					this.fireCollection(roomId, collectionId);
+				}
+				return true;
+			}
+			case "removeEntity": {
+				const [roomId, collectionId, id] = args;
+				this._room(roomId).collections.get(collectionId)?.delete(id);
+				this.fireCollection(roomId, collectionId);
+				return true;
+			}
+			case "sendEvent": {
+				const [roomId, type, payload] = args;
+				for (const entry of this.listeners.message.get(roomId) ?? []) if (entry.type === type) entry.cb(jsonClone(payload));
+				return true;
+			}
+			default: throw new IncantoError("BAD_FORMAT", `Loopback kernel has no remote function '${fn}'. Available: joinRoom, leaveRoom, setMyState, patchRoomState, addEntity, updateEntity, removeEntity, sendEvent.`);
+		}
+	}
+	/** @internal */
+	_subscribe(kind, roomId, entry) {
+		const registry = this.listeners[kind];
+		let set = registry.get(roomId);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			registry.set(roomId, set);
+		}
+		set.add(entry);
+		return () => set?.delete(entry);
+	}
+	/** @internal */
+	_snapshotUsers(roomId) {
+		return Object.fromEntries([...this._room(roomId).users.entries()].map(([a, s]) => [a, jsonClone(s)]));
+	}
+	/** @internal */
+	_snapshotCollection(roomId, collectionId) {
+		const coll = this._room(roomId).collections.get(collectionId);
+		return coll ? Object.fromEntries([...coll.entries()].map(([i, e]) => [i, jsonClone(e)])) : {};
+	}
+	/** @internal */
+	_snapshotRoomState(roomId) {
+		return jsonClone(this._room(roomId).state);
+	}
+	fire(set, value) {
+		for (const cb of set ?? []) cb(value);
+	}
+	fireAllUsers(roomId) {
+		const snapshot = this._snapshotUsers(roomId);
+		for (const cb of this.listeners.allUsers.get(roomId) ?? []) cb(snapshot);
+	}
+	fireCollection(roomId, collectionId) {
+		const snapshot = this._snapshotCollection(roomId, collectionId);
+		for (const entry of this.listeners.collection.get(roomId) ?? []) if (entry.id === collectionId) entry.cb(snapshot);
+	}
+};
+/** A client on a LoopbackHub. Subscriptions fire immediately with a snapshot. */
+var LoopbackTransport = class {
+	hub;
+	account;
+	connected = false;
+	constructor(hub, account) {
+		this.hub = hub;
+		this.account = account;
+	}
+	connect() {
+		this.connected = true;
+		return Promise.resolve(true);
+	}
+	disconnect() {
+		this.connected = false;
+		return Promise.resolve();
+	}
+	remoteFunction(fn, args = []) {
+		return Promise.resolve(this.hub._call(this.account, fn, args));
+	}
+	subscribeRoomState(roomId, cb) {
+		const off = this.hub._subscribe("roomState", roomId, cb);
+		cb(this.hub._snapshotRoomState(roomId));
+		return off;
+	}
+	subscribeRoomMyState(roomId, cb) {
+		const off = this.hub._subscribe("myState", roomId, {
+			account: this.account,
+			cb
+		});
+		cb(jsonClone(this.hub._room(roomId).users.get(this.account) ?? {}));
+		return off;
+	}
+	subscribeRoomAllUserStates(roomId, cb) {
+		const off = this.hub._subscribe("allUsers", roomId, cb);
+		cb(this.hub._snapshotUsers(roomId));
+		return off;
+	}
+	subscribeRoomCollection(roomId, collectionId, cb) {
+		const off = this.hub._subscribe("collection", roomId, {
+			id: collectionId,
+			cb
+		});
+		cb(this.hub._snapshotCollection(roomId, collectionId));
+		return off;
+	}
+	onRoomMessage(roomId, type, cb) {
+		return this.hub._subscribe("message", roomId, {
+			type,
+			cb
+		});
+	}
+	onRoomUserJoin(roomId, cb) {
+		return this.hub._subscribe("join", roomId, cb);
+	}
+	onRoomUserLeave(roomId, cb) {
+		return this.hub._subscribe("leave", roomId, cb);
+	}
+};
+//#endregion
+//#region src/net/local-game-server.ts
+/**
+* Run a multiplayer game's REAL agent8-sdk-v2 `Server` class **locally**, in
+* memory, with NO cloud and NO auth — the preview/dev path.
+*
+* `LoopbackHub` answers only the fixed built-in room protocol (joinRoom,
+* setMyState, collections, events). Real games add server-AUTHORITATIVE rules
+* (`awardPoint`, `castSpell`, `$roomTick` match clocks) in `server/src/server.ts`
+* against the v2 contexts `$sender`/`$global`/`$room`/`$lock`. LocalGameServer
+* runs that exact class body so the whole game — client + server logic — is
+* playable in dev before it ever touches the Agent8 platform. Swap
+* `local.createClient(account)` for `await createAgent8Server()` to go live;
+* nothing else changes.
+*
+* How it stays faithful to the isolated-vm platform:
+* - A FRESH `Server` instance runs per request, so `this.*` never persists.
+* - The v2 globals are injected on `globalThis` for the duration of each call
+*   (the SAME `server/src/server.ts` body that reads bare `$room`/`$sender`
+*   runs unmodified).
+* - Calls are SERIALIZED through one queue, so a global binding can't leak across
+*   another request's `await`s (the platform isolates per request; we serialize).
+* - `$roomTick(deltaMS, roomId)` runs only while a room has users — drive it from
+*   the engine: `engine.updated.connect((dt) => local.tick(dt * 1000))`.
+*
+* NOT a substitute for the cloud: no isolated-vm sandboxing, no persistence, no
+* rate limits — a faithful FUNCTIONAL emulator for local play and tests.
+*/
+var LocalGameServer = class {
+	hub = new LoopbackHub();
+	serverClass;
+	/** Each client's current room — binds `$sender.roomId` on later calls. */
+	clientRooms = /* @__PURE__ */ new Map();
+	/** All remoteFunction/tick calls run one-at-a-time so injected globals never overlap. */
+	queue = Promise.resolve();
+	/** Per-key mutex backing `$lock`. */
+	locks = /* @__PURE__ */ new Map();
+	/** Persistent (process-lifetime) store backing the `$global` + `$asset` contexts. */
+	g_state = {};
+	g_userStates = /* @__PURE__ */ new Map();
+	g_collections = /* @__PURE__ */ new Map();
+	g_assets = /* @__PURE__ */ new Map();
+	g_seq = 0;
+	/** Client-side global/asset subscription registries (fanned out on mutation). */
+	subState = /* @__PURE__ */ new Set();
+	subUser = /* @__PURE__ */ new Map();
+	subColl = /* @__PURE__ */ new Map();
+	subAsset = /* @__PURE__ */ new Map();
+	subMsg = /* @__PURE__ */ new Map();
+	constructor(serverClass) {
+		this.serverClass = serverClass;
+	}
+	/** A client on this server. Distinct `account` per player (default auto-assigned). */
+	createClient(account) {
+		return new LocalGameServerTransport(this, this.hub.createClient(account));
+	}
+	collectionSnapshot(id) {
+		const c = this.g_collections.get(id);
+		return c ? Object.fromEntries([...c.entries()].map(([k, v]) => [k, jsonClone(v)])) : {};
+	}
+	assetSnapshot(acct) {
+		return Object.fromEntries(this.g_assets.get(acct) ?? []);
+	}
+	/** @internal */
+	subscribeGlobalState(cb) {
+		this.subState.add(cb);
+		cb(jsonClone(this.g_state));
+		return () => this.subState.delete(cb);
+	}
+	/** @internal */
+	subscribeGlobalUserState(account, cb) {
+		const off = addToSetMap(this.subUser, account, cb);
+		cb(jsonClone(this.g_userStates.get(account) ?? {}));
+		return off;
+	}
+	/** @internal */
+	subscribeGlobalCollection(id, cb) {
+		const off = addToSetMap(this.subColl, id, cb);
+		cb(this.collectionSnapshot(id));
+		return off;
+	}
+	/** @internal */
+	subscribeAsset(account, cb) {
+		const off = addToSetMap(this.subAsset, account, cb);
+		cb(this.assetSnapshot(account));
+		return off;
+	}
+	/** @internal Messages are events — no immediate snapshot. */
+	onGlobalMessage(account, type, cb) {
+		const entry = {
+			account,
+			cb
+		};
+		return addToSetMap(this.subMsg, type, entry);
+	}
+	fireState() {
+		const s = jsonClone(this.g_state);
+		for (const cb of [...this.subState]) cb(s);
+	}
+	fireUser(account) {
+		const s = jsonClone(this.g_userStates.get(account) ?? {});
+		for (const cb of [...this.subUser.get(account) ?? []]) cb(s);
+	}
+	fireColl(id) {
+		const r = this.collectionSnapshot(id);
+		for (const cb of [...this.subColl.get(id) ?? []]) cb(r);
+	}
+	fireAsset(account) {
+		const w = this.assetSnapshot(account);
+		for (const cb of [...this.subAsset.get(account) ?? []]) cb(w);
+	}
+	fireMsg(type, message, target) {
+		for (const e of [...this.subMsg.get(type) ?? []]) if (!target || e.account === target) e.cb(jsonClone(message));
+	}
+	/**
+	* Advance server-driven periodic logic. Calls the `Server`'s `$roomTick(deltaMS,
+	* roomId)` once per room that currently has users. No-op without a `$roomTick`.
+	*/
+	tick(deltaMS) {
+		return this.enqueue(() => this.runTick(deltaMS));
+	}
+	/** @internal Dispatch a remoteFunction (serialized). */
+	call(account, fn, args) {
+		return this.enqueue(() => this.dispatch(account, fn, args));
+	}
+	enqueue(run) {
+		const result = this.queue.then(run, run);
+		this.queue = result.then(() => void 0, () => void 0);
+		return result;
+	}
+	async dispatch(account, fn, args) {
+		const server = this.serverClass ? new this.serverClass() : null;
+		const method = server && typeof server[fn] === "function" ? server[fn] : null;
+		const roomId = fn === "joinRoom" ? void 0 : this.clientRooms.get(account) ?? args[0];
+		let out;
+		if (method && server) {
+			const restore = this.bindGlobals(account, roomId);
+			try {
+				out = await method.apply(server, args);
+			} finally {
+				restore();
+			}
+		} else out = this.hub._call(account, fn, args);
+		if (fn === "joinRoom" && typeof out === "string") this.clientRooms.set(account, out);
+		else if (fn === "leaveRoom") this.clientRooms.delete(account);
+		return out;
+	}
+	async runTick(deltaMS) {
+		if (!this.serverClass) return;
+		if (typeof new this.serverClass().$roomTick !== "function") return;
+		for (const roomId of new Set(this.clientRooms.values())) {
+			const server = new this.serverClass();
+			const restore = this.bindGlobals("", roomId);
+			try {
+				await server.$roomTick.call(server, deltaMS, roomId);
+			} finally {
+				restore();
+			}
+		}
+	}
+	/** Install the v2 globals for one dispatch; returns a restorer. */
+	bindGlobals(account, roomId) {
+		const g = globalThis;
+		const prev = {
+			$sender: g.$sender,
+			$global: g.$global,
+			$room: g.$room,
+			$lock: g.$lock,
+			$asset: g.$asset
+		};
+		g.$sender = {
+			account,
+			roomId: roomId ?? ""
+		};
+		g.$global = this.globalContext(account);
+		g.$room = this.roomContext(account, roomId);
+		g.$asset = this.assetContext(account);
+		g.$lock = (key, fn) => this.withLock(key, fn);
+		return () => {
+			g.$sender = prev.$sender;
+			g.$global = prev.$global;
+			g.$room = prev.$room;
+			g.$lock = prev.$lock;
+			g.$asset = prev.$asset;
+		};
+	}
+	/**
+	* The `$global` context — room membership, persistent GLOBAL state/user-state/
+	* collections, room management, and global messaging. Backed by an in-memory
+	* store that survives between requests (unlike rooms, which the hub clears when
+	* empty) — matching the platform's persistent-global / ephemeral-room split.
+	*/
+	globalContext(account) {
+		const hub = this.hub;
+		const coll = (id) => {
+			let c = this.g_collections.get(id);
+			if (!c) {
+				c = /* @__PURE__ */ new Map();
+				this.g_collections.set(id, c);
+			}
+			return c;
+		};
+		const userState = (acct) => this.g_userStates.get(acct) ?? {};
+		return {
+			joinRoom: (rid) => Promise.resolve(hub._call(account, "joinRoom", [rid])),
+			leaveRoom: () => {
+				const left = this.clientRooms.get(account) ?? "";
+				hub._call(account, "leaveRoom", [left]);
+				return Promise.resolve(left);
+			},
+			getGlobalState: () => Promise.resolve(jsonClone(this.g_state)),
+			updateGlobalState: (patch) => {
+				Object.assign(this.g_state, jsonClone(patch));
+				this.fireState();
+				return Promise.resolve(jsonClone(this.g_state));
+			},
+			getUserState: (acct) => Promise.resolve(jsonClone(userState(acct))),
+			updateUserState: (acct, patch) => {
+				const next = {
+					...userState(acct),
+					...jsonClone(patch)
+				};
+				this.g_userStates.set(acct, next);
+				this.fireUser(acct);
+				return Promise.resolve(jsonClone(next));
+			},
+			getMyState: () => Promise.resolve(jsonClone(userState(account))),
+			updateMyState: (patch) => {
+				const next = {
+					...userState(account),
+					...jsonClone(patch)
+				};
+				this.g_userStates.set(account, next);
+				this.fireUser(account);
+				return Promise.resolve(jsonClone(next));
+			},
+			addCollectionItem: (id, item) => {
+				const __id = item.__id ?? `g${++this.g_seq}`;
+				const stored = {
+					...jsonClone(item),
+					__id
+				};
+				coll(id).set(__id, stored);
+				this.fireColl(id);
+				return Promise.resolve(jsonClone(stored));
+			},
+			updateCollectionItem: (id, item) => {
+				const { __id, ...patch } = item;
+				const c = coll(id);
+				const next = {
+					...c.get(__id) ?? {},
+					...jsonClone(patch),
+					__id
+				};
+				c.set(__id, next);
+				this.fireColl(id);
+				return Promise.resolve(jsonClone(next));
+			},
+			deleteCollectionItem: (id, itemId) => {
+				coll(id).delete(itemId);
+				this.fireColl(id);
+				return Promise.resolve({ __id: itemId });
+			},
+			deleteCollection: (id) => {
+				this.g_collections.delete(id);
+				this.fireColl(id);
+				return Promise.resolve(id);
+			},
+			getCollectionItem: (id, itemId) => Promise.resolve(jsonClone(coll(id).get(itemId) ?? {})),
+			getCollectionItems: (id, options) => Promise.resolve(queryItems([...coll(id).values()].map(jsonClone), options)),
+			countCollectionItems: (id, options) => Promise.resolve(queryItems([...coll(id).values()].map(jsonClone), options).length),
+			countRooms: () => Promise.resolve(new Set(this.clientRooms.values()).size),
+			getAllRoomIds: () => Promise.resolve([...new Set(this.clientRooms.values())]),
+			getAllRoomStates: () => Promise.resolve([...new Set(this.clientRooms.values())].map((r) => roomStateWithDefaults(hub, r))),
+			getRoomUserAccounts: (rid) => Promise.resolve(Object.keys(hub._snapshotUsers(rid))),
+			countRoomUsers: (rid) => Promise.resolve(Object.keys(hub._snapshotUsers(rid)).length),
+			getRoomState: (rid) => Promise.resolve(roomStateWithDefaults(hub, rid)),
+			updateRoomState: (rid, patch) => {
+				hub._call(account, "patchRoomState", [rid, patch]);
+				return Promise.resolve(roomStateWithDefaults(hub, rid));
+			},
+			getRoomUserState: (rid, acct) => Promise.resolve(hub._snapshotUsers(rid)[acct] ?? {}),
+			updateRoomUserState: (rid, acct, patch) => {
+				hub._call(acct, "setMyState", [rid, patch]);
+				return Promise.resolve(hub._snapshotUsers(rid)[acct] ?? {});
+			},
+			broadcastToAll: (type, message) => {
+				this.fireMsg(type, message);
+			},
+			sendMessageToUser: (type, acct, message) => {
+				this.fireMsg(type, message, acct);
+			}
+		};
+	}
+	/**
+	* The `$asset` context — a per-account currency ledger. `burn`/`transfer` throw
+	* on an insufficient balance (the documented pattern always checks `has` first),
+	* surfacing economy bugs in preview just as the platform would.
+	*/
+	assetContext(account) {
+		const wallet = (acct) => {
+			let w = this.g_assets.get(acct);
+			if (!w) {
+				w = /* @__PURE__ */ new Map();
+				this.g_assets.set(acct, w);
+			}
+			return w;
+		};
+		const all = (acct) => Object.fromEntries(wallet(acct));
+		return {
+			get: (assetId) => Promise.resolve(wallet(account).get(assetId) ?? 0),
+			getAll: () => Promise.resolve(all(account)),
+			has: (assetId, amount) => Promise.resolve((wallet(account).get(assetId) ?? 0) >= amount),
+			mint: (assetId, amount) => {
+				requireAmount("mint", amount);
+				wallet(account).set(assetId, (wallet(account).get(assetId) ?? 0) + amount);
+				this.fireAsset(account);
+				return Promise.resolve(all(account));
+			},
+			burn: (assetId, amount) => {
+				requireAmount("burn", amount);
+				const have = wallet(account).get(assetId) ?? 0;
+				if (have < amount) throw new IncantoError("BAD_FORMAT", `$asset.burn: insufficient '${assetId}' for ${account} (have ${have}, need ${amount}). Guard with $asset.has first.`);
+				wallet(account).set(assetId, have - amount);
+				this.fireAsset(account);
+				return Promise.resolve(all(account));
+			},
+			transfer: (toAccount, assetId, amount) => {
+				requireAmount("transfer", amount);
+				const have = wallet(account).get(assetId) ?? 0;
+				if (have < amount) throw new IncantoError("BAD_FORMAT", `$asset.transfer: insufficient '${assetId}' for ${account} (have ${have}, need ${amount}).`);
+				wallet(account).set(assetId, have - amount);
+				wallet(toAccount).set(assetId, (wallet(toAccount).get(assetId) ?? 0) + amount);
+				this.fireAsset(account);
+				this.fireAsset(toAccount);
+				return Promise.resolve(all(account));
+			}
+		};
+	}
+	/** The `$room` context, bound to one room — maps onto the hub's kernel primitives. */
+	roomContext(account, roomId) {
+		const rid = () => {
+			if (!roomId) throw new IncantoError("BAD_FORMAT", "$room used outside a room — joinRoom must resolve a room before $room is touched.");
+			return roomId;
+		};
+		const hub = this.hub;
+		return {
+			updateMyState: (patch) => Promise.resolve(hub._call(account, "setMyState", [rid(), patch])).then(() => hub._snapshotUsers(rid())[account] ?? {}),
+			updateRoomState: (patch) => Promise.resolve(hub._call(account, "patchRoomState", [rid(), patch])).then(() => hub._snapshotRoomState(rid())),
+			updateUserState: (acct, patch) => Promise.resolve(hub._call(acct, "setMyState", [rid(), patch])).then(() => hub._snapshotUsers(rid())[acct] ?? {}),
+			getUserState: (acct) => Promise.resolve(hub._snapshotUsers(rid())[acct] ?? {}),
+			getMyState: () => Promise.resolve(hub._snapshotUsers(rid())[account] ?? {}),
+			getRoomState: () => Promise.resolve(roomStateWithDefaults(hub, rid())),
+			getAllUserStates: () => Promise.resolve(Object.entries(hub._snapshotUsers(rid())).map(([acct, state]) => ({
+				...state,
+				account: acct
+			}))),
+			countUsers: () => Promise.resolve(Object.keys(hub._snapshotUsers(rid())).length),
+			addCollectionItem: (coll, item) => {
+				const id = hub._call(account, "addEntity", [
+					rid(),
+					coll,
+					item
+				]);
+				return Promise.resolve(hub._snapshotCollection(rid(), coll)[id] ?? { __id: id });
+			},
+			updateCollectionItem: (coll, item) => {
+				const { __id, ...patch } = item;
+				hub._call(account, "updateEntity", [
+					rid(),
+					coll,
+					__id,
+					patch
+				]);
+				return Promise.resolve(hub._snapshotCollection(rid(), coll)[__id] ?? { __id });
+			},
+			deleteCollectionItem: (coll, itemId) => {
+				hub._call(account, "removeEntity", [
+					rid(),
+					coll,
+					itemId
+				]);
+				return Promise.resolve({ __id: itemId });
+			},
+			deleteCollection: (coll) => {
+				for (const id of Object.keys(hub._snapshotCollection(rid(), coll))) hub._call(account, "removeEntity", [
+					rid(),
+					coll,
+					id
+				]);
+				return Promise.resolve(coll);
+			},
+			getCollectionItem: (coll, itemId) => Promise.resolve(hub._snapshotCollection(rid(), coll)[itemId] ?? {}),
+			getCollectionItems: (coll, options) => Promise.resolve(queryItems(Object.values(hub._snapshotCollection(rid(), coll)), options)),
+			countCollectionItems: (coll, options) => Promise.resolve(queryItems(Object.values(hub._snapshotCollection(rid(), coll)), options).length),
+			broadcastToRoom: (type, message) => {
+				hub._call(account, "sendEvent", [
+					rid(),
+					type,
+					message
+				]);
+			},
+			sendMessageToUser: (_type, _acct, _message) => {}
+		};
+	}
+	withLock(key, fn) {
+		const run = (this.locks.get(key) ?? Promise.resolve()).then(() => fn());
+		this.locks.set(key, run.then(() => void 0, () => void 0));
+		return run;
+	}
+};
+/** Add a value to a Map-of-Sets registry; returns an unsubscribe that removes it. */
+function addToSetMap(map, key, value) {
+	let set = map.get(key);
+	if (!set) {
+		set = /* @__PURE__ */ new Set();
+		map.set(key, set);
+	}
+	set.add(value);
+	return () => {
+		set?.delete(value);
+	};
+}
+/** A room state snapshot with the platform-maintained `roomId` + `$users` defaults. */
+function roomStateWithDefaults(hub, roomId) {
+	return {
+		...hub._snapshotRoomState(roomId),
+		roomId,
+		$users: Object.keys(hub._snapshotUsers(roomId))
+	};
+}
+/** Throw unless `amount` is a non-negative finite number (matches the platform; the
+* preview must NOT be more lenient — a negative burn would otherwise ADD currency). */
+function requireAmount(op, amount) {
+	if (typeof amount !== "number" || !Number.isFinite(amount) || amount < 0) throw new IncantoError("BAD_FORMAT", `$asset.${op}: amount must be a non-negative finite number (got ${amount}).`);
+}
+/** Compare two JSON-ish scalars for ordering. Numbers numerically, else by string. */
+function cmp(a, b) {
+	if (typeof a === "number" && typeof b === "number") return a - b;
+	const sa = String(a);
+	const sb = String(b);
+	return sa < sb ? -1 : sa > sb ? 1 : 0;
+}
+function jsonEq(a, b) {
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+function matchFilter(fieldVal, op, value) {
+	switch (op) {
+		case "<": return cmp(fieldVal, value) < 0;
+		case "<=": return cmp(fieldVal, value) <= 0;
+		case ">": return cmp(fieldVal, value) > 0;
+		case ">=": return cmp(fieldVal, value) >= 0;
+		case "==": return jsonEq(fieldVal, value);
+		case "!=": return !jsonEq(fieldVal, value);
+		case "array-contains": return Array.isArray(fieldVal) && fieldVal.some((v) => jsonEq(v, value));
+		case "in": return Array.isArray(value) && value.some((v) => jsonEq(v, fieldVal));
+		case "not-in": return Array.isArray(value) && !value.some((v) => jsonEq(v, fieldVal));
+		case "array-contains-any": return Array.isArray(fieldVal) && Array.isArray(value) && fieldVal.some((v) => value.some((w) => jsonEq(v, w)));
+		default: throw new IncantoError("BAD_FORMAT", `Unknown collection filter operator '${op}'.`);
+	}
+}
+/** Apply CollectionOptions to a list of items (preview emulation of the platform query). */
+function queryItems(items, options) {
+	if (!options) return items;
+	const { filters, orderBy, limit, startAfter, endBefore } = options;
+	if (filters?.length && orderBy?.length) throw new IncantoError("BAD_FORMAT", "CollectionOptions cannot combine filters and orderBy (the platform requires a composite index). Use one or the other.");
+	let out = items;
+	if (filters?.length) out = out.filter((it) => filters.every((f) => matchFilter(it[f.field], f.operator, f.value)));
+	const ob = orderBy?.[0];
+	if (ob) {
+		const { field } = ob;
+		const dir = ob.direction === "desc" ? -1 : 1;
+		out = [...out].sort((a, b) => cmp(a[field], b[field]) * dir);
+		if (startAfter !== void 0) out = out.filter((it) => cmp(it[field], startAfter) * dir > 0);
+		if (endBefore !== void 0) out = out.filter((it) => cmp(it[field], endBefore) * dir < 0);
+	}
+	if (typeof limit === "number") out = out.slice(0, limit);
+	return out;
+}
+/** Construct a local preview server. With no `server`, it equals a raw LoopbackHub. */
+function createLocalGameServer(opts = {}) {
+	return new LocalGameServer(opts.server);
+}
+/**
+* A client of a {@link LocalGameServer}. Subscriptions read the shared in-memory
+* store directly (same fan-out as Loopback); `remoteFunction` routes through the
+* server's serialized dispatch so the game's `Server` class actually runs.
+*/
+var LocalGameServerTransport = class {
+	server;
+	loop;
+	account;
+	connected = false;
+	constructor(server, loop) {
+		this.server = server;
+		this.loop = loop;
+		this.account = loop.account;
+	}
+	async connect() {
+		this.connected = true;
+		await this.loop.connect();
+		return true;
+	}
+	async disconnect() {
+		this.connected = false;
+		await this.loop.disconnect();
+	}
+	remoteFunction(fn, args = []) {
+		return this.server.call(this.account, fn, args);
+	}
+	subscribeRoomState(roomId, cb) {
+		return this.loop.subscribeRoomState(roomId, cb);
+	}
+	subscribeRoomMyState(roomId, cb) {
+		return this.loop.subscribeRoomMyState(roomId, cb);
+	}
+	subscribeRoomAllUserStates(roomId, cb) {
+		return this.loop.subscribeRoomAllUserStates(roomId, cb);
+	}
+	subscribeRoomCollection(roomId, collectionId, cb) {
+		return this.loop.subscribeRoomCollection(roomId, collectionId, cb);
+	}
+	onRoomMessage(roomId, type, cb) {
+		return this.loop.onRoomMessage(roomId, type, cb);
+	}
+	onRoomUserJoin(roomId, cb) {
+		return this.loop.onRoomUserJoin(roomId, cb);
+	}
+	onRoomUserLeave(roomId, cb) {
+		return this.loop.onRoomUserLeave(roomId, cb);
+	}
+	subscribeGlobalState(cb) {
+		return this.server.subscribeGlobalState(cb);
+	}
+	subscribeGlobalMyState(cb) {
+		return this.server.subscribeGlobalUserState(this.account, cb);
+	}
+	subscribeGlobalUserState(account, cb) {
+		return this.server.subscribeGlobalUserState(account, cb);
+	}
+	subscribeGlobalCollection(collectionId, cb) {
+		return this.server.subscribeGlobalCollection(collectionId, cb);
+	}
+	subscribeAsset(account, cb) {
+		return this.server.subscribeAsset(account, cb);
+	}
+	onGlobalMessage(type, cb) {
+		return this.server.onGlobalMessage(this.account, type, cb);
+	}
+};
+//#endregion
+//#region src/net/network-manager.ts
+const managers = /* @__PURE__ */ new WeakMap();
+/**
+* Per-engine multiplayer hub: joins a room, exposes the room channels as core
+* Signals, replicates `network: {mode:'owner'}` node props on a throttle
+* window, and resolves registered scenes for NetworkSpawner.
+*/
+var NetworkManager = class NetworkManager {
+	account;
+	roomId;
+	roomState = new Signal();
+	allUserStates = new Signal();
+	userJoined = new Signal();
+	userLeft = new Signal();
+	/**
+	* GLOBAL (cross-room, persistent) channels — populated only when the transport
+	* supports them (`LocalGameServer`, the agent8 adapter). On a transport without a
+	* global tier they stay empty / never fire.
+	*/
+	globalState = new Signal();
+	globalMyState = new Signal();
+	/** The local account's `$asset` ledger. */
+	asset = new Signal();
+	/** Latest snapshots for polling consumers (NetworkSpawner). */
+	latestUserStates = {};
+	latestRoomState = {};
+	latestGlobalState = {};
+	latestGlobalMyState = {};
+	latestAsset = {};
+	server;
+	engine;
+	throttleMs;
+	subs = [];
+	messageSignals = /* @__PURE__ */ new Map();
+	collectionSignals = /* @__PURE__ */ new Map();
+	latestCollections = /* @__PURE__ */ new Map();
+	globalMessageSignals = /* @__PURE__ */ new Map();
+	globalCollectionSignals = /* @__PURE__ */ new Map();
+	latestGlobalCollections = /* @__PURE__ */ new Map();
+	scenes = /* @__PURE__ */ new Map();
+	lastSent = /* @__PURE__ */ new Map();
+	sendAccumulator = 0;
+	detachReplication = null;
+	lastOwner = null;
+	boundScene = null;
+	static get(engine) {
+		return managers.get(engine) ?? null;
+	}
+	static async create(engine, opts = {}) {
+		await managers.get(engine)?.dispose();
+		const server = opts.transport ?? await createDefaultTransport(opts.config);
+		await server.connect();
+		const requested = opts.room ?? engine.scene?.multiplayer?.room ?? "auto";
+		const manager = new NetworkManager(engine, server, await server.remoteFunction("joinRoom", [requested === "auto" ? void 0 : requested], { needResponse: true }), opts.throttleMs ?? 50);
+		managers.set(engine, manager);
+		return manager;
+	}
+	constructor(engine, server, roomId, throttleMs) {
+		this.engine = engine;
+		this.server = server;
+		this.roomId = roomId;
+		this.account = server.account;
+		this.throttleMs = Math.max(30, throttleMs);
+		this.boundScene = engine.scene;
+		this.subs.push(server.subscribeRoomState(roomId, (state) => {
+			this.latestRoomState = state;
+			this.roomState.emit(state);
+		}), server.subscribeRoomAllUserStates(roomId, (states) => {
+			this.latestUserStates = states;
+			this.allUserStates.emit(states);
+		}), server.onRoomUserJoin(roomId, (account) => this.userJoined.emit(account)), server.onRoomUserLeave(roomId, (account) => this.userLeft.emit(account)));
+		if (server.subscribeGlobalState) this.subs.push(server.subscribeGlobalState((state) => {
+			this.latestGlobalState = state;
+			this.globalState.emit(state);
+		}));
+		if (server.subscribeGlobalMyState) this.subs.push(server.subscribeGlobalMyState((state) => {
+			this.latestGlobalMyState = state;
+			this.globalMyState.emit(state);
+		}));
+		if (server.subscribeAsset) this.subs.push(server.subscribeAsset(this.account, (assets) => {
+			this.latestAsset = assets;
+			this.asset.emit(assets);
+		}));
+		this.detachReplication = engine.fixedUpdated.connect((dt) => this.replicate(dt));
+	}
+	/** Signal for a typed room message (`sendEvent` on any client). */
+	message(type) {
+		let sig = this.messageSignals.get(type);
+		if (!sig) {
+			sig = new Signal();
+			this.messageSignals.set(type, sig);
+			this.subs.push(this.server.onRoomMessage(this.roomId, type, (m) => sig?.emit(m)));
+		}
+		return sig;
+	}
+	/** Signal + snapshot for a room collection (spawned entities). */
+	collection(id) {
+		let sig = this.collectionSignals.get(id);
+		if (!sig) {
+			sig = new Signal();
+			this.collectionSignals.set(id, sig);
+			this.subs.push(this.server.subscribeRoomCollection(this.roomId, id, (entities) => {
+				this.latestCollections.set(id, entities);
+				sig?.emit(entities);
+			}));
+		}
+		return sig;
+	}
+	latestCollection(id) {
+		this.collection(id);
+		return this.latestCollections.get(id) ?? {};
+	}
+	/** Signal for a typed GLOBAL message (`$global.broadcastToAll`/`sendMessageToUser`). */
+	globalMessage(type) {
+		let sig = this.globalMessageSignals.get(type);
+		if (!sig) {
+			sig = new Signal();
+			this.globalMessageSignals.set(type, sig);
+			const sub = this.server.onGlobalMessage?.(type, (m) => sig?.emit(m));
+			if (sub) this.subs.push(sub);
+		}
+		return sig;
+	}
+	/** Signal + snapshot for a GLOBAL collection (persistent, cross-room). */
+	globalCollection(id) {
+		let sig = this.globalCollectionSignals.get(id);
+		if (!sig) {
+			sig = new Signal();
+			this.globalCollectionSignals.set(id, sig);
+			const sub = this.server.subscribeGlobalCollection?.(id, (entities) => {
+				this.latestGlobalCollections.set(id, entities);
+				sig?.emit(entities);
+			});
+			if (sub) this.subs.push(sub);
+		}
+		return sig;
+	}
+	latestGlobalCollection(id) {
+		this.globalCollection(id);
+		return this.latestGlobalCollections.get(id) ?? {};
+	}
+	setMyState(patch) {
+		return this.server.remoteFunction("setMyState", [this.roomId, patch], {
+			throttle: this.throttleMs,
+			throttleKey: "incanto:myState"
+		});
+	}
+	patchRoomState(patch) {
+		return this.server.remoteFunction("patchRoomState", [this.roomId, patch]);
+	}
+	addEntity(collectionId, entity) {
+		return this.server.remoteFunction("addEntity", [
+			this.roomId,
+			collectionId,
+			entity
+		]);
+	}
+	updateEntity(collectionId, id, patch) {
+		return this.server.remoteFunction("updateEntity", [
+			this.roomId,
+			collectionId,
+			id,
+			patch
+		]);
+	}
+	removeEntity(collectionId, id) {
+		return this.server.remoteFunction("removeEntity", [
+			this.roomId,
+			collectionId,
+			id
+		]);
+	}
+	sendEvent(type, payload) {
+		return this.server.remoteFunction("sendEvent", [
+			this.roomId,
+			type,
+			payload
+		]);
+	}
+	/**
+	* Invoke a CUSTOM server-authoritative function — a method you added to your
+	* `server/src/server.ts` `Server` class (run live on the Agent8 platform, or
+	* locally via `createLocalGameServer`). The room id is prepended automatically,
+	* matching the `(roomId, …)` shape every server method takes:
+	*
+	*   `manager.call('claimCoin', coinId)` → server `claimCoin(roomId, coinId)`
+	*
+	* Returns the function's result (use it for server-validated outcomes — a
+	* rejected claim, a rolled value). This is THE entry point for game rules the
+	* client must not be trusted to compute.
+	*/
+	call(fn, ...args) {
+		return this.server.remoteFunction(fn, [this.roomId, ...args], { needResponse: true });
+	}
+	/** Register a scene for NetworkSpawner (`"scene": "<key>"`). */
+	/**
+	* `json` is `unknown` for the reason `createGame2D.scene` is: an imported
+	* `.scene.json` does not satisfy `SceneJson` (`format: number` vs `1`), and
+	* the loader validates it properly anyway.
+	*/
+	registerScene(key, json) {
+		this.scenes.set(key, json);
+	}
+	resolveScene(key) {
+		const json = this.scenes.get(key);
+		if (!json) throw new IncantoError("UNRESOLVED_INSTANCE", `No scene registered for '${key}'. Registered: [${[...this.scenes.keys()].join(", ")}]. Call manager.registerScene('${key}', sceneJson).`);
+		return json;
+	}
+	async dispose() {
+		this.detachReplication?.();
+		for (const off of this.subs) off();
+		await this.server.remoteFunction("leaveRoom", [this.roomId]);
+		managers.delete(this.engine);
+	}
+	replicate(dt) {
+		const scene = this.engine.scene;
+		if (!scene || scene !== this.boundScene) return;
+		this.sendAccumulator += dt * 1e3;
+		const owner = findOwnerNode(scene.root, true);
+		if (!owner) return;
+		if (owner !== this.lastOwner) {
+			this.lastOwner = owner;
+			this.lastSent.clear();
+		}
+		const net = owner.network;
+		const window = Math.max(30, typeof net.throttleMs === "number" ? net.throttleMs : this.throttleMs);
+		const syncKeys = Array.isArray(net.sync) ? net.sync : [];
+		const patch = {};
+		for (const key of syncKeys) {
+			const value = readSyncKey(owner, key);
+			if (value === void 0) continue;
+			if (!jsonEquals(this.lastSent.get(key) ?? null, value)) patch[key] = jsonClone(value);
+		}
+		if (this.sendAccumulator < window) return;
+		if (Object.keys(patch).length === 0) return;
+		for (const [key, value] of Object.entries(patch)) this.lastSent.set(key, jsonClone(value));
+		this.sendAccumulator = 0;
+		this.setMyState({ sync: patch });
+	}
+};
+function findOwnerNode(node, enforceSingle = false) {
+	const owners = [];
+	collectOwners(node, owners);
+	if (enforceSingle && owners.length > 1) throw new IncantoError("BAD_FORMAT", `Multiple network owner nodes found (${owners.map((o) => o.getPath()).join(", ")}). Exactly ONE node per player may declare network.mode 'owner' — replicate spawned entities through collections instead.`);
+	return owners[0] ?? null;
+}
+function collectOwners(node, out) {
+	if (node.network?.mode === "owner") out.push(node);
+	for (const c of node.children) collectOwners(c, out);
+}
+/** `'position'` → own prop; `'Sprite.animation'` → child path + prop (last dot splits). */
+function readSyncKey(node, key) {
+	const lastDot = key.lastIndexOf(".");
+	const target = lastDot === -1 ? node : node.getNodeOrNull(key.slice(0, lastDot)) ?? void 0;
+	const prop = lastDot === -1 ? key : key.slice(lastDot + 1);
+	if (!target) return void 0;
+	return target[prop];
+}
+/**
+* @internal Applies a replicated flat sync patch (`{'position': …,
+* 'Sprite.animation': …}`) onto a spawned subtree (NetworkSpawner).
+*/
+function applySyncPatch(root, patch, setProp, onMissingNode) {
+	for (const [key, value] of Object.entries(patch)) {
+		const lastDot = key.lastIndexOf(".");
+		const target = lastDot === -1 ? root : root.getNodeOrNull(key.slice(0, lastDot));
+		const prop = lastDot === -1 ? key : key.slice(lastDot + 1);
+		if (target) setProp(target, prop, value);
+		else onMissingNode?.(key);
+	}
+}
+async function createDefaultTransport(config) {
+	const { createAgent8Server } = await import("./agent8-CvsfVskX.js").then((n) => n.t);
+	return createAgent8Server(config);
+}
+//#endregion
+//#region src/net/nodes/network-spawner.ts
+/** Platform bookkeeping the game never replicates. */
+const RESERVED_KEYS = new Set([
+	"__id",
+	"__roomId",
+	"__updated",
+	"__leaved",
+	"account",
+	"roomId"
+]);
+/**
+* Materializes a registered scene per remote player or collection entity:
+*
+* - `source: 'users'` — one instance per OTHER account in the room
+*   (self is skipped; the local player is your own owned node)
+* - `source: 'collection:<id>'` — one instance per entity (bullets, pickups…)
+*
+* Replicated flat `{sync: {...}}` patches apply onto each instance's root;
+* `position` lerps toward its target when `interpolate` is on. Emits
+* `spawned(node, key)` / `despawned(node, key)`.
+*/
+var NetworkSpawner = class extends Node {
+	static typeName = "NetworkSpawner";
+	static signals = ["spawned", "despawned"];
+	static props = {
+		source: { default: "users" },
+		scene: { default: "" },
+		interpolate: { default: true }
+	};
+	source = "users";
+	/** Key registered via `manager.registerScene(key, json)`. */
+	scene = "";
+	interpolate = true;
+	spawned = /* @__PURE__ */ new Map();
+	positionTargets = /* @__PURE__ */ new Map();
+	failedKeys = /* @__PURE__ */ new Set();
+	reported = /* @__PURE__ */ new Set();
+	update(dt) {
+		const engine = this.tree?.engine;
+		if (!engine) return;
+		const manager = NetworkManager.get(engine);
+		if (!manager || this.scene === "") return;
+		const entries = this.currentEntries(manager);
+		for (const [key, state] of Object.entries(entries)) {
+			let instance = this.spawned.get(key);
+			if (!instance) {
+				if (this.failedKeys.has(key)) continue;
+				try {
+					instance = buildNodeJson(manager.resolveScene(this.scene).root);
+				} catch (error) {
+					this.failedKeys.add(key);
+					throw error;
+				}
+				instance.name = sanitizeName(key);
+				this.addChild(instance);
+				this.spawned.set(key, instance);
+				this.emit("spawned", instance, key);
+			}
+			const patch = this.patchOf(state);
+			if (patch) applySyncPatch(instance, patch, (target, prop, value) => this.setProp(target, prop, value), (missing) => this.report(`'${missing}' names a node this scene does not have`));
+		}
+		for (const [key, instance] of [...this.spawned.entries()]) if (!(key in entries)) {
+			this.spawned.delete(key);
+			this.positionTargets.delete(instance);
+			this.emit("despawned", instance, key);
+			instance.free();
+		}
+		if (this.interpolate) this.stepInterpolation(dt);
+	}
+	currentEntries(manager) {
+		if (this.source === "users") {
+			const out = {};
+			for (const [account, state] of Object.entries(manager.latestUserStates)) if (account !== manager.account) out[account] = state;
+			return out;
+		}
+		if (this.source.startsWith("collection:")) return manager.latestCollection(this.source.slice(11));
+		return {};
+	}
+	/**
+	* The replicated fields of one entry.
+	*
+	* A USER state carries them under `sync` (that is what the owner node sends).
+	* A COLLECTION entity is written by your SERVER, which has no reason to know
+	* that convention — `addCollectionItem('coins', { position: [x, y] })` is the
+	* obvious thing to write, and it used to apply nothing at all. Both work:
+	* `sync` when present, otherwise the entity minus the platform's own keys.
+	*/
+	patchOf(state) {
+		if (state.sync !== void 0) return state.sync;
+		if (this.source === "users") return void 0;
+		const out = {};
+		for (const [key, value] of Object.entries(state)) {
+			if (RESERVED_KEYS.has(key) || key.startsWith("$")) continue;
+			out[key] = value;
+		}
+		return Object.keys(out).length > 0 ? out : void 0;
+	}
+	/** Say it ONCE per message — a per-frame repeat would drown the log. */
+	report(message) {
+		if (this.reported.has(message)) return;
+		this.reported.add(message);
+		diagnose(this.tree?.engine ?? null, "error", `[incanto] NetworkSpawner '${this.name}': ${message} — that value replicates to nothing.`);
+	}
+	setProp(target, prop, value) {
+		if (this.interpolate && prop === "position" && Array.isArray(value)) {
+			this.positionTargets.set(target, value);
+			return;
+		}
+		target[prop] = value;
+	}
+	stepInterpolation(dt) {
+		const f = Math.min(1, dt * 8);
+		for (const [target, goal] of this.positionTargets) {
+			const pos = target.position;
+			if (!Array.isArray(pos)) continue;
+			target.position = pos.map((v, i) => v + ((goal[i] ?? v) - v) * f);
+		}
+	}
+};
+function sanitizeName(key) {
+	return key.replace(/[/%]/g, "_") || "remote";
+}
+//#endregion
+//#region src/net/register.ts
+/**
+* Register the networking node types (and the core nodes). Call once in your
+* game entry before loading a multiplayer scene. Explicit — never a side effect.
+*/
+function registerNodesNet() {
+	registerCoreNodes();
+	registerNode(NetworkSpawner);
+}
+//#endregion
+//#region src/net/split-screen.ts
+/**
+* N local clients on ONE page sharing ONE in-memory game server — the
+* split-screen preview harness three examples were hand-wiring (~40 lines
+* each). Wires: LocalGameServer + per-player Engine/scene/NetworkManager +
+* the server tick driven from the first panel's clock.
+*
+*   const { players, server } = await createSplitScreen({
+*     scene: gameJson,
+*     server: MyServerClass,
+*     scenes: { 'remote-player': remoteJson },
+*     setup: ({ engine }, i) => {
+*       new Renderer2D({ canvas: canvases[i], engine });
+*       engine.input.attachKeyboard(window);
+*       engine.start();
+*     },
+*   });
+*
+* Going live stays the one-line story: replace the transport with
+* `createAgent8Server()` and boot ONE client per browser.
+*/
+async function createSplitScreen(opts) {
+	const server = createLocalGameServer(opts);
+	const accounts = opts.accounts ?? ["p1", "p2"];
+	const players = [];
+	for (let i = 0; i < accounts.length; i++) {
+		const account = accounts[i];
+		const engine = new Engine(opts.seed !== void 0 ? { seed: opts.seed + i } : {});
+		engine.setScene(loadScene(jsonClone(opts.scene)));
+		const manager = await NetworkManager.create(engine, {
+			transport: server.createClient(account),
+			...opts.room !== void 0 || i > 0 ? { room: opts.room ?? players[0].manager.roomId } : {}
+		});
+		for (const [name, json] of Object.entries(opts.scenes ?? {})) manager.registerScene(name, json);
+		await enablePhysicsFor(engine, opts.physics);
+		const player = {
+			account,
+			engine,
+			manager
+		};
+		players.push(player);
+		await opts.setup(player, i);
+	}
+	const disconnect = (players[0]?.engine)?.updated.connect((dt) => void server.tick(Math.min(dt, .05) * 1e3));
+	return {
+		server,
+		players,
+		dispose() {
+			disconnect?.();
+			for (const p of players) p.engine.dispose?.();
+		}
+	};
+}
+/**
+* Enable physics the way the createGame helpers do, without dragging three.js
+* into the net layer's static graph: the adapter is imported only when the
+* scene actually needs it.
+*/
+async function enablePhysicsFor(engine, want) {
+	if (want === false) return;
+	const root = engine.scene?.tree.root;
+	if (!root) return;
+	const dim = engine.scene?.dimension === "3d" ? "3d" : "2d";
+	if (want !== true) {
+		if (!hasBodyNamed(root, dim === "3d" ? "PhysicsBody3D" : "PhysicsBody2D")) return;
+	}
+	if (dim === "3d") {
+		const { enablePhysics3D } = await import("./3d.js");
+		await enablePhysics3D(engine);
+	} else {
+		const { enablePhysics2D } = await import("./2d.js");
+		await enablePhysics2D(engine);
+	}
+}
+/** Any node whose prototype chain carries the adapter's body base class. */
+function hasBodyNamed(node, base) {
+	let ctor = node.constructor;
+	while (typeof ctor === "function") {
+		if (ctor.name === base) return true;
+		ctor = Object.getPrototypeOf(ctor);
+	}
+	for (const child of node.children) if (hasBodyNamed(child, base)) return true;
+	return false;
+}
+//#endregion
+export { applySyncPatch as a, createLocalGameServer as c, NetworkManager as i, LoopbackHub as l, registerNodesNet as n, LocalGameServer as o, NetworkSpawner as r, LocalGameServerTransport as s, createSplitScreen as t, LoopbackTransport as u };