incanto 0.51.0 → 0.52.0

package/dist/register-CLVhzWcI.js

@@ -1,374 +0,0 @@
-import { M as Signal, f as Node, t as buildNodeJson } from "./loader-B2asghWa.js";
-import { t as registerCoreNodes } from "./register-CGq-Hee8.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-IyWCGe4q.js";
-//#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>"`). */
-	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) {
-	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);
-	}
-}
-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
-/**
-* 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();
-	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 = state.sync;
-			if (patch) applySyncPatch(instance, patch, (target, prop, value) => this.setProp(target, prop, value));
-		}
-		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 {};
-	}
-	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
-export { applySyncPatch as i, NetworkSpawner as n, NetworkManager as r, registerNodesNet as t };