incanto 0.1.0

package/dist/net.js

@@ -0,0 +1,772 @@
+import { t as IncantoError } from "./errors-BpWbnbb_.js";
+import { t as jsonClone } from "./json-BLk7H2Qa.js";
+import { n as createAgent8Server } from "./agent8-DzU2fFyH.js";
+import { i as applySyncPatch, n as NetworkSpawner, r as NetworkManager, t as registerNodesNet } from "./register-Dasmnurl.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
+export { LocalGameServer, LocalGameServerTransport, LoopbackHub, LoopbackTransport, NetworkManager, NetworkSpawner, applySyncPatch, createAgent8Server, createLocalGameServer, registerNodesNet };