incanto 0.57.0 → 0.59.0

package/dist/{split-screen-DLsUrleX.js → split-screen-DDMZutQ6.js}

@@ -1,8 +1,8 @@
-import { C as diagnose, M as Signal, S as Node, n as loadScene, t as buildNodeJson } from "./loader-BcrRSjxB.js";
-import { _ as Engine, t as registerCoreNodes } from "./register-Ch70uByv.js";
+import { C as Node, N as Signal, n as loadScene, t as buildNodeJson, w as diagnose } from "./loader-D8n7TU8W.js";
+import { _ as Engine, t as registerCoreNodes } from "./register-CDrAQqPp.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";
+import { n as jsonEquals, t as jsonClone } from "./json-CwwhxQgb.js";
+import { l as registerNode } from "./registry-WWcQcfMr.js";
 //#region src/net/loopback.ts
 /**
 * In-memory multiplayer hub implementing the SAME kernel contract as
@@ -771,6 +771,15 @@ var LocalGameServerTransport = class {
 };
 //#endregion
 //#region src/net/network-manager.ts
+/**
+* How long a sync key may read as `undefined` before it is called dead.
+*
+* Long enough for `onReady` and a few `update`s to have run; short enough that
+* a genuinely wrong prop name is named while its author is still looking.
+*/
+const DEAD_KEY_GRACE_MS = 500;
+/** Full-state resend interval, in simulated ms. See `keyframeMs`. */
+const DEFAULT_KEYFRAME_MS = 2e3;
 const managers = /* @__PURE__ */ new WeakMap();
 /**
 * Per-engine multiplayer hub: joins a room, exposes the room channels as core
@@ -802,6 +811,7 @@ var NetworkManager = class NetworkManager {
 	server;
 	engine;
 	throttleMs;
+	keyframeMs;
 	subs = [];
 	messageSignals = /* @__PURE__ */ new Map();
 	collectionSignals = /* @__PURE__ */ new Map();
@@ -814,12 +824,28 @@ var NetworkManager = class NetworkManager {
 	/** Sync keys already reported unreadable, so a per-frame send says it once. */
 	reportedDeadKeys = /* @__PURE__ */ new Set();
 	/** Name a sync key the owner cannot read — a typo in the prop or the path. */
+	/**
+	* A sync key that has NEVER been readable, reported once — after a grace
+	* period.
+	*
+	* Behaviours set their props in `onReady`/`update`, and replication runs on
+	* the fixed step, so a perfectly correct key reads as `undefined` on the
+	* first pass or two. Reporting immediately made the engine's own co-op
+	* example print "sync key 'firing' … it is never sent" about a key that is
+	* sent from frame 2 onward — a diagnostic that cries wolf teaches its reader
+	* to ignore the one that does not.
+	*/
 	reportDeadSyncKey(owner, key) {
 		if (this.reportedDeadKeys.has(key)) return;
+		if (this.aliveMs < DEAD_KEY_GRACE_MS) return;
 		this.reportedDeadKeys.add(key);
 		diagnose(owner.tree?.engine ?? null, "error", `[incanto] ${owner.getPath()}: sync key '${key}' reads as undefined — it is never sent, so remote players never see it change. Check the prop name and the node path.`);
 	}
 	sendAccumulator = 0;
+	/** Simulated ms since the last time the FULL sync set went out. */
+	keyframeAccumulator = 0;
+	/** Simulated ms this manager has been replicating — see reportDeadSyncKey. */
+	aliveMs = 0;
 	detachReplication = null;
 	lastOwner = null;
 	boundScene = null;
@@ -831,16 +857,17 @@ var NetworkManager = class NetworkManager {
 		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);
+		const manager = new NetworkManager(engine, server, await server.remoteFunction("joinRoom", [requested === "auto" ? void 0 : requested], { needResponse: true }), opts.throttleMs ?? 50, opts.keyframeMs ?? DEFAULT_KEYFRAME_MS);
 		managers.set(engine, manager);
 		return manager;
 	}
