Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

test(render): the mesh that comes back is the mesh that left

esenginebbe4aec4758e
diff --git a/sdk/etc/index.api.md b/sdk/etc/index.api.md
index 92276c7f2..43a0e6cab 100644
--- a/sdk/etc/index.api.md
+++ b/sdk/etc/index.api.md
@@ -900,6 +900,8 @@ loadTextureRaw: (ref: string) => Promise<TextureResult>
loadTilemap: (ref: string) => Promise<TilemapResult>
loadTileset: (ref: string) => Promise<TilesetResult>
loadTimeline: (ref: string) => Promise<TimelineResult>
+meshRealizations: () => { handle: number; generation: number; realized: boolean; }[]
+meshesAwaitingRematerialization: () => number[]
onInvalidate: (listener: InvalidateListener) => () => void
pathForHandle: (kind: string, handle: number) => string | null
preload: (refs: ReadonlyArray<string>, onProgress?: (loaded: number, total: number) => void, options?: { readonly maxConcurrent?: number; }) => Promise<{ failed: MissingAsset[]; }>
@@ -917,6 +919,7 @@ releasePrefab: (ref: string) => void
releaseTexture: (ref: string) => void
releaseTilemap: (ref: string) => void
releaseTimeline: (ref: string) => void
+rematerializeMeshesAfterDeviceLoss: () => Promise<number>
remoteRoot: string | undefined
resolveLoadPath: (ref: string) => string
resolveRef: (ref: string) => string | null
diff --git a/sdk/etc/index.native.api.md b/sdk/etc/index.native.api.md
index 34bd72241..730077dc7 100644
--- a/sdk/etc/index.native.api.md
+++ b/sdk/etc/index.native.api.md
@@ -900,6 +900,8 @@ loadTextureRaw: (ref: string) => Promise<TextureResult>
loadTilemap: (ref: string) => Promise<TilemapResult>
loadTileset: (ref: string) => Promise<TilesetResult>
loadTimeline: (ref: string) => Promise<TimelineResult>
+meshRealizations: () => { handle: number; generation: number; realized: boolean; }[]
+meshesAwaitingRematerialization: () => number[]
onInvalidate: (listener: InvalidateListener) => () => void
pathForHandle: (kind: string, handle: number) => string | null
preload: (refs: ReadonlyArray<string>, onProgress?: (loaded: number, total: number) => void, options?: { readonly maxConcurrent?: number; }) => Promise<{ failed: MissingAsset[]; }>
@@ -917,6 +919,7 @@ releasePrefab: (ref: string) => void
releaseTexture: (ref: string) => void
releaseTilemap: (ref: string) => void
releaseTimeline: (ref: string) => void
+rematerializeMeshesAfterDeviceLoss: () => Promise<number>
remoteRoot: string | undefined
resolveLoadPath: (ref: string) => string
resolveRef: (ref: string) => string | null
diff --git a/sdk/etc/index.node.api.md b/sdk/etc/index.node.api.md
index e69a4aa7c..a83f846f0 100644
--- a/sdk/etc/index.node.api.md
+++ b/sdk/etc/index.node.api.md
@@ -895,6 +895,8 @@ loadTextureRaw: (ref: string) => Promise<TextureResult>
loadTilemap: (ref: string) => Promise<TilemapResult>
loadTileset: (ref: string) => Promise<TilesetResult>
loadTimeline: (ref: string) => Promise<TimelineResult>
+meshRealizations: () => { handle: number; generation: number; realized: boolean; }[]
+meshesAwaitingRematerialization: () => number[]
onInvalidate: (listener: InvalidateListener) => () => void
pathForHandle: (kind: string, handle: number) => string | null
preload: (refs: ReadonlyArray<string>, onProgress?: (loaded: number, total: number) => void, options?: { readonly maxConcurrent?: number; }) => Promise<{ failed: MissingAsset[]; }>
@@ -912,6 +914,7 @@ releasePrefab: (ref: string) => void
releaseTexture: (ref: string) => void
releaseTilemap: (ref: string) => void
releaseTimeline: (ref: string) => void
+rematerializeMeshesAfterDeviceLoss: () => Promise<number>
remoteRoot: string | undefined
resolveLoadPath: (ref: string) => string
resolveRef: (ref: string) => string | null
diff --git a/sdk/etc/minigame.api.md b/sdk/etc/minigame.api.md
index eb9e69ed3..843d17740 100644
--- a/sdk/etc/minigame.api.md
+++ b/sdk/etc/minigame.api.md
@@ -895,6 +895,8 @@ loadTextureRaw: (ref: string) => Promise<TextureResult>
loadTilemap: (ref: string) => Promise<TilemapResult>
loadTileset: (ref: string) => Promise<TilesetResult>
loadTimeline: (ref: string) => Promise<TimelineResult>
+meshRealizations: () => { handle: number; generation: number; realized: boolean; }[]
+meshesAwaitingRematerialization: () => number[]
onInvalidate: (listener: InvalidateListener) => () => void
pathForHandle: (kind: string, handle: number) => string | null
preload: (refs: ReadonlyArray<string>, onProgress?: (loaded: number, total: number) => void, options?: { readonly maxConcurrent?: number; }) => Promise<{ failed: MissingAsset[]; }>
@@ -912,6 +914,7 @@ releasePrefab: (ref: string) => void
releaseTexture: (ref: string) => void
releaseTilemap: (ref: string) => void
releaseTimeline: (ref: string) => void
+rematerializeMeshesAfterDeviceLoss: () => Promise<number>
remoteRoot: string | undefined
resolveLoadPath: (ref: string) => string
resolveRef: (ref: string) => string | null
diff --git a/sdk/etc/wasm.api.md b/sdk/etc/wasm.api.md
index 0c1027f28..582c203fc 100644
--- a/sdk/etc/wasm.api.md
+++ b/sdk/etc/wasm.api.md
@@ -202,6 +202,9 @@ getTextureRefCount: (handle: number) => number
invalidateTexturePath: (path: string) => boolean
loadBitmapFont: (fntContent: string, textureHandle: number, texWidth: number, texHeight: number) => number
measureBitmapText: (fontHandle: number, text: string, fontSize: number, spacing: number) => { width: number; height: number; }
+meshRealizations: (() => string) | undefined
+meshesAwaitingRemat: (() => string) | undefined
+meshesLostNonRecoverable: (() => number) | undefined
registerExternalTexture: (glTextureId: number, width: number, height: number) => number
registerExternalTextureSized: (glTextureId: number, width: number, height: number, bytes: number) => number
registerTextureWithPath: (handle: number, path: string) => void
@@ -307,6 +310,7 @@ meshRenderer_setMaterialAll: ((registry: CppRegistry, materialId: number) => num
meshRenderer_setMeshAll: ((registry: CppRegistry, meshHandle: number) => number) | undefined
mesh_createFromChannels: ((channelsPtr: number, channelCount: number, vertexStride: number, vertexPtr: number, vertexBytes: number, indexPtr: number, indexCount: number, minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number, bindPtr: number, bindFloats: number) => number) | undefined
mesh_release: ((meshHandle: number) => void) | undefined
+mesh_rematerializeFromChannels: ((targetHandle: number, channelsPtr: number, channelCount: number, vertexStride: number, vertexPtr: number, vertexBytes: number, indexPtr: number, indexCount: number, minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number, bindPtr: number, bindFloats: number) => number) | undefined
notifyDeviceLost: ((reason: number, message: string) => void) | undefined
particle_getAliveCount: ((entity: number) => number) | undefined
particle_play: ((registry: CppRegistry, entity: number) => void) | undefined
diff --git a/sdk/etc/wechat.api.md b/sdk/etc/wechat.api.md
index 4fbd4868c..d89237a81 100644
--- a/sdk/etc/wechat.api.md
+++ b/sdk/etc/wechat.api.md
@@ -895,6 +895,8 @@ loadTextureRaw: (ref: string) => Promise<TextureResult>
loadTilemap: (ref: string) => Promise<TilemapResult>
loadTileset: (ref: string) => Promise<TilesetResult>
loadTimeline: (ref: string) => Promise<TimelineResult>
+meshRealizations: () => { handle: number; generation: number; realized: boolean; }[]
+meshesAwaitingRematerialization: () => number[]
onInvalidate: (listener: InvalidateListener) => () => void
pathForHandle: (kind: string, handle: number) => string | null
preload: (refs: ReadonlyArray<string>, onProgress?: (loaded: number, total: number) => void, options?: { readonly maxConcurrent?: number; }) => Promise<{ failed: MissingAsset[]; }>
@@ -912,6 +914,7 @@ releasePrefab: (ref: string) => void
releaseTexture: (ref: string) => void
releaseTilemap: (ref: string) => void
releaseTimeline: (ref: string) => void
+rematerializeMeshesAfterDeviceLoss: () => Promise<number>
remoteRoot: string | undefined
resolveLoadPath: (ref: string) => string
resolveRef: (ref: string) => string | null
diff --git a/sdk/src/asset/Assets.ts b/sdk/src/asset/Assets.ts
index 9a0243017..57527d2ee 100644
--- a/sdk/src/asset/Assets.ts
+++ b/sdk/src/asset/Assets.ts
@@ -498,6 +498,24 @@ export class Assets {
return raw ? raw.split(',').map(Number).filter((h) => h > 0) : [];
}
+ /**
+ * Every live mesh's identity beside the device generation its realization
+ * belongs to. A recovery that minted new handles and one that put geometry
+ * back behind the old ones both end with a scene that draws.
+ */
+ meshRealizations(): { handle: number; generation: number; realized: boolean }[] {
+ const raw = requireResourceManager().meshRealizations?.() ?? '';
+ if (!raw) return [];
+ return raw.split(',').map((row) => {
+ const [handle, generation, realized] = row.split(':');
+ return {
+ handle: Number(handle),
+ generation: Number(generation),
+ realized: realized === '1',
+ };
+ });
+ }
+
/**
* Replays each owed mesh from its source, into the handle it already has.
*
diff --git a/sdk/src/ecs/bridge/nativeEngineApi.generated.ts b/sdk/src/ecs/bridge/nativeEngineApi.generated.ts
index 9a7aa2953..f4e9a7584 100644
--- a/sdk/src/ecs/bridge/nativeEngineApi.generated.ts
+++ b/sdk/src/ecs/bridge/nativeEngineApi.generated.ts
@@ -196,6 +196,7 @@ export interface NativeEngineApi {
rm_getTextureRefCount?(rm: unknown, handleId: number): number;
rm_invalidateTexturePath?(rm: unknown, path: string): boolean;
rm_loadBitmapFont?(rm: unknown, fntContent: string, textureHandle: number, texWidth: number, texHeight: number): number;
+ rm_meshRealizations?(rm: unknown): string;
rm_meshesAwaitingRemat?(rm: unknown): string;
rm_meshesLostNonRecoverable?(rm: unknown): number;
rm_registerExternalTexture?(rm: unknown, glTextureId: number, width: number, height: number): number;
@@ -453,6 +454,7 @@ export function createNativeEngineApi(
bind('rm_getTextureRefCount', 'es_rm_getTextureRefCount', true);
bind('rm_invalidateTexturePath', 'es_rm_invalidateTexturePath', true);
bind('rm_loadBitmapFont', 'es_rm_loadBitmapFont', true);
+ bind('rm_meshRealizations', 'es_rm_meshRealizations', true);
bind('rm_meshesAwaitingRemat', 'es_rm_meshesAwaitingRemat', true);
bind('rm_meshesLostNonRecoverable', 'es_rm_meshesLostNonRecoverable', true);
bind('rm_registerExternalTexture', 'es_rm_registerExternalTexture', true);
diff --git a/sdk/src/wasm.ts b/sdk/src/wasm.ts
index d7e186e9a..a3544c0bb 100644
--- a/sdk/src/wasm.ts
+++ b/sdk/src/wasm.ts
@@ -104,6 +104,13 @@ export interface CppResourceManager {
* Optional: absent on an older wasm build.
*/
meshesLostNonRecoverable?(): number;
+ /**
+ * Every live mesh as `handle:generation:realized`. Identity and realization
+ * read apart: from outside, a mesh that came back and one that was replaced
+ * by a new handle both simply draw, and only these tell them apart.
+ * Optional: absent on an older wasm build.
+ */
+ meshRealizations?(): string;
getTextureGLId(handle: number): number;
getTextureDimensions(handle: number): { width: number; height: number } | null;
releaseTexture(handle: number): void;
diff --git a/src/esengine/bindings/ResourceManagerBindings.cpp b/src/esengine/bindings/ResourceManagerBindings.cpp
index f87544668..21a8ac8ca 100644
--- a/src/esengine/bindings/ResourceManagerBindings.cpp
+++ b/src/esengine/bindings/ResourceManagerBindings.cpp
@@ -158,6 +158,19 @@ std::string rm_meshesAwaitingRemat(resource::ResourceManager& rm) {
return out;
}
+std::string rm_meshRealizations(resource::ResourceManager& rm) {
+ std::string out;
+ for (const auto& row : rm.meshRealizations()) {
+ if (!out.empty()) out += ',';
+ out += std::to_string(row.handle);
+ out += ':';
+ out += std::to_string(row.generation);
+ out += ':';
+ out += row.realized ? '1' : '0';
+ }
+ return out;
+}
+
u32 rm_meshesLostNonRecoverable(resource::ResourceManager& rm) {
return rm.meshesLostNonRecoverable();
}
diff --git a/src/esengine/bindings/ResourceManagerBindings.hpp b/src/esengine/bindings/ResourceManagerBindings.hpp
index 83fde28aa..05dfb9b93 100644
--- a/src/esengine/bindings/ResourceManagerBindings.hpp
+++ b/src/esengine/bindings/ResourceManagerBindings.hpp
@@ -48,6 +48,10 @@ bool rm_adoptTextureContent(resource::ResourceManager& rm, u32 target, u32 sourc
* path: the engine never knew one, and the asset layer holds it. */
std::string rm_meshesAwaitingRemat(resource::ResourceManager& rm);
+/** @brief Every live mesh as `handle:generation:realized`, so a criterion can
+ * tell a mesh that CAME BACK from one that was replaced. */
+std::string rm_meshRealizations(resource::ResourceManager& rm);
+
/** @brief Meshes the last loss ended for good — host-only geometry no source
* can replay. Reported so recovery cannot call them recovered. */
u32 rm_meshesLostNonRecoverable(resource::ResourceManager& rm);
diff --git a/src/esengine/bindings/WebSDKEntry.cpp b/src/esengine/bindings/WebSDKEntry.cpp
index dbae11762..3bb63ae0f 100644
--- a/src/esengine/bindings/WebSDKEntry.cpp
+++ b/src/esengine/bindings/WebSDKEntry.cpp
@@ -494,6 +494,7 @@ EMSCRIPTEN_BINDINGS(esengine_renderer) {
.function("texturesAwaitingReupload", &esengine::rm_texturesAwaitingReupload)
.function("meshesAwaitingRemat", &esengine::rm_meshesAwaitingRemat)
.function("meshesLostNonRecoverable", &esengine::rm_meshesLostNonRecoverable)
+ .function("meshRealizations", &esengine::rm_meshRealizations)
.function("adoptTextureContent", &esengine::rm_adoptTextureContent)
.function("releaseTexture", &esengine::rm_releaseTexture)
.function("getTextureRefCount", &esengine::rm_getTextureRefCount)
diff --git a/src/esengine/resource/ResourceManager.cpp b/src/esengine/resource/ResourceManager.cpp
index 49fd407d4..98dbb8033 100644
--- a/src/esengine/resource/ResourceManager.cpp
+++ b/src/esengine/resource/ResourceManager.cpp
@@ -659,6 +659,14 @@ u32 ResourceManager::invalidateGpuMeshes() {
return static_cast<u32>(awaitingRematerialization_.size());
}
+std::vector<ResourceManager::MeshRealization> ResourceManager::meshRealizations() {
+ std::vector<MeshRealization> out;
+ meshes_.forEachAlive([&](MeshHandle handle, Mesh& mesh) {
+ out.push_back({handle.id(), mesh.realizationGeneration, mesh.hasRealization()});
+ });
+ return out;
+}
+
std::vector<MeshHandle> ResourceManager::meshesAwaitingRematerialization() const {
return awaitingRematerialization_;
}
diff --git a/src/esengine/resource/ResourceManager.hpp b/src/esengine/resource/ResourceManager.hpp
index 6d71d3a88..c40ab2322 100644
--- a/src/esengine/resource/ResourceManager.hpp
+++ b/src/esengine/resource/ResourceManager.hpp
@@ -513,6 +513,21 @@ public:
* them. Never part of the awaiting list, never silently skipped. */
u32 meshesLostNonRecoverable() const { return meshes_lost_non_recoverable_; }
+ /** @brief One live mesh's identity told apart from its realization. */
+ struct MeshRealization {
+ u32 handle = 0;
+ u64 generation = 0; ///< The device generation the realization belongs to.
+ bool realized = false;
+ };
+
+ /**
+ * @brief Every live mesh, as identity and realization read separately.
+ * @details The seam a recovery criterion needs. From outside, a mesh that
+ * came back and a mesh that was replaced by a new one look the same
+ * — both draw — and only these two numbers tell them apart.
+ */
+ std::vector<MeshRealization> meshRealizations();
+
// =========================================================================
// Environment Resources
// =========================================================================
diff --git a/tools/render-host/host.ts b/tools/render-host/host.ts
index c7a9e865e..c75bdf2bc 100644
--- a/tools/render-host/host.ts
+++ b/tools/render-host/host.ts
@@ -684,6 +684,11 @@ window.__estellaHeadless = {
// needs the list, and a number cannot give it.
awaiting: () => (app?.getResource(Assets)?.texturesAwaitingReupload() ?? [])
.map((t: { handle: number; path: string }) => `${t.handle}|${t.path}`),
+ // Identity and realization apart, which a frame cannot show: a recovery
+ // that minted fresh handles draws exactly like one that put the geometry
+ // back behind the handles the world already points at.
+ meshes: () => app?.getResource(Assets)?.meshRealizations() ?? [],
+ meshesOwed: () => app?.getResource(Assets)?.meshesAwaitingRematerialization() ?? [],
// Emscripten's GL tables hold wrappers minted against the dead context;
// counting them says whether a rebuild refilled them or merely added to
// the stale ones.
diff --git a/tools/render-host/run.mjs b/tools/render-host/run.mjs
index 16f477a02..89cb34008 100644
--- a/tools/render-host/run.mjs
+++ b/tools/render-host/run.mjs
@@ -153,7 +153,33 @@ function finish(result, server) {
// for each WebGL context it creates, and no engine call names it.
return owned && (last.tables.buffers - first.tables.buffers) <= spans;
})(rounds[1], rounds[rounds.length - 1], rounds.length - 2);
- const deviceLossOk = lossSeen && cameBack && drivenSteps && growthOk;
+ // Geometry, which the pixels cannot speak for: a recovery that minted fresh
+ // handles draws the same frame as one that re-realized the old ones. Same
+ // identity set, each realized again, each on a LATER device generation.
+ const meshIdentityOk = !dl || !dl.meshesBefore?.length || (() => {
+ const before = dl.meshesBefore;
+ const after = dl.meshesAfterFull ?? [];
+ const by = (rows) => new Map(rows.map((m) => [m.handle, m]));
+ const [b, a] = [by(before), by(after)];
+ if (b.size !== a.size) return false;
+ for (const [handle, was] of b) {
+ const now = a.get(handle);
+ // Same handle, realized again, on a generation the dead one never saw.
+ if (!now || !now.realized || now.generation <= was.generation) return false;
+ }
+ // Nothing may still be owed: a debt outliving recovery is geometry that
+ // never came back, and the device had no business reporting Live.
+ if ((dl.meshesOwedAfterFull?.length ?? 0) !== 0) return false;
+ // The middle state has to have happened. Without it, a scene that never lost
+ // its geometry passes this whole check by never having been broken.
+ if (dl.mode !== 'auto') {
+ if (!dl.meshesAfterRecover?.length) return false;
+ if (!dl.meshesAfterRecover.every((m) => !m.realized)) return false;
+ if ((dl.meshesOwedAfterRecover?.length ?? 0) !== before.length) return false;
+ }
+ return true;
+ })();
+ const deviceLossOk = lossSeen && cameBack && drivenSteps && growthOk && meshIdentityOk;
// Freezing nothing would pass every pixel assertion by not having changed the
// scene — the shape of a check that cannot fail.
const meshOk = (!result.meshResident || result.meshResident.frozen > 0)
@@ -452,7 +478,8 @@ app.whenReady().then(async () => {
// Rounds, because losing a context is not a one-off: backgrounding a
// tab does it again and again, and what a single round cannot show is
// whether the engine hands the last one's objects back.
- const out = { mode: 'auto', supported: true, rounds: [], tablesBefore: d.glTables() };
+ const out = { mode: 'auto', supported: true, rounds: [], tablesBefore: d.glTables(),
+ meshesBefore: d.meshes() };
for (let r = 0; r < ${ROUNDS}; r++) {
if (!d.lose()) return { ...out, supported: false };
@@ -476,6 +503,8 @@ app.whenReady().then(async () => {
}
out.statusAfterFull = d.status();
out.awaitingAfterFull = d.awaiting();
+ out.meshesAfterFull = d.meshes();
+ out.meshesOwedAfterFull = d.meshesOwed();
out.recovered = out.statusAfterFull === 0;
out.fullRecovered = out.recovered;
out.tablesAfterFull = d.glTables();
@@ -492,7 +521,7 @@ app.whenReady().then(async () => {
deviceLoss = await exec(`(async () => {
const d = window.__estellaHeadless.device;
const api = window.__estellaHeadless.api;
- const out = { supported: d.lose() };
+ const out = { meshesBefore: d.meshes(), supported: d.lose() };
if (!out.supported) return out;
// The browser reports the loss asynchronously and the engine polls on its
@@ -507,6 +536,8 @@ app.whenReady().then(async () => {
out.guard = d.guard();
out.tablesAtLoss = d.glTables();
out.awaitingAtLoss = d.awaiting();
+ out.meshesAtLoss = d.meshes();
+ out.meshesOwedAtLoss = d.meshesOwed();
out.glLostBeforeRestore = d.contextLost();
out.restoreCalled = d.restore();
await new Promise((r) => setTimeout(r, 500));
@@ -520,12 +551,19 @@ app.whenReady().then(async () => {
}
out.statusAfterRecover = d.status();
out.awaitingAfterRecover = d.awaiting();
+ // Between the rebuild and the replay: the one moment the realization is
+ // gone and the identity is not. Sampled at the loss instead, this proves
+ // nothing — the engine has not been told about it yet.
+ out.meshesAfterRecover = d.meshes();
+ out.meshesOwedAfterRecover = d.meshesOwed();
// The full cycle: rebuild, re-upload the textures, and declare it whole.
out.fullRecovered = await d.recoverFull();
out.statusAfterFull = d.status();
out.tablesAfterFull = d.glTables();
out.awaitingAfterFull = d.awaiting();
+ out.meshesAfterFull = d.meshes();
+ out.meshesOwedAfterFull = d.meshesOwed();
await api.step(${STEPS}, 1 / 60);
out.drawCallsAfterRecover = api.getStats ? api.getStats().drawCalls : -1;
return out;
diff --git a/tools/renderScenes.mjs b/tools/renderScenes.mjs
index f3f4b3739..f15126202 100644
--- a/tools/renderScenes.mjs
+++ b/tools/renderScenes.mjs
@@ -540,6 +540,14 @@ export const SCENES = [
// 0 looked exactly like one with no normal map, and nothing could tell.
{ id: "device-loss-material", tier: "pr", env: { ESTELLA_VERIFY_DEVICE_LOSS: "1", ESTELLA_VERIFY_SCENE: "/scenes/mat-lit-normal.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mat-lit-normal.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.333,\"y\":0.5,\"rgb\":[0,252,0],\"tol\":45},{\"x\":0.667,\"y\":0.5,\"rgb\":[0,36,0],\"tol\":50}]" } },
{ id: "device-loss", tier: "pr", env: { ESTELLA_VERIFY_DEVICE_LOSS: "1", ESTELLA_VERIFY_SCENE: "/scenes/tilemap-flip.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/tilemap-flip.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "2", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.40,\"y\":0.36,\"rgb\":[255,0,0]},{\"x\":0.60,\"y\":0.36,\"rgb\":[0,255,0]},{\"x\":0.40,\"y\":0.58,\"rgb\":[0,0,255]},{\"x\":0.60,\"y\":0.58,\"rgb\":[255,255,0]}]" } },
+ // The textures above prove content comes back; a mesh proves IDENTITY does —
+ // the handles the world points at are the ones re-realized, not new ones the
+ // scene happens to draw with. Through the asset layer, the only replayable path.
+ { id: "device-loss-mesh", tier: "pr", env: { ESTELLA_VERIFY_DEVICE_LOSS: "1", ESTELLA_VERIFY_MESH_ASSET: "/scenes/two-triangles.esmesh", ESTELLA_VERIFY_SCENE: "/scenes/mesh-renderer.esscene", ESTELLA_VERIFY_MANIFEST: "/scenes/mesh-renderer.textures.json", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_EXPECT: "[{\"x\":0.30,\"y\":0.556,\"rgb\":[255,0,0],\"tol\":40},{\"x\":0.70,\"y\":0.556,\"rgb\":[0,255,0],\"tol\":40},{\"x\":0.30,\"y\":0.40,\"rgb\":[255,0,0],\"tol\":40}]" } },
+ // Where "same handle" stops being a detail: a LODGroup names its levels BY
+ // handle, so a recovery that reloaded would leave every reference pointing at
+ // geometry nothing rebuilt, while the frame drew whichever level came back.
+ { id: "device-loss-lod", tier: "pr", env: { ESTELLA_VERIFY_DEVICE_LOSS: "1", ESTELLA_VERIFY_SCENE: "/scenes/lod-3d.esscene", ESTELLA_VERIFY_W: "256", ESTELLA_VERIFY_H: "256", ESTELLA_VERIFY_STEPS: "4", ESTELLA_VERIFY_COUNTERS: "{\"render.lod.groups\":4,\"render.lod.level0\":1,\"render.lod.level1\":1,\"render.lod.level2\":1,\"render.meshes\":3}" } },
// The player's case: nothing asks for the recovery, only frames pass, and it
// happens FOUR times — backgrounding a tab is not a one-off, a recovery that
// works once and never again passes any single-round check, and it takes