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.
TypeScript 2d-game-engine3d3d-game-engineandroidcppecsgame-editorgame-enginegamedeviostypescriptwebassemblywebglwebgpuwechat-minigame
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.mdindex 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) => () => voidpathForHandle: (kind: string, handle: number) => string | nullpreload: (refs: ReadonlyArray<string>, onProgress?: (loaded: number, total: number) => void, options?: { readonly maxConcurrent?: number; }) => Promise<{ failed: MissingAsset[]; }>@@ -917,6 +919,7 @@ releasePrefab: (ref: string) => voidreleaseTexture: (ref: string) => voidreleaseTilemap: (ref: string) => voidreleaseTimeline: (ref: string) => void+rematerializeMeshesAfterDeviceLoss: () => Promise<number>remoteRoot: string | undefinedresolveLoadPath: (ref: string) => stringresolveRef: (ref: string) => string | nulldiff --git a/sdk/etc/index.native.api.md b/sdk/etc/index.native.api.mdindex 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) => () => voidpathForHandle: (kind: string, handle: number) => string | nullpreload: (refs: ReadonlyArray<string>, onProgress?: (loaded: number, total: number) => void, options?: { readonly maxConcurrent?: number; }) => Promise<{ failed: MissingAsset[]; }>@@ -917,6 +919,7 @@ releasePrefab: (ref: string) => voidreleaseTexture: (ref: string) => voidreleaseTilemap: (ref: string) => voidreleaseTimeline: (ref: string) => void+rematerializeMeshesAfterDeviceLoss: () => Promise<number>remoteRoot: string | undefinedresolveLoadPath: (ref: string) => stringresolveRef: (ref: string) => string | nulldiff --git a/sdk/etc/index.node.api.md b/sdk/etc/index.node.api.mdindex 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) => () => voidpathForHandle: (kind: string, handle: number) => string | nullpreload: (refs: ReadonlyArray<string>, onProgress?: (loaded: number, total: number) => void, options?: { readonly maxConcurrent?: number; }) => Promise<{ failed: MissingAsset[]; }>@@ -912,6 +914,7 @@ releasePrefab: (ref: string) => voidreleaseTexture: (ref: string) => voidreleaseTilemap: (ref: string) => voidreleaseTimeline: (ref: string) => void+rematerializeMeshesAfterDeviceLoss: () => Promise<number>remoteRoot: string | undefinedresolveLoadPath: (ref: string) => stringresolveRef: (ref: string) => string | nulldiff --git a/sdk/etc/minigame.api.md b/sdk/etc/minigame.api.mdindex 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) => () => voidpathForHandle: (kind: string, handle: number) => string | nullpreload: (refs: ReadonlyArray<string>, onProgress?: (loaded: number, total: number) => void, options?: { readonly maxConcurrent?: number; }) => Promise<{ failed: MissingAsset[]; }>@@ -912,6 +914,7 @@ releasePrefab: (ref: string) => voidreleaseTexture: (ref: string) => voidreleaseTilemap: (ref: string) => voidreleaseTimeline: (ref: string) => void+rematerializeMeshesAfterDeviceLoss: () => Promise<number>remoteRoot: string | undefinedresolveLoadPath: (ref: string) => stringresolveRef: (ref: string) => string | nulldiff --git a/sdk/etc/wasm.api.md b/sdk/etc/wasm.api.mdindex 0c1027f28..582c203fc 100644--- a/sdk/etc/wasm.api.md+++ b/sdk/etc/wasm.api.md@@ -202,6 +202,9 @@ getTextureRefCount: (handle: number) => numberinvalidateTexturePath: (path: string) => booleanloadBitmapFont: (fntContent: string, textureHandle: number, texWidth: number, texHeight: number) => numbermeasureBitmapText: (fontHandle: number, text: string, fontSize: number, spacing: number) => { width: number; height: number; }+meshRealizations: (() => string) | undefined+meshesAwaitingRemat: (() => string) | undefined+meshesLostNonRecoverable: (() => number) | undefinedregisterExternalTexture: (glTextureId: number, width: number, height: number) => numberregisterExternalTextureSized: (glTextureId: number, width: number, height: number, bytes: number) => numberregisterTextureWithPath: (handle: number, path: string) => void@@ -307,6 +310,7 @@ meshRenderer_setMaterialAll: ((registry: CppRegistry, materialId: number) => nummeshRenderer_setMeshAll: ((registry: CppRegistry, meshHandle: number) => number) | undefinedmesh_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) | undefinedmesh_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) | undefinednotifyDeviceLost: ((reason: number, message: string) => void) | undefinedparticle_getAliveCount: ((entity: number) => number) | undefinedparticle_play: ((registry: CppRegistry, entity: number) => void) | undefineddiff --git a/sdk/etc/wechat.api.md b/sdk/etc/wechat.api.mdindex 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) => () => voidpathForHandle: (kind: string, handle: number) => string | nullpreload: (refs: ReadonlyArray<string>, onProgress?: (loaded: number, total: number) => void, options?: { readonly maxConcurrent?: number; }) => Promise<{ failed: MissingAsset[]; }>@@ -912,6 +914,7 @@ releasePrefab: (ref: string) => voidreleaseTexture: (ref: string) => voidreleaseTilemap: (ref: string) => voidreleaseTimeline: (ref: string) => void+rematerializeMeshesAfterDeviceLoss: () => Promise<number>remoteRoot: string | undefinedresolveLoadPath: (ref: string) => stringresolveRef: (ref: string) => string | nulldiff --git a/sdk/src/asset/Assets.ts b/sdk/src/asset/Assets.tsindex 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.tsindex 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.tsindex 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.cppindex 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.hppindex 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.cppindex 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.cppindex 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.hppindex 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.tsindex 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.mjsindex 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.mjsindex 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