-	constructor(engine, server, roomId, throttleMs) {
+	constructor(engine, server, roomId, throttleMs, keyframeMs) {
 		this.engine = engine;
 		this.server = server;
 		this.roomId = roomId;
 		this.account = server.account;
 		this.throttleMs = Math.max(30, throttleMs);
+		this.keyframeMs = Math.max(0, keyframeMs);
 		this.boundScene = engine.scene;
 		this.subs.push(server.subscribeRoomState(roomId, (state) => {
 			this.latestRoomState = state;
@@ -996,6 +1023,7 @@ var NetworkManager = class NetworkManager {
 		const scene = this.engine.scene;
 		if (!scene || scene !== this.boundScene) return;
 		this.sendAccumulator += dt * 1e3;
+		this.aliveMs += dt * 1e3;
 		const owner = findOwnerNode(scene.root, true);
 		if (!owner) return;
 		if (owner !== this.lastOwner) {
@@ -1005,22 +1033,29 @@ var NetworkManager = class NetworkManager {
 		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 = {};
+		const full = {};
+		let changed = false;
 		for (const key of syncKeys) {
 			const value = readSyncKey(owner, key);
 			if (value === void 0) {
 				this.reportDeadSyncKey(owner, key);
 				continue;
 			}
-			if (!jsonEquals(this.lastSent.get(key) ?? null, value)) patch[key] = jsonClone(value);
+			full[key] = jsonClone(value);
+			if (!jsonEquals(this.lastSent.get(key) ?? null, value)) changed = true;
 		}
+		this.keyframeAccumulator += dt * 1e3;
+		const keyframeDue = this.keyframeMs > 0 && this.keyframeAccumulator >= this.keyframeMs;
 		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));
+		if (!changed && !keyframeDue) return;
+		if (Object.keys(full).length === 0) return;
+		for (const [key, value] of Object.entries(full)) this.lastSent.set(key, jsonClone(value));
+		this.keyframeAccumulator = 0;
 		this.sendAccumulator = 0;
-		this.setMyState({ sync: patch });
+		this.setMyState({ sync: full });
 	}
 };
+/** The single `network.mode === 'owner'` node in a tree, or null. @internal */
 function findOwnerNode(node, enforceSingle = false) {
 	const owners = [];
 	collectOwners(node, owners);
@@ -1032,6 +1067,13 @@ function collectOwners(node, out) {
 	for (const c of node.children) collectOwners(c, out);
 }
 /** `'position'` → own prop; `'Sprite.animation'` → child path + prop (last dot splits). */
+/**
+* Read one `network.sync` key off an owner node, exactly as the sender does.
+*
+* Exported so an agreement check reads GROUND TRUTH through the same last-dot
+* split the protocol uses — a second implementation would eventually disagree
+* with this one, and then the check would be measuring itself.
+*/
 function readSyncKey(node, key) {
 	const lastDot = key.lastIndexOf(".");
 	const target = lastDot === -1 ? node : node.getNodeOrNull(key.slice(0, lastDot)) ?? void 0;
@@ -1176,6 +1218,7 @@ var NetworkSpawner = class extends Node {
 		}
 	}
 };
+/** The child name a spawner gives an account's instance. @internal */
 function sanitizeName(key) {
 	return key.replace(/[/%]/g, "_") || "remote";
 }
@@ -1218,7 +1261,7 @@ async function createSplitScreen(opts) {
 	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)));
+		engine.setScene(loadScene(jsonClone(opts.scene), opts.load));
 		const manager = await NetworkManager.create(engine, {
 			transport: server.createClient(account),
 			...opts.room !== void 0 || i > 0 ? { room: opts.room ?? players[0].manager.roomId } : {}
@@ -1275,4 +1318,4 @@ function hasBodyNamed(node, base) {
 	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 };
+export { NetworkManager as a, readSyncKey as c, createLocalGameServer as d, LoopbackHub as f, sanitizeName as i, LocalGameServer as l, registerNodesNet as n, applySyncPatch as o, LoopbackTransport as p, NetworkSpawner as r, findOwnerNode as s, createSplitScreen as t, LocalGameServerTransport as u };

package/dist/{sprite-animation-C0wXLBZJ.js → sprite-animation-CY-mrr1L.js}

@@ -1,5 +1,5 @@
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { n as jsonEquals } from "./json-BLk7H2Qa.js";
+import { n as jsonEquals } from "./json-CwwhxQgb.js";
 //#region src/core/particle-presets.ts
 const PARTICLE_PRESETS = {
 	fire: {

package/dist/{src-CGjmPw65.js → src-CY21B462.js}

@@ -214,6 +214,6 @@ function newUid() {
 //#endregion
 //#region src/index.ts
 /** Engine version. Kept in sync with package.json by the release pipeline. */
-const VERSION = "0.57.0";
+const VERSION = "0.59.0";
 //#endregion
 export { preloadUrls as a, preloadSceneAssets as i, newUid as n, findPath as o, assetUrls as r, gridFromRows as s, VERSION as t };

package/dist/{teardown-Cs113S9F.js → teardown-RApWnM1G.js}

@@ -1,4 +1,4 @@
-import { g as AudioPlayer } from "./register-Ch70uByv.js";
+import { g as AudioPlayer } from "./register-CDrAQqPp.js";
 import { a as logReport, s as parseDrive } from "./touch-DESwnpOc.js";
 import { a as frameSignature, i as frameImage, o as frameStats } from "./frame-report-BSMny7oe.js";
 //#region src/core/audio-errors.ts

package/dist/{test-it1VekWs.js → test-DHYuFyAu.js}

@@ -1,13 +1,13 @@
-import { A as registerBehavior, n as loadScene, s as resolveViewport } from "./loader-BcrRSjxB.js";
-import { _ as Engine } from "./register-Ch70uByv.js";
+import { c as resolveViewport, j as registerBehavior, n as loadScene } from "./loader-D8n7TU8W.js";
+import { _ as Engine } from "./register-CDrAQqPp.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { n as jsonEquals, t as jsonClone } from "./json-BLk7H2Qa.js";
-import { i as getNodeSchema, s as mergeStaticProps } from "./registry-C7u42TID.js";
-import { n as startRecording } from "./replay-s7I2GstT.js";
-import { n as registerGameplayBehaviors } from "./gameplay-BVphcxmE.js";
-import { t as registerNodes2D } from "./register-C6ZBFRjd.js";
-import { n as registerNodes3D, t as resolveEnvironmentHdri } from "./environment-presets-CvvQr_bJ.js";
-import { n as registerNodesNet, t as createSplitScreen } from "./split-screen-DLsUrleX.js";
+import { n as jsonEquals, t as jsonClone } from "./json-CwwhxQgb.js";
+import { i as getNodeSchema, s as mergeStaticProps } from "./registry-WWcQcfMr.js";
+import { n as startRecording } from "./replay-CEPyQtF_.js";
+import { n as registerGameplayBehaviors } from "./gameplay-BBEjPFsR.js";
+import { t as registerNodes2D } from "./register-BpFcgdcL.js";
+import { n as registerNodes3D, t as resolveEnvironmentHdri } from "./environment-presets-DRAz5EV9.js";
+import { a as NetworkManager, c as readSyncKey, i as sanitizeName, n as registerNodesNet, r as NetworkSpawner, s as findOwnerNode, t as createSplitScreen } from "./split-screen-DDMZutQ6.js";
 import { Box3, Euler, Matrix4, PerspectiveCamera, Quaternion, Vector3 } from "three";
 //#region src/test/framing.ts
 /**
@@ -474,6 +474,24 @@ function framingText(report) {
 const FALL_2D_PX = 1e3;
 /** "Reached it", in pixels — one 32 px tile, next to a ~34 px character. */
 const REACH_2D_PX = 32;
+/**
+* How hard this scene pulls, in its own units — 0 only for a scene that says so.
+*
+* Gravity is what makes "left the world downward" mean anything, and a
+* top-down game has none. But ABSENT is not ZERO: the physics adapters default
+* an undeclared scene to [0, 980] px/s² in 2D and [0, -9.81, 0] m/s² in 3D, so
+* a platformer that never wrote a physics header still falls, and reading
+* absent as zero would have stopped reporting the pit it fell into.
+*/
+function gravityMagnitude(physics) {
+	const g = physics?.gravity;
+	if (g === void 0) return 1;
+	if (!Array.isArray(g)) return 1;
+	return g.reduce((sum, v) => sum + (typeof v === "number" ? Math.abs(v) : 0), 0);
+}
+/** Furthest the player ever got from its spawn, below which it went nowhere. */
+const STUCK_3D_M = 3;
+const STUCK_2D_PX = 96;
 const CONTROLLERS = new Set(["CharacterController2D", "CharacterController3D"]);
 /**
 * Who the driver is playing as.
@@ -718,7 +736,8 @@ async function runOnce(json, seed, opts) {
 		0
 	];
 	const down = scene.dimension === "2d" ? 1 : -1;
-	const floor = opts.fallBelow ?? start[1] + down * (down > 0 ? FALL_2D_PX : 50);
+	const pull = gravityMagnitude(scene.physics);
+	const floor = opts.fallBelow ?? (pull > 0 ? start[1] + down * (down > 0 ? FALL_2D_PX : 50) : null);
 	const radius = opts.reachRadius ?? (down > 0 ? REACH_2D_PX : 2);
 	const recorder = startRecording(engine);
 	const rand = () => engine.rng.next();
@@ -726,10 +745,12 @@ async function runOnce(json, seed, opts) {
 	const reached = /* @__PURE__ */ new Set();
 	const stepMs = 1e3 / 60;
 	const deadline = (opts.seconds ?? 60) * 1e3;
-	let outcome = "stuck";
+	let outcome = null;
 	let at = start;
+	let wentAsFarAs = 0;
 	while (session.timeMs < deadline) {
 		at = player ? worldOf(player) : start;
+		wentAsFarAs = Math.max(wentAsFarAs, Math.hypot(at[0] - start[0], at[2] - start[2]));
 		driver.step(stepMs / 1e3, at);
 		session.step(stepMs);
 		if (player) for (const [path, node] of targetNodes) {
@@ -746,15 +767,17 @@ async function runOnce(json, seed, opts) {
 			outcome = "error";
 			break;
 		}
-		if (player && (at[1] - floor) * down > 0) {
+		if (player && floor !== null && (at[1] - floor) * down > 0) {
 			outcome = "fell";
 			break;
 		}
 	}
 	driver.release();
+	const WENT_NOWHERE = scene.dimension === "2d" ? STUCK_2D_PX : STUCK_3D_M;
+	outcome ??= wentAsFarAs > WENT_NOWHERE ? "unfinished" : "stuck";
 	const heard = engine.audio.recent().map((e) => e.from);
 	const shown = engine.effects.recent().map((e) => e.from);
-	const bad = outcome !== "won";
+	const bad = outcome !== "won" && outcome !== "unfinished";
 	const run = {
 		seed,
 		outcome,
@@ -857,12 +880,15 @@ function playtestText(report) {
 		"error",
 		"fell",
 		"lost",
-		"stuck"
+		"stuck",
+		"unfinished"
 	]) {
 		const hits = runs.filter((r) => r.outcome === bad);
 		if (hits.length === 0) continue;
 		const where = bad === "fell" ? ` (last at y=${hits[0].endedAt[1].toFixed(1)})` : "";
-		lines.push(`  ✗ ${bad} in ${pct(hits.length, total)}${where}`);
+		const mark = bad === "unfinished" ? "·" : "✗";
+		const what = bad === "unfinished" ? "ran out of time still playing" : `${bad} in ${pct(hits.length, total)}`;
+		lines.push(bad === "unfinished" ? `  ${mark} ${pct(hits.length, total)} ${what}` : `  ${mark} ${what}${where}`);
 	}
 	const everReached = new Set(runs.flatMap((r) => r.reached));
 	const missed = targets.filter((path) => !everReached.has(path));
@@ -1012,6 +1038,177 @@ function facingText(report) {
 	return `facing: ${report.skin} faces its travel (dot ${report.dot.toFixed(2)})`;
 }
 //#endregion
+//#region src/test/agreement.ts
+/** Absolute slack, for values that are still converging out of a lerp. */
+const ABS_TOL = .001;
+/** Relative slack, so a large coordinate is not held to the absolute one. */
+const REL_TOL = .005;
+function closeEnough(a, b, absTol, relTol) {
+	return Math.abs(a - b) <= Math.max(absTol, relTol * Math.abs(a));
+}
+function numbers(v) {
+	if (typeof v === "number") return [v];
+	if (Array.isArray(v) && v.every((x) => typeof x === "number")) return v;
+	return null;
+}
+/**
+* Every way the clients disagree, most structural first.
+*
+* @param live snapshots taken after the match has quiesced
+* @param late the same, for a client that joined AFTER everything settled
+*/
+function agreementProblems(live, late = [], opts = {}) {
+	const absTol = opts.absTol ?? ABS_TOL;
+	const relTol = opts.relTol ?? REL_TOL;
+	const out = [];
+	const compare = (snapshots, lateJoin) => {
+		const found = [];
+		for (const s of snapshots) for (const [observer, seen] of Object.entries(s.seen)) {
+			if (seen === null) {
+				found.push({
+					kind: "missing",
+					account: s.account,
+					observer,
+					key: "",
+					summary: `${observer} never materialised ${s.account} at all — a NetworkSpawner spawns one instance per OTHER account, so check its \`scene\` key is registered and its \`source\` names a real collection.`
+				});
+				continue;
+			}
+			for (const [key, truth] of Object.entries(s.truth)) {
+				const mine = seen[key];
+				if (mine === void 0) {
+					found.push({
+						kind: lateJoin ? "erased" : "absent",
+						account: s.account,
+						observer,
+						key,
+						truth,
+						summary: lateJoin ? `${observer} joined late and never got ${s.account}'s \`${key}\` — the live clients have it, so the value is gone from the AUTHORITATIVE state, not from the wire. A partial patch replaces the stored \`sync\` object.` : `${observer} has no \`${key}\` for ${s.account} — the key path does not resolve on the spawned scene (a renamed child?), or it was never sent.`
+					});
+					continue;
+				}
+				const a = numbers(truth);
+				const b = numbers(mine);
+				if (a && b) {
+					if (a.length !== b.length) {
+						found.push({
+							kind: "shape",
+							account: s.account,
+							observer,
+							key,
+							truth,
+							seen: mine,
+							summary: `${observer} holds ${b.length} components of ${s.account}'s \`${key}\` where there are ${a.length} — the interpolator treats a missing component as already correct, so this never converges and never complains.`
+						});
+						continue;
+					}
+					if (a.every((v, i) => closeEnough(v, b[i], absTol, relTol))) continue;
+					found.push({
+						kind: "mismatch",
+						account: s.account,
+						observer,
+						key,
+						truth,
+						seen: mine,
+						summary: `${observer} has ${s.account}'s \`${key}\` as ${JSON.stringify(mine)}, not ${JSON.stringify(truth)}.`
+					});
+					continue;
+				}
+				if (jsonEquals(truth, mine)) continue;
+				found.push({
+					kind: "mismatch",
+					account: s.account,
+					observer,
+					key,
+					truth,
+					seen: mine,
+					summary: `${observer} has ${s.account}'s \`${key}\` as ${JSON.stringify(mine)}, not ${JSON.stringify(truth)}.`
+				});
+			}
+		}
+		return found;
+	};
+	out.push(...compare(live, false));
+	if (late.length > 0) {
+		const alreadyAbsent = new Set(out.filter((d) => d.kind === "absent").map((d) => `${d.account}|${d.key}`));
+		for (const d of compare(late, true)) {
+			if (d.kind === "erased" && alreadyAbsent.has(`${d.account}|${d.key}`)) continue;
+			out.push(d);
+		}
+	}
+	const rank = {
+		missing: 0,
+		erased: 1,
+		absent: 2,
+		shape: 3,
+		mismatch: 4
+	};
+	return out.sort((x, y) => rank[x.kind] - rank[y.kind]);
+}
+//#endregion
+//#region src/test/agreement-snapshot.ts
+/** The last-dot split of the RECEIVE side, applied to a spawned instance. */
+function readFromInstance(instance, key) {
+	const lastDot = key.lastIndexOf(".");
+	const target = lastDot === -1 ? instance : instance.getNodeOrNull(key.slice(0, lastDot));
+	if (!target) return void 0;
+	return target[lastDot === -1 ? key : key.slice(lastDot + 1)];
+}
+/** Every spawned instance in a client's tree, by the child name a spawner gives it. */
+function instancesByName(engine) {
+	const out = /* @__PURE__ */ new Map();
+	const root = engine.scene?.tree.root;
+	if (!root) return out;
+	const walk = (node) => {
+		for (const child of node.children) {
+			if (!out.has(child.name)) out.set(child.name, child);
+			walk(child);
+		}
+	};
+	walk(root);
+	return out;
+}
+/**
+* One snapshot per account: its own truth, and what each other client believes.
+*
+* @param clients every client in the match
+* @param observers the clients whose beliefs to record (defaults to `clients`)
+*/
+function takeAgreementSnapshots(clients, observers = clients) {
+	const snapshots = [];
+	for (const owner of clients) {
+		const root = owner.engine.scene?.tree.root;
+		if (!root) continue;
+		const node = findOwnerNode(root);
+		if (!node) continue;
+		const keys = Array.isArray(node.network?.sync) ? node.network.sync : [];
+		if (keys.length === 0) continue;
+		const truth = {};
+		for (const key of keys) {
+			const value = readSyncKey(node, key);
+			if (value !== void 0) truth[key] = value;
+		}
+		const seen = {};
+		for (const other of observers) {
+			if (other.account === owner.account) continue;
+			const instance = instancesByName(other.engine).get(sanitizeName(owner.account));
+			if (!instance) {
+				seen[other.account] = null;
+				continue;
+			}
+			const held = {};
+			for (const key of Object.keys(truth)) held[key] = readFromInstance(instance, key);
+			seen[other.account] = held;
+		}
+		snapshots.push({
+			account: owner.account,
+			truth,
+			seen
+		});
+	}
+	return snapshots;
+}
+//#endregion
 //#region src/test/feel.ts
 const STEP_MS = 1e3 / 60;
 /** Drop height for the buffer probe — long enough to outlast a coyote window. */
@@ -1404,10 +1601,12 @@ async function playMultiplayer(opts) {
 	const seconds = opts.seconds ?? 5;
 	const stepMs = opts.stepMs ?? 1e3 / 60;
 	const accounts = Array.from({ length: count }, (_, i) => `p${i + 1}`);
-	const { players, dispose } = await createSplitScreen({
+	const { server, players, dispose } = await createSplitScreen({
 		scene: opts.scene,
 		...opts.server ? { server: opts.server } : {},
 		...opts.scenes ? { scenes: opts.scenes } : {},
+		...opts.seed !== void 0 ? { seed: opts.seed } : {},
+		...opts.load ? { load: opts.load } : {},
 		accounts,
 		setup: () => {}
 	});
@@ -1424,26 +1623,87 @@ async function playMultiplayer(opts) {
 		if (frame % 6 === 0) await settle();
 	}
 	await settle();
-	const report = summarize(players, seconds, frames);
+	for (let frame = 0; frame < 60; frame++) {
+		now += stepMs;
+		for (const player of players) player.engine.tick(now);
+		if (frame % 6 === 0) await settle();
+	}
+	await settle();
+	const live = takeAgreementSnapshots(players);
+	const matchDetail = players.map((p) => ({
+		account: p.account,
+		room: p.manager.roomId,
+		spawned: spawnerCounts(p.engine),
+		sawAccounts: Object.keys(p.manager.latestUserStates ?? {}).filter((a) => a !== p.account),
+		errors: p.engine.stats().errors
+	}));
+	let lateSnapshots = [];
+	let lateJoinChecked = false;
+	if ((opts.lateJoin ?? true) && players.length > 0) {
+		const joiner = await joinLate(server, players[0], opts);
+		if (joiner) {
+			for (let frame = 0; frame < 60; frame++) {
+				now += stepMs;
+				for (const player of [...players, joiner]) player.engine.tick(now);
+				if (frame % 6 === 0) await settle();
+			}
+			await settle();
+			lateSnapshots = takeAgreementSnapshots(players, [joiner]);
+			lateJoinChecked = true;
+		}
+	}
+	const report = summarize(players, seconds, frames, matchDetail, {
+		disagreements: agreementProblems(live, lateSnapshots),
+		keysCompared: live.reduce((n, s) => n + Object.keys(s.truth).length * Object.keys(s.seen).length, 0),
+		lateJoinChecked
+	});
 	dispose();
 	return report;
 }
+/**
+* One more client, against the SAME server and the SAME room.
+*
+* `createSplitScreen` builds all its panels up front, so this is the ten lines
+* of it that matter — and the room id has to come from panel 0 or the joiner
+* lands in its own auto-assigned room and reports everything as missing.
+*/
+async function joinLate(server, first, opts) {
+	try {
+		const { Engine } = await import("./register-CDrAQqPp.js").then((n) => n.v);
+		const { loadScene } = await import("./loader-D8n7TU8W.js").then((n) => n.r);
+		const { jsonClone } = await import("./json-CwwhxQgb.js").then((n) => n.i);
+		const engine = new Engine(opts.seed !== void 0 ? { seed: opts.seed + 999 } : {});
+		engine.setScene(loadScene(jsonClone(opts.scene), opts.load));
+		const manager = await NetworkManager.create(engine, {
+			transport: server.createClient("late"),
+			room: first.manager.roomId
+		});
+		for (const [name, json] of Object.entries(opts.scenes ?? {})) manager.registerScene(name, json);
+		return {
+			account: "late",
+			engine,
+			manager
+		};
+	} catch {
+		return null;
+	}
+}
 /** Give the server's promise queue a turn. */
 function settle() {
 	return new Promise((resolve) => setTimeout(resolve, 0));
 }
-function summarize(players, seconds, frames) {
+function summarize(players, seconds, frames, matchDetail, agreement) {
 	const rooms = players.map((p) => p.manager.roomId);
-	const detail = players.map((p) => ({
-		account: p.account,
-		room: p.manager.roomId,
-		spawned: spawnerCounts(p.engine),
-		sawAccounts: Object.keys(p.manager.latestUserStates ?? {}).filter((a) => a !== p.account),
-		errors: p.engine.stats().errors
+	const detail = matchDetail.map((d, i) => ({
+		...d,
+		errors: players[i]?.engine.stats().errors ?? d.errors
 	}));
-	const problems = multiplayProblems(detail, rooms);
+	const problems = [...multiplayProblems(detail, rooms), ...agreement.disagreements.map((d) => d.summary)];
 	return {
 		ok: problems.length === 0,
+		disagreements: agreement.disagreements,
+		keysCompared: agreement.keysCompared,
+		lateJoinChecked: agreement.lateJoinChecked,
 		seconds,
 		frames,
 		rooms,
@@ -1476,7 +1736,7 @@ function spawnerCounts(engine) {
 	const root = engine.scene?.tree.root;
 	if (!root) return out;
 	const walk = (node) => {
-		if (node.constructor.name === "NetworkSpawner") out[node.name] = node.children.length;
+		if (node instanceof NetworkSpawner) out[node.name] = node.children.length;
 		for (const child of node.children) walk(child);
 	};
 	walk(root);
@@ -1485,6 +1745,7 @@ function spawnerCounts(engine) {
 /** The report as the one paragraph a reader needs. */
 function multiplayText(report) {
 	const lines = [`multiplayer: ${report.players.length} clients, ${report.seconds}s, room ${[...new Set(report.rooms)].join(" + ")}`];
+	lines.push(report.keysCompared === 0 ? "  agrees: nothing to compare — no owner node declared any sync keys" : `  agrees: ${report.keysCompared} replicated value(s) compared across clients${report.lateJoinChecked ? " + a late joiner" : ""}, over one in-memory server (not a live wire)`);
 	for (const p of report.players) {
 		const spawned = Object.entries(p.spawned).map(([name, n]) => `${name}=${n}`).join(" ");
 		lines.push(`  ${p.account}: sees [${p.sawAccounts.join(", ") || "—"}]` + (spawned ? ` spawned ${spawned}` : "") + (p.errors ? ` · ${p.errors} error(s)` : ""));
@@ -1762,10 +2023,10 @@ async function runScript(json, opts) {
 	engine.setScene(scene);
 	const physics = opts.physics ?? "auto";
 	if (physics === "2d" || physics === "auto" && scene.dimension === "2d") {
-		const { enablePhysics2D } = await import("./physics-2d-BLcvEFDR.js").then((n) => n.r);
+		const { enablePhysics2D } = await import("./physics-2d-BaRSRrrZ.js").then((n) => n.r);
 		await enablePhysics2D(engine);
 	} else if (physics === "3d" || physics === "auto" && scene.dimension === "3d") {
-		const { enablePhysics3D } = await import("./physics-3d-QBrfIT2Y.js").then((n) => n.r);
+		const { enablePhysics3D } = await import("./physics-3d-CYxjh-HW.js").then((n) => n.r);
 		await enablePhysics3D(engine);
 	}
 	const failures = [];
@@ -1878,10 +2139,10 @@ async function createPlaySession(json, opts = {}) {
 	engine.setScene(scene);
 	const physics = opts.physics ?? "auto";
 	if (physics === "2d" || physics === "auto" && scene.dimension === "2d") {
-		const { enablePhysics2D } = await import("./physics-2d-BLcvEFDR.js").then((n) => n.r);
+		const { enablePhysics2D } = await import("./physics-2d-BaRSRrrZ.js").then((n) => n.r);
 		await enablePhysics2D(engine);
 	} else if (physics === "3d" || physics === "auto" && scene.dimension === "3d") {
-		const { enablePhysics3D } = await import("./physics-3d-QBrfIT2Y.js").then((n) => n.r);
+		const { enablePhysics3D } = await import("./physics-3d-CYxjh-HW.js").then((n) => n.r);
 		await enablePhysics3D(engine);
 	}
 	const stepMs = 1e3 / (opts.fixedHz ?? 60);
@@ -1919,4 +2180,4 @@ async function createPlaySession(json, opts = {}) {
 	};
 }
 //#endregion
-export { framingText as S, failingReplays as _, registerAllNodes as a, playtestText as b, ladderText as c, multiplayText as d, playMultiplayer as f, facingText as g, facingReport as h, findFloatingProps as i, ladderVerdict as l, feelText as m, createPlaySession as n, runScript as o, feelReport as p, describeCapture as r, validateScene as s, captureScene as t, multiplayProblems as u, findPlayer as v, describeFraming as x, playtest as y };
+export { describeFraming as C, playtestText as S, facingReport as _, registerAllNodes as a, findPlayer as b, ladderText as c, multiplayText as d, playMultiplayer as f, agreementProblems as g, takeAgreementSnapshots as h, findFloatingProps as i, ladderVerdict as l, feelText as m, createPlaySession as n, runScript as o, feelReport as p, describeCapture as r, validateScene as s, captureScene as t, multiplayProblems as u, facingText as v, framingText as w, playtest as x, failingReplays as y };