@eva/plugin-renderer-tilemap 2.1.0-beta.5 → 2.1.0-beta.7

package/dist/EVA.plugin.renderer.tilemap.js

@@ -154,6 +154,8 @@ var _EVA_IIFE_tilemap = function (exports, eva_js, pluginRenderer, pixi_js) {
       this.tilesetSpacing = 0;
       this.tilesetMargin = 0;
       this.layers = [];
+      this.tilemapRef = '';
+      this.layersV2 = undefined;
     }
     init(obj) {
       if (obj) _extends(this, obj);
@@ -165,78 +167,758 @@ var _EVA_IIFE_tilemap = function (exports, eva_js, pluginRenderer, pixi_js) {
   __decorate([type('number'), __metadata("design:type", Number)], Tilemap.prototype, "tileHeight", void 0);
   __decorate([type('number'), __metadata("design:type", Number)], Tilemap.prototype, "tilesetSpacing", void 0);
   __decorate([type('number'), __metadata("design:type", Number)], Tilemap.prototype, "tilesetMargin", void 0);
+  __decorate([type('string'), __metadata("design:type", String)], Tilemap.prototype, "tilemapRef", void 0);
+  const CHUNK_SIZE$2 = 16;
+  const CHUNK_CELL_COUNT = CHUNK_SIZE$2 * CHUNK_SIZE$2;
+  function unpackCell(packed) {
+    return {
+      sourceSlot: packed & 0xff,
+      col: packed >>> 8 & 0xff,
+      row: packed >>> 16 & 0xff,
+      altIdx: packed >>> 24 & 0x1f,
+      flipH: (packed >>> 29 & 1) === 1,
+      flipV: (packed >>> 30 & 1) === 1,
+      transpose: (packed >>> 31 & 1) === 1
+    };
+  }
+  function isEmptyCellValue(packed) {
+    return (packed & 0xff) === 0;
+  }
+  function decodeChunk(blob) {
+    const bytes = base64Decode(blob.blob);
+    if (bytes.byteLength !== CHUNK_CELL_COUNT * 4) {
+      throw new Error(`decodeChunk: expected ${CHUNK_CELL_COUNT * 4} bytes, got ${bytes.byteLength}`);
+    }
+    const copy = new Uint8Array(bytes.byteLength);
+    copy.set(bytes);
+    return new Int32Array(copy.buffer);
+  }
+  const BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+  function base64Decode(s) {
+    if (typeof atob === 'function') {
+      const bin = atob(s);
+      const out = new Uint8Array(bin.length);
+      for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+      return out;
+    }
+    const bufCtor = globalThis.Buffer;
+    if (bufCtor) {
+      return new Uint8Array(bufCtor.from(s, 'base64'));
+    }
+    const clean = s.replace(/[^A-Za-z0-9+/]/g, '');
+    const padding = s.endsWith('==') ? 2 : s.endsWith('=') ? 1 : 0;
+    const len = Math.floor(clean.length * 3 / 4) - padding;
+    const out = new Uint8Array(len);
+    let p = 0;
+    for (let i = 0; i < clean.length; i += 4) {
+      const v0 = BASE64_ALPHABET.indexOf(clean[i]);
+      const v1 = BASE64_ALPHABET.indexOf(clean[i + 1]);
+      const v2 = clean[i + 2] ? BASE64_ALPHABET.indexOf(clean[i + 2]) : 0;
+      const v3 = clean[i + 3] ? BASE64_ALPHABET.indexOf(clean[i + 3]) : 0;
+      const w = v0 << 18 | v1 << 12 | v2 << 6 | v3;
+      if (p < len) out[p++] = w >> 16 & 0xff;
+      if (p < len) out[p++] = w >> 8 & 0xff;
+      if (p < len) out[p++] = w & 0xff;
+    }
+    return out;
+  }
+  function makeLoadedTileset(raw) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+    const slotByIdMap = new Map();
+    const sourcesBySlot = [];
+    const seenByAsset = new Map();
+    for (let i = 0; i < raw.sources.length; i++) {
+      const src = raw.sources[i];
+      sourcesBySlot.push(src);
+      slotByIdMap.set(src.id, i + 1);
+      if (src.kind === 'atlas' && src.textureAsset) {
+        const prev = seenByAsset.get(src.textureAsset);
+        if (prev) {
+          const sameRegion = prev.regionSize.width === src.regionSize.width && prev.regionSize.height === src.regionSize.height;
+          const sameMargins = ((_b = (_a = prev.margins) === null || _a === void 0 ? void 0 : _a.x) !== null && _b !== void 0 ? _b : 0) === ((_d = (_c = src.margins) === null || _c === void 0 ? void 0 : _c.x) !== null && _d !== void 0 ? _d : 0) && ((_f = (_e = prev.margins) === null || _e === void 0 ? void 0 : _e.y) !== null && _f !== void 0 ? _f : 0) === ((_h = (_g = src.margins) === null || _g === void 0 ? void 0 : _g.y) !== null && _h !== void 0 ? _h : 0);
+          const sameSep = ((_k = (_j = prev.separation) === null || _j === void 0 ? void 0 : _j.x) !== null && _k !== void 0 ? _k : 0) === ((_m = (_l = src.separation) === null || _l === void 0 ? void 0 : _l.x) !== null && _m !== void 0 ? _m : 0) && ((_p = (_o = prev.separation) === null || _o === void 0 ? void 0 : _o.y) !== null && _p !== void 0 ? _p : 0) === ((_r = (_q = src.separation) === null || _q === void 0 ? void 0 : _q.y) !== null && _r !== void 0 ? _r : 0);
+          if (!sameRegion || !sameMargins || !sameSep) {
+            if (typeof console !== 'undefined') {
+              console.warn(`[Tilemap] Atlas sources '${prev.sourceId}' and '${src.id}' share textureAsset='${src.textureAsset}' ` + `but differ in regionSize/margins/separation. Frame texture cache may collide and render wrong frames. ` + `Use distinct textureAssets per atlas source.`);
+            }
+          }
+        } else {
+          seenByAsset.set(src.textureAsset, {
+            regionSize: src.regionSize,
+            margins: src.margins,
+            separation: src.separation,
+            sourceId: src.id
+          });
+        }
+      }
+    }
+    return {
+      raw,
+      sourcesBySlot,
+      slotByIdMap,
+      tileWidth: raw.tileSize.width,
+      tileHeight: raw.tileSize.height
+    };
+  }
+  class TileAnimationDriver {
+    constructor() {
+      this.animations = [];
+      this.lastFrameIdxByKey = new Map();
+    }
+    loadFromTileset(raw) {
+      var _a;
+      this.animations = [];
+      this.lastFrameIdxByKey.clear();
+      for (let slotIdx = 0; slotIdx < raw.sources.length; slotIdx++) {
+        const src = raw.sources[slotIdx];
+        if (src.kind !== 'atlas') continue;
+        const slot = slotIdx + 1;
+        for (const tile of src.tiles) {
+          const anim = tile.animation;
+          if (!anim || !anim.frames || anim.frames.length === 0) continue;
+          const frames = anim.frames.map(f => {
+            var _a;
+            return {
+              col: f.atlasCoords.col,
+              row: f.atlasCoords.row,
+              durationMs: anim.stepMs * ((_a = f.durationFactor) !== null && _a !== void 0 ? _a : 1)
+            };
+          });
+          const totalDurationMs = frames.reduce((s, f) => s + f.durationMs, 0);
+          if (totalDurationMs <= 0) continue;
+          const phaseOffsetMs = anim.phase === 'randomStart' ? deterministicPhaseOffset(slot, tile.atlasCoords.col, tile.atlasCoords.row, totalDurationMs) : 0;
+          this.animations.push({
+            sourceSlot: slot,
+            col: tile.atlasCoords.col,
+            row: tile.atlasCoords.row,
+            frames,
+            totalDurationMs,
+            phase: (_a = anim.phase) !== null && _a !== void 0 ? _a : 'sync',
+            phaseOffsetMs
+          });
+        }
+      }
+    }
+    get animationCount() {
+      return this.animations.length;
+    }
+    isAnimatedSource(slot, col, row) {
+      for (const a of this.animations) {
+        if (a.sourceSlot === slot && a.col === col && a.row === row) return true;
+      }
+      return false;
+    }
+    advance(nowMs) {
+      const currentFrames = new Map();
+      const dirtyKeys = new Set();
+      for (const anim of this.animations) {
+        const key = `${anim.sourceSlot},${anim.col},${anim.row}`;
+        const t = ((nowMs + anim.phaseOffsetMs) % anim.totalDurationMs + anim.totalDurationMs) % anim.totalDurationMs;
+        let acc = 0;
+        let idx = 0;
+        for (; idx < anim.frames.length; idx++) {
+          acc += anim.frames[idx].durationMs;
+          if (t < acc) break;
+        }
+        if (idx >= anim.frames.length) idx = anim.frames.length - 1;
+        const frame = anim.frames[idx];
+        currentFrames.set(key, {
+          col: frame.col,
+          row: frame.row
+        });
+        const prev = this.lastFrameIdxByKey.get(key);
+        if (prev !== idx) {
+          dirtyKeys.add(key);
+          this.lastFrameIdxByKey.set(key, idx);
+        }
+      }
+      return {
+        currentFrames,
+        dirtyKeys
+      };
+    }
+    reset() {
+      this.lastFrameIdxByKey.clear();
+    }
+  }
+  function deterministicPhaseOffset(slot, col, row, total) {
+    let h = slot * 73856093 ^ col * 19349663 ^ row * 83492791;
+    h = (h ^ h >>> 13) * 1274126177;
+    h = h ^ h >>> 16;
+    const t = (h >>> 0) / 0xffffffff;
+    return Math.floor(t * total);
+  }
+  const TILEMAP_PROBE_NAMES = {
+    DIRTY_REBUILD_MS: 'tilemap.dirtyRebuild.ms',
+    CULL_CHECK_MS: 'tilemap.cullCheck.ms',
+    ANIM_TICK_MS: 'tilemap.animTick.ms',
+    DRAWCALLS_COUNT: 'tilemap.drawcalls.count',
+    DRAWCALLS_BY_ATLAS: 'tilemap.drawcalls.byAtlas',
+    PHYSICS_REBAKE_MS: 'tilemap.physicsRebake.ms',
+    GPU_UPLOAD_MS: 'tilemap.gpuUpload.ms',
+    GPU_UPLOAD_BYTES: 'tilemap.gpuUpload.bytes',
+    AUTOTILE_MS: 'tilemap.autotile.ms',
+    PATCH_APPLY_MS: 'tilemap.patchApply.ms',
+    DIRTY_PENDING: 'tilemap.dirty.pending',
+    DIRTY_FRAMES_BEHIND: 'tilemap.dirty.framesBehind',
+    BODIES_TOTAL: 'tilemap.bodies.total',
+    BODIES_CREATED: 'tilemap.bodies.created',
+    BODIES_DESTROYED: 'tilemap.bodies.destroyed',
+    STRATEGY_SPRITE_COUNT: 'tilemap.strategy.sprite.count',
+    STRATEGY_MESH_COUNT: 'tilemap.strategy.mesh.count',
+    STRATEGY_MESH_FALLBACK_COUNT: 'tilemap.strategy.meshFallback.count',
+    SCENECOLLECTION_SKIPPED_COUNT: 'tilemap.sceneCollection.skipped.count',
+    CULL_HITS_COUNT: 'tilemap.cull.hits',
+    MODE_SWITCH_FAILED_COUNT: 'tilemap.modeSwitch.failed',
+    ANIM_TICK_ERROR_COUNT: 'tilemap.animTick.error.count',
+    CONTEXT_LOST_COUNT: 'tilemap.context.lost'
+  };
+  function createInMemoryProbeRegistry() {
+    const inFlight = new Map();
+    const timings = new Map();
+    const counts = new Map();
+    const gauges = new Map();
+    return {
+      beginTiming(name) {
+        inFlight.set(name, nowMs());
+      },
+      endTiming(name) {
+        const t0 = inFlight.get(name);
+        if (t0 === undefined) return;
+        inFlight.delete(name);
+        const dur = nowMs() - t0;
+        if (!timings.has(name)) timings.set(name, []);
+        timings.get(name).push(dur);
+      },
+      count(name, delta = 1) {
+        var _a;
+        counts.set(name, ((_a = counts.get(name)) !== null && _a !== void 0 ? _a : 0) + delta);
+      },
+      gauge(name, value) {
+        gauges.set(name, value);
+      },
+      histogram(name, value) {
+        this.count(`${name}.histN`);
+        this.count(`${name}.histSum`, value);
+      },
+      timings,
+      counts,
+      gauges
+    };
+  }
+  function nowMs() {
+    if (typeof performance !== 'undefined' && performance.now) return performance.now();
+    return 0;
+  }
+  function adaptGamePerfProbes(game) {
+    var _a, _b, _c, _d;
+    const p = game === null || game === void 0 ? void 0 : game.perfProbes;
+    if (!p) return null;
+    return {
+      beginTiming: (_a = p.beginTiming) !== null && _a !== void 0 ? _a : () => {},
+      endTiming: (_b = p.endTiming) !== null && _b !== void 0 ? _b : () => {},
+      count: (_c = p.count) !== null && _c !== void 0 ? _c : () => {},
+      gauge: (_d = p.gauge) !== null && _d !== void 0 ? _d : () => {},
+      histogram: p.histogram
+    };
+  }
+  function getRequiredTilemapProbes() {
+    return Object.values(TILEMAP_PROBE_NAMES);
+  }
+  function resolveChunkRenderStrategy(ctx) {
+    if (ctx.preference && ctx.preference !== 'auto') return ctx.preference;
+    if (ctx.atlasesInChunk > 1) return 'sprite';
+    if (ctx.nonEmptyCellsInChunk >= 192) return 'mesh';
+    return 'sprite';
+  }
+  function estimateSpriteNodes(nonEmptyCellsInChunk) {
+    return 1 + nonEmptyCellsInChunk;
+  }
+  function buildChunkMesh(_config) {
+    const container = new pixi_js.Container();
+    container.label = `chunk-mesh-stub-${_config.chunkKey}`;
+    return container;
+  }
+  function isMeshPathAvailable() {
+    return false;
+  }
+  function estimateChunkMeshMemoryKB(config) {
+    const cellsBytes = 256 * (32 + 12);
+    return Math.ceil(cellsBytes / 1024);
+  }
   let TilemapSystem = class TilemapSystem extends pluginRenderer.Renderer {
     constructor() {
       super(...arguments);
       this.name = 'Tilemap';
       this.records = {};
+      this.animationDrivers = new Map();
+      this.probes = null;
+      this.isHidden = false;
+      this.contextLost = false;
+      this.canvasWithCtxListeners = null;
     }
     init() {
       this.renderSystem = this.game.getSystem(pluginRenderer.RendererSystem);
       this.renderSystem.rendererManager.register(this);
+      this.probes = adaptGamePerfProbes(this.game);
+      this.installVisibilityHandlers();
+    }
+    installVisibilityHandlers() {
+      var _a, _b, _c;
+      if (typeof document === 'undefined') return;
+      try {
+        this.visibilityListener = () => {
+          this.isHidden = !!document.hidden;
+        };
+        document.addEventListener('visibilitychange', this.visibilityListener);
+      } catch (_d) {}
+      try {
+        const canvas = (_c = (_b = (_a = this.renderSystem) === null || _a === void 0 ? void 0 : _a.application) === null || _b === void 0 ? void 0 : _b.canvas) !== null && _c !== void 0 ? _c : null;
+        if (canvas && typeof canvas.addEventListener === 'function') {
+          this.contextLostListener = () => {
+            this.contextLost = true;
+            this.probeCount(TILEMAP_PROBE_NAMES.CONTEXT_LOST_COUNT, 1);
+            if (typeof console !== 'undefined') {
+              console.warn('[Tilemap] WebGL context lost — pausing animation tick');
+            }
+          };
+          this.contextRestoredListener = () => {
+            this.contextLost = false;
+            if (typeof console !== 'undefined') {
+              console.info('[Tilemap] WebGL context restored — resuming animation tick');
+            }
+          };
+          canvas.addEventListener('webglcontextlost', this.contextLostListener);
+          canvas.addEventListener('webglcontextrestored', this.contextRestoredListener);
+          this.canvasWithCtxListeners = canvas;
+        }
+      } catch (_e) {}
+    }
+    uninstallVisibilityHandlers() {
+      if (typeof document !== 'undefined' && this.visibilityListener) {
+        try {
+          document.removeEventListener('visibilitychange', this.visibilityListener);
+        } catch (_a) {}
+        this.visibilityListener = undefined;
+      }
+      if (this.canvasWithCtxListeners) {
+        try {
+          if (this.contextLostListener) {
+            this.canvasWithCtxListeners.removeEventListener('webglcontextlost', this.contextLostListener);
+          }
+          if (this.contextRestoredListener) {
+            this.canvasWithCtxListeners.removeEventListener('webglcontextrestored', this.contextRestoredListener);
+          }
+        } catch (_b) {}
+        this.contextLostListener = undefined;
+        this.contextRestoredListener = undefined;
+        this.canvasWithCtxListeners = null;
+      }
+    }
+    attachPerfProbes(probes) {
+      this.probes = probes;
+    }
+    setCullingBoundsHint(gameObjectId, bounds) {
+      const record = this.records[gameObjectId];
+      if (!record) return;
+      if (bounds === null) {
+        record.cullingBoundsHint = undefined;
+      } else {
+        record.cullingBoundsHint = bounds;
+      }
+    }
+    invalidateChunks(gameObjectId, layerId, chunkKeys) {
+      const record = this.records[gameObjectId];
+      if (!record || chunkKeys.length === 0) return;
+      let bucket = record.dirtyChunkKeys.get(layerId);
+      if (!bucket) {
+        bucket = new Set();
+        record.dirtyChunkKeys.set(layerId, bucket);
+      }
+      for (const k of chunkKeys) bucket.add(k);
+      let total = 0;
+      for (const s of record.dirtyChunkKeys.values()) total += s.size;
+      this.probeGauge(TILEMAP_PROBE_NAMES.DIRTY_PENDING, total);
+      if (!record.flushScheduled) {
+        record.flushScheduled = true;
+        const sched = typeof requestAnimationFrame !== 'undefined' ? requestAnimationFrame : cb => setTimeout(() => cb(0), 16);
+        sched(() => this.flushDirtyChunks(gameObjectId));
+      }
+    }
+    flushDirtyChunks(gameObjectId) {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+      const record = this.records[gameObjectId];
+      if (!record) return;
+      record.flushScheduled = false;
+      if (record.dirtyChunkKeys.size === 0) return;
+      if (record.mode !== 'v2' || !record.loadedTileset) {
+        record.dirtyChunkKeys.clear();
+        this.probeGauge(TILEMAP_PROBE_NAMES.DIRTY_PENDING, 0);
+        return;
+      }
+      this.probeCount(TILEMAP_PROBE_NAMES.DIRTY_FRAMES_BEHIND, 1);
+      const loaded = record.loadedTileset;
+      const animDriver = (_a = this.animationDrivers.get(gameObjectId)) !== null && _a !== void 0 ? _a : null;
+      const game = this.game;
+      let component = null;
+      if (game === null || game === void 0 ? void 0 : game.gameObjects) {
+        for (const go of game.gameObjects) {
+          if (go.id !== gameObjectId) continue;
+          const c = (_b = go.components) === null || _b === void 0 ? void 0 : _b.find(cc => (cc === null || cc === void 0 ? void 0 : cc.name) === 'Tilemap');
+          if (c) {
+            component = c;
+            break;
+          }
+        }
+      }
+      const cellW = (_d = (_c = component === null || component === void 0 ? void 0 : component.cellSize) === null || _c === void 0 ? void 0 : _c.width) !== null && _d !== void 0 ? _d : loaded.tileWidth;
+      const cellH = (_f = (_e = component === null || component === void 0 ? void 0 : component.cellSize) === null || _e === void 0 ? void 0 : _e.height) !== null && _f !== void 0 ? _f : loaded.tileHeight;
+      const originX = (_h = (_g = component === null || component === void 0 ? void 0 : component.mapOrigin) === null || _g === void 0 ? void 0 : _g.x) !== null && _h !== void 0 ? _h : 0;
+      const originY = (_k = (_j = component === null || component === void 0 ? void 0 : component.mapOrigin) === null || _j === void 0 ? void 0 : _j.y) !== null && _k !== void 0 ? _k : 0;
+      this.probeBegin(TILEMAP_PROBE_NAMES.DIRTY_REBUILD_MS);
+      try {
+        for (const [layerId, chunkKeys] of record.dirtyChunkKeys) {
+          const layerEntry = record.layerContainersV2.get(layerId);
+          if (!layerEntry) continue;
+          const layerSpec = (_m = (_l = component === null || component === void 0 ? void 0 : component.layersV2) === null || _l === void 0 ? void 0 : _l.find(l => l.id === layerId)) !== null && _m !== void 0 ? _m : null;
+          if (!layerSpec) continue;
+          for (const chunkKey of chunkKeys) {
+            const oldChunkContainer = layerEntry.chunkContainers.get(chunkKey);
+            if (oldChunkContainer) {
+              layerEntry.container.removeChild(oldChunkContainer);
+              try {
+                oldChunkContainer.destroy({
+                  children: true
+                });
+              } catch (_q) {}
+              layerEntry.chunkContainers.delete(chunkKey);
+            }
+            const blob = (_p = (_o = layerSpec.cellData) === null || _o === void 0 ? void 0 : _o.chunks) === null || _p === void 0 ? void 0 : _p[chunkKey];
+            if (!blob || blob.nonEmpty <= 0) continue;
+            const chunkContainer = new pixi_js.Container();
+            chunkContainer.label = `chunk-${chunkKey}`;
+            this.populateChunkSprites(chunkContainer, chunkKey, blob, record, loaded, cellW, cellH, originX, originY, layerSpec, animDriver);
+            layerEntry.container.addChild(chunkContainer);
+            layerEntry.chunkContainers.set(chunkKey, chunkContainer);
+          }
+        }
+      } finally {
+        this.probeEnd(TILEMAP_PROBE_NAMES.DIRTY_REBUILD_MS);
+      }
+      record.dirtyChunkKeys.clear();
+      this.probeGauge(TILEMAP_PROBE_NAMES.DIRTY_PENDING, 0);
+      this.requestRedraw();
+    }
+    probeBegin(name) {
+      var _a;
+      (_a = this.probes) === null || _a === void 0 ? void 0 : _a.beginTiming(name);
+    }
+    probeEnd(name) {
+      var _a;
+      (_a = this.probes) === null || _a === void 0 ? void 0 : _a.endTiming(name);
+    }
+    probeCount(name, delta = 1) {
+      var _a;
+      (_a = this.probes) === null || _a === void 0 ? void 0 : _a.count(name, delta);
+    }
+    probeGauge(name, value) {
+      var _a;
+      (_a = this.probes) === null || _a === void 0 ? void 0 : _a.gauge(name, value);
     }
     rendererUpdate(_gameObject) {}
+    update(_frame) {
+      if (this.isHidden || this.contextLost) return;
+      if (this.animationDrivers.size === 0) return;
+      this.probeBegin(TILEMAP_PROBE_NAMES.ANIM_TICK_MS);
+      let totalSpritesSwapped = 0;
+      try {
+        const now = typeof performance !== 'undefined' && performance.now ? performance.now() : 0;
+        for (const [gameObjectId, driver] of this.animationDrivers) {
+          const record = this.records[gameObjectId];
+          if (!record || record.mode !== 'v2') continue;
+          try {
+            const result = driver.advance(now);
+            if (result.dirtyKeys.size === 0) continue;
+            const loaded = record.loadedTileset;
+            if (!loaded) continue;
+            let anyApplied = false;
+            for (const animKey of result.dirtyKeys) {
+              const sprites = record.animatedSpritesByAnimKey.get(animKey);
+              if (!sprites || sprites.length === 0) continue;
+              const nextFrame = result.currentFrames.get(animKey);
+              if (!nextFrame) continue;
+              const parts = animKey.split(',');
+              const slot = Number.parseInt(parts[0], 10);
+              const newTex = this.getAtlasFrameTexture(record, loaded, {
+                sourceSlot: slot,
+                col: nextFrame.col,
+                row: nextFrame.row
+              });
+              if (!newTex) continue;
+              for (const sp of sprites) {
+                sp.texture = newTex;
+                anyApplied = true;
+                totalSpritesSwapped++;
+              }
+            }
+            if (anyApplied) this.requestRedraw();
+          } catch (e) {
+            this.probeCount(TILEMAP_PROBE_NAMES.ANIM_TICK_ERROR_COUNT, 1);
+            if (typeof console !== 'undefined') {
+              console.error(`[Tilemap] animation tick failed for entity ${gameObjectId}`, e);
+            }
+          }
+        }
+      } finally {
+        this.probeEnd(TILEMAP_PROBE_NAMES.ANIM_TICK_MS);
+        if (totalSpritesSwapped > 0) this.probeCount('tilemap.anim.spritesSwapped', totalSpritesSwapped);
+      }
+    }
     componentChanged(changed) {
-      var _a, _b, _c;
       return __awaiter(this, void 0, void 0, function* () {
         if (changed.componentName !== 'Tilemap') return;
         const component = changed.component;
         const gameObjectId = changed.gameObject.id;
         if (changed.type === eva_js.OBSERVER_TYPE.ADD) {
+          yield this.handleAdd(gameObjectId, changed.gameObject, component);
+        } else if (changed.type === eva_js.OBSERVER_TYPE.CHANGE) {
+          yield this.handleChange(gameObjectId, component, changed);
+        } else if (changed.type === eva_js.OBSERVER_TYPE.REMOVE) {
+          this.handleRemove(gameObjectId);
+        }
+      });
+    }
+    handleAdd(gameObjectId, gameObject, component) {
+      return __awaiter(this, void 0, void 0, function* () {
+        this.probeBegin(TILEMAP_PROBE_NAMES.DIRTY_REBUILD_MS);
+        try {
           const asyncId = this.increaseAsyncId(gameObjectId);
-          let texture = null;
-          if (component.tileset) {
-            const {
-              instance
-            } = yield eva_js.resource.getResource(component.tileset);
-            if (!this.validateAsyncId(gameObjectId, asyncId)) return;
-            if (!instance) {
-              console.error(`GameObject:${changed.gameObject.name}'s Tilemap tileset load error`);
-              return;
-            }
-            texture = instance;
-          }
-          if (!texture) return;
+          const mode = this.detectMode(component);
           const root = new pixi_js.Container();
-          const container = this.containerManager.getContainer(gameObjectId);
-          if (container) container.addChildAt(root, 0);
+          const containerHost = this.containerManager.getContainer(gameObjectId);
+          if (containerHost) containerHost.addChildAt(root, 0);
           const record = {
             root,
             layerContainers: [],
+            layerContainersV2: new Map(),
             frameTextures: [],
-            baseTexture: texture
+            frameTexturesV2: new Map(),
+            baseTexture: null,
+            atlasTextures: new Map(),
+            loadedTileset: null,
+            mode,
+            animatedSpritesByAnimKey: new Map(),
+            sceneCollectionWarnedSourceIds: new Set(),
+            dirtyChunkKeys: new Map(),
+            flushScheduled: false
           };
           this.records[gameObjectId] = record;
-          this.buildLayers(record, component);
-        } else if (changed.type === eva_js.OBSERVER_TYPE.CHANGE) {
-          const record = this.records[gameObjectId];
-          if (!record) return;
-          if (((_b = (_a = changed.prop) === null || _a === void 0 ? void 0 : _a.prop) === null || _b === void 0 ? void 0 : _b[0]) === 'tileset') {
+          if (mode === 'v1') {
+            yield this.ensureV1Built(record, gameObjectId, gameObject, component, asyncId);
+          } else if (mode === 'v2') {
+            yield this.ensureV2Built(record, gameObjectId, gameObject, component, asyncId);
+          }
+        } finally {
+          this.probeEnd(TILEMAP_PROBE_NAMES.DIRTY_REBUILD_MS);
+        }
+      });
+    }
+    ensureV1Built(record, gameObjectId, gameObject, component, asyncId) {
+      return __awaiter(this, void 0, void 0, function* () {
+        const texture = yield this.loadV1Texture(component);
+        if (!this.validateAsyncId(gameObjectId, asyncId)) return;
+        if (!texture) {
+          if (typeof console !== 'undefined') {
+            console.error(`GameObject:${gameObject.name}'s Tilemap tileset load error`);
+          }
+          return;
+        }
+        record.baseTexture = texture;
+        this.buildLayersV1(record, component);
+        this.requestRedraw();
+      });
+    }
+    ensureV2Built(record, gameObjectId, gameObject, component, asyncId) {
+      return __awaiter(this, void 0, void 0, function* () {
+        const loaded = yield this.loadV2Tileset(component);
+        if (!this.validateAsyncId(gameObjectId, asyncId)) return;
+        if (!loaded) {
+          if (typeof console !== 'undefined') {
+            console.error(`GameObject:${gameObject.name}'s Tilemap tilemapRef load error`);
+          }
+          return;
+        }
+        record.loadedTileset = loaded;
+        yield this.loadAtlasTextures(record, loaded);
+        if (!this.validateAsyncId(gameObjectId, asyncId)) return;
+        const animDriver = new TileAnimationDriver();
+        animDriver.loadFromTileset(loaded.raw);
+        const driverForBuild = animDriver.animationCount > 0 ? animDriver : null;
+        if (driverForBuild) this.animationDrivers.set(gameObjectId, driverForBuild);
+        this.buildLayersV2(record, component, driverForBuild);
+        this.requestRedraw();
+      });
+    }
+    requestRedraw() {
+      var _a;
+      try {
+        const app = (_a = this.renderSystem) === null || _a === void 0 ? void 0 : _a.application;
+        if ((app === null || app === void 0 ? void 0 : app.renderer) && app.stage) {
+          app.renderer.render(app.stage);
+        }
+      } catch (e) {
+        if (typeof console !== 'undefined') {
+          console.warn('[Tilemap] requestRedraw failed', e);
+        }
+      }
+    }
+    handleChange(gameObjectId, component, changed) {
+      var _a, _b;
+      return __awaiter(this, void 0, void 0, function* () {
+        const record = this.records[gameObjectId];
+        if (!record) return;
+        const prop = (_b = (_a = changed.prop) === null || _a === void 0 ? void 0 : _a.prop) === null || _b === void 0 ? void 0 : _b[0];
+        this.probeBegin(TILEMAP_PROBE_NAMES.PATCH_APPLY_MS);
+        try {
+          const newMode = this.detectMode(component);
+          if (newMode !== record.mode) {
+            const asyncId = this.increaseAsyncId(gameObjectId);
+            try {
+              if (record.mode === 'v1') {
+                this.tearDownChildrenV1(record);
+              } else if (record.mode === 'v2') {
+                this.tearDownChildrenV2(record);
+                this.animationDrivers.delete(gameObjectId);
+              }
+              record.baseTexture = null;
+              record.loadedTileset = null;
+              if (newMode === 'v1') {
+                const texture = yield this.loadV1Texture(component);
+                if (!this.validateAsyncId(gameObjectId, asyncId)) return;
+                if (!texture) {
+                  record.mode = 'unknown';
+                  this.probeCount(TILEMAP_PROBE_NAMES.MODE_SWITCH_FAILED_COUNT, 1);
+                  if (typeof console !== 'undefined') {
+                    console.error(`GameObject:${changed.gameObject.name}'s Tilemap mode-switch v→v1 failed (tileset load returned null)`);
+                  }
+                  return;
+                }
+                record.mode = 'v1';
+                record.baseTexture = texture;
+                this.buildLayersV1(record, component);
+                this.requestRedraw();
+              } else if (newMode === 'v2') {
+                const loaded = yield this.loadV2Tileset(component);
+                if (!this.validateAsyncId(gameObjectId, asyncId)) return;
+                if (!loaded) {
+                  record.mode = 'unknown';
+                  this.probeCount(TILEMAP_PROBE_NAMES.MODE_SWITCH_FAILED_COUNT, 1);
+                  if (typeof console !== 'undefined') {
+                    console.error(`GameObject:${changed.gameObject.name}'s Tilemap mode-switch v→v2 failed (tilemapRef load returned null)`);
+                  }
+                  return;
+                }
+                yield this.loadAtlasTextures(record, loaded);
+                if (!this.validateAsyncId(gameObjectId, asyncId)) return;
+                record.mode = 'v2';
+                record.loadedTileset = loaded;
+                const animDriver = new TileAnimationDriver();
+                animDriver.loadFromTileset(loaded.raw);
+                const driverForBuild = animDriver.animationCount > 0 ? animDriver : null;
+                if (driverForBuild) this.animationDrivers.set(gameObjectId, driverForBuild);
+                this.buildLayersV2(record, component, driverForBuild);
+                this.requestRedraw();
+              } else {
+                record.mode = 'unknown';
+              }
+            } catch (e) {
+              record.mode = 'unknown';
+              this.probeCount(TILEMAP_PROBE_NAMES.MODE_SWITCH_FAILED_COUNT, 1);
+              if (typeof console !== 'undefined') {
+                console.error('[Tilemap] mode switch threw', e);
+              }
+            }
+            return;
+          }
+          if (prop === 'tileset' && record.mode === 'v1') {
+            const asyncId = this.increaseAsyncId(gameObjectId);
+            const texture = yield this.loadV1Texture(component);
+            if (!this.validateAsyncId(gameObjectId, asyncId)) return;
+            if (!texture) return;
+            this.tearDownChildrenV1(record);
+            record.baseTexture = texture;
+            this.buildLayersV1(record, component);
+            this.requestRedraw();
+          } else if (prop === 'tilemapRef' && record.mode === 'v2') {
             const asyncId = this.increaseAsyncId(gameObjectId);
-            const {
-              instance
-            } = yield eva_js.resource.getResource(component.tileset);
+            const loaded = yield this.loadV2Tileset(component);
+            if (!this.validateAsyncId(gameObjectId, asyncId)) return;
+            if (!loaded) return;
+            this.tearDownChildrenV2(record);
+            record.loadedTileset = loaded;
+            yield this.loadAtlasTextures(record, loaded);
             if (!this.validateAsyncId(gameObjectId, asyncId)) return;
-            if (!instance) return;
-            this.tearDownChildren(record);
-            record.baseTexture = instance;
-            this.buildLayers(record, component);
+            this.animationDrivers.delete(gameObjectId);
+            const animDriver = new TileAnimationDriver();
+            animDriver.loadFromTileset(loaded.raw);
+            const driverForBuild = animDriver.animationCount > 0 ? animDriver : null;
+            if (driverForBuild) this.animationDrivers.set(gameObjectId, driverForBuild);
+            this.buildLayersV2(record, component, driverForBuild);
+            this.requestRedraw();
+          } else if (prop === 'layersV2' && record.mode === 'v2') {
+            this.tearDownChildrenV2(record);
+            this.animationDrivers.delete(gameObjectId);
+            record.dirtyChunkKeys.clear();
+            const loaded = record.loadedTileset;
+            let driverForBuild = null;
+            if (loaded) {
+              const animDriver = new TileAnimationDriver();
+              animDriver.loadFromTileset(loaded.raw);
+              if (animDriver.animationCount > 0) {
+                driverForBuild = animDriver;
+                this.animationDrivers.set(gameObjectId, animDriver);
+              }
+            }
+            this.buildLayersV2(record, component, driverForBuild);
+            this.requestRedraw();
           }
-        } else if (changed.type === eva_js.OBSERVER_TYPE.REMOVE) {
-          this.increaseAsyncId(gameObjectId);
-          const record = this.records[gameObjectId];
-          if (!record) return;
-          this.tearDownChildren(record);
-          const container = (_c = this.containerManager) === null || _c === void 0 ? void 0 : _c.getContainer(gameObjectId);
-          if (container) container.removeChild(record.root);
-          record.root.destroy({
-            children: true
-          });
-          delete this.records[gameObjectId];
+        } finally {
+          this.probeEnd(TILEMAP_PROBE_NAMES.PATCH_APPLY_MS);
         }
       });
     }
-    tearDownChildren(record) {
+    handleRemove(gameObjectId) {
+      var _a;
+      this.increaseAsyncId(gameObjectId);
+      const record = this.records[gameObjectId];
+      if (!record) return;
+      this.tearDownChildrenV1(record);
+      this.tearDownChildrenV2(record);
+      const containerHost = (_a = this.containerManager) === null || _a === void 0 ? void 0 : _a.getContainer(gameObjectId);
+      if (containerHost) containerHost.removeChild(record.root);
+      record.root.destroy({
+        children: true
+      });
+      delete this.records[gameObjectId];
+      this.animationDrivers.delete(gameObjectId);
+      this.probeGauge('tilemap.records.alive', Object.keys(this.records).length);
+    }
+    detectMode(component) {
+      if (component.tilemapRef) return 'v2';
+      if (component.tileset) return 'v1';
+      return 'unknown';
+    }
+    loadV1Texture(component) {
+      var _a;
+      return __awaiter(this, void 0, void 0, function* () {
+        if (!component.tileset) return null;
+        const {
+          instance
+        } = yield eva_js.resource.getResource(component.tileset);
+        return (_a = instance) !== null && _a !== void 0 ? _a : null;
+      });
+    }
+    tearDownChildrenV1(record) {
       for (const layer of record.layerContainers) {
         record.root.removeChild(layer);
         layer.destroy({
@@ -251,7 +933,7 @@ var _EVA_IIFE_tilemap = function (exports, eva_js, pluginRenderer, pixi_js) {
       }
       record.frameTextures = [];
     }
-    buildLayers(record, component) {
+    buildLayersV1(record, component) {
       var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
       const base = record.baseTexture;
       if (!base) return;
@@ -264,12 +946,12 @@ var _EVA_IIFE_tilemap = function (exports, eva_js, pluginRenderer, pixi_js) {
       const sourceWidth = (_j = (_g = (_f = (_d = (_c = base.orig) === null || _c === void 0 ? void 0 : _c.width) !== null && _d !== void 0 ? _d : (_e = base.source) === null || _e === void 0 ? void 0 : _e.width) !== null && _f !== void 0 ? _f : base.width) !== null && _g !== void 0 ? _g : (_h = base.frame) === null || _h === void 0 ? void 0 : _h.width) !== null && _j !== void 0 ? _j : 0;
       const inferredCols = sourceWidth > 0 ? Math.max(1, Math.floor((sourceWidth - margin + spacing) / (tileW + spacing))) : 1;
       const cols = component.tilesetColumns && component.tilesetColumns > 0 ? component.tilesetColumns : inferredCols;
-      const tilesetCache = new Map();
+      const cache = new Map();
       const getFrameTexture = tileId => {
         var _a, _b;
         if (tileId <= 0) return null;
         const idx = tileId - 1;
-        const cached = tilesetCache.get(idx);
+        const cached = cache.get(idx);
         if (cached) return cached;
         const col = idx % cols;
         const row = Math.floor(idx / cols);
@@ -281,7 +963,7 @@ var _EVA_IIFE_tilemap = function (exports, eva_js, pluginRenderer, pixi_js) {
             source,
             frame: new pixi_js.Rectangle(x, y, tileW, tileH)
           });
-          tilesetCache.set(idx, sub);
+          cache.set(idx, sub);
           record.frameTextures.push(sub);
           return sub;
         } catch (e) {
@@ -321,12 +1003,274 @@ var _EVA_IIFE_tilemap = function (exports, eva_js, pluginRenderer, pixi_js) {
         record.layerContainers.push(layerContainer);
       }
     }
+    loadV2Tileset(component) {
+      var _a, _b;
+      return __awaiter(this, void 0, void 0, function* () {
+        if (!component.tilemapRef) return null;
+        const res = yield eva_js.resource.getResource(component.tilemapRef);
+        if (!res) return null;
+        const json = (_a = res.instance) !== null && _a !== void 0 ? _a : (_b = res.data) === null || _b === void 0 ? void 0 : _b.json;
+        if (!json || json.kind !== 'tileset') {
+          if (typeof console !== 'undefined') {
+            console.error(`[Tilemap] resource '${component.tilemapRef}' is not a TileSet document`);
+          }
+          return null;
+        }
+        return makeLoadedTileset(json);
+      });
+    }
+    loadAtlasTextures(record, loaded) {
+      return __awaiter(this, void 0, void 0, function* () {
+        const assetsToLoad = new Set();
+        for (const src of loaded.sourcesBySlot) {
+          if (src.kind === 'atlas' && src.textureAsset) assetsToLoad.add(src.textureAsset);
+        }
+        yield Promise.all(Array.from(assetsToLoad).map(assetId => __awaiter(this, void 0, void 0, function* () {
+          var _a, _b, _c;
+          try {
+            const res = yield eva_js.resource.getResource(assetId);
+            const texture = (_c = (_a = res === null || res === void 0 ? void 0 : res.instance) !== null && _a !== void 0 ? _a : (_b = res === null || res === void 0 ? void 0 : res.data) === null || _b === void 0 ? void 0 : _b.image) !== null && _c !== void 0 ? _c : null;
+            if (texture) record.atlasTextures.set(assetId, texture);
+          } catch (e) {
+            if (typeof console !== 'undefined') {
+              console.warn(`[Tilemap] failed to load atlas asset '${assetId}'`, e);
+            }
+          }
+        })));
+      });
+    }
+    tearDownChildrenV2(record) {
+      for (const {
+        container
+      } of record.layerContainersV2.values()) {
+        record.root.removeChild(container);
+        container.destroy({
+          children: true
+        });
+      }
+      record.layerContainersV2.clear();
+      for (const tex of record.frameTexturesV2.values()) {
+        try {
+          tex.destroy(false);
+        } catch (_a) {}
+      }
+      record.frameTexturesV2.clear();
+      record.animatedSpritesByAnimKey.clear();
+    }
+    buildLayersV2(record, component, animDriver) {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+      const loaded = record.loadedTileset;
+      if (!loaded) return;
+      const cellW = (_b = (_a = component.cellSize) === null || _a === void 0 ? void 0 : _a.width) !== null && _b !== void 0 ? _b : loaded.tileWidth;
+      const cellH = (_d = (_c = component.cellSize) === null || _c === void 0 ? void 0 : _c.height) !== null && _d !== void 0 ? _d : loaded.tileHeight;
+      const originX = (_f = (_e = component.mapOrigin) === null || _e === void 0 ? void 0 : _e.x) !== null && _f !== void 0 ? _f : 0;
+      const originY = (_h = (_g = component.mapOrigin) === null || _g === void 0 ? void 0 : _g.y) !== null && _h !== void 0 ? _h : 0;
+      const layers = (_j = component.layersV2) !== null && _j !== void 0 ? _j : [];
+      const sorted = layers.map((l, i) => ({
+        layer: l,
+        idx: i
+      })).sort((a, b) => {
+        var _a, _b;
+        return ((_a = a.layer.zIndex) !== null && _a !== void 0 ? _a : 0) - ((_b = b.layer.zIndex) !== null && _b !== void 0 ? _b : 0);
+      });
+      for (const {
+        layer
+      } of sorted) {
+        if (layer.enabled === false) continue;
+        const container = new pixi_js.Container();
+        container.label = (_k = layer.name) !== null && _k !== void 0 ? _k : layer.id;
+        container.alpha = (_l = layer.opacity) !== null && _l !== void 0 ? _l : 1;
+        container.visible = layer.visible !== false;
+        const chunkContainers = new Map();
+        this.buildChunksForLayer(record, container, chunkContainers, layer, loaded, cellW, cellH, originX, originY, animDriver);
+        record.root.addChild(container);
+        record.layerContainersV2.set(layer.id, {
+          container,
+          chunkContainers
+        });
+      }
+    }
+    buildChunksForLayer(record, layerContainer, chunkContainers, layer, loaded, cellW, cellH, originX, originY, animDriver) {
+      var _a;
+      const cellData = layer.cellData;
+      if (!cellData || !cellData.chunks) return;
+      const visibleChunks = Object.entries(cellData.chunks).filter(([, b]) => b && b.nonEmpty > 0);
+      const totalChunksVisible = visibleChunks.length;
+      const cullingHint = (_a = record.cullingBoundsHint) !== null && _a !== void 0 ? _a : null;
+      let culledCount = 0;
+      this.probeBegin(TILEMAP_PROBE_NAMES.CULL_CHECK_MS);
+      for (const [chunkKey, blob] of visibleChunks) {
+        if (cullingHint) {
+          const parts = chunkKey.split(',');
+          const ckX = Number.parseInt(parts[0], 10);
+          const ckY = Number.parseInt(parts[1], 10);
+          const chunkMinX = originX + ckX * CHUNK_SIZE$2 * cellW;
+          const chunkMinY = originY + ckY * CHUNK_SIZE$2 * cellH;
+          const chunkMaxX = chunkMinX + CHUNK_SIZE$2 * cellW;
+          const chunkMaxY = chunkMinY + CHUNK_SIZE$2 * cellH;
+          const intersects = chunkMaxX > cullingHint.minX && chunkMinX < cullingHint.maxX && chunkMaxY > cullingHint.minY && chunkMinY < cullingHint.maxY;
+          if (!intersects) {
+            culledCount++;
+            continue;
+          }
+        }
+        const chunkContainer = new pixi_js.Container();
+        chunkContainer.label = `chunk-${chunkKey}`;
+        let atlasesInChunk = 1;
+        let preDecoded = null;
+        try {
+          preDecoded = decodeChunk(blob);
+          const seenAtlasSlots = new Set();
+          for (let i = 0; i < preDecoded.length; i++) {
+            const v = preDecoded[i];
+            if (isEmptyCellValue(v)) continue;
+            const slot = v & 0xff;
+            const src = loaded.sourcesBySlot[slot - 1];
+            if (src && src.kind === 'atlas') seenAtlasSlots.add(slot);
+          }
+          atlasesInChunk = Math.max(1, seenAtlasSlots.size);
+        } catch (_b) {
+          atlasesInChunk = 1;
+          preDecoded = null;
+        }
+        const strategy = resolveChunkRenderStrategy({
+          nonEmptyCellsInChunk: blob.nonEmpty,
+          atlasesInChunk,
+          totalChunksVisible
+        });
+        let dispatched = 'sprite';
+        if (strategy === 'mesh') {
+          if (this.tryBuildMeshChunk(chunkContainer, chunkKey, blob, loaded, cellW, cellH, originX, originY, layer)) {
+            dispatched = 'mesh';
+          } else {
+            dispatched = 'meshFallback';
+            this.probeCount(TILEMAP_PROBE_NAMES.STRATEGY_MESH_FALLBACK_COUNT, 1);
+            this.populateChunkSprites(chunkContainer, chunkKey, blob, record, loaded, cellW, cellH, originX, originY, layer, animDriver, preDecoded);
+          }
+        } else {
+          this.populateChunkSprites(chunkContainer, chunkKey, blob, record, loaded, cellW, cellH, originX, originY, layer, animDriver, preDecoded);
+        }
+        if (dispatched === 'sprite') this.probeCount(TILEMAP_PROBE_NAMES.STRATEGY_SPRITE_COUNT, 1);else if (dispatched === 'mesh') this.probeCount(TILEMAP_PROBE_NAMES.STRATEGY_MESH_COUNT, 1);
+        layerContainer.addChild(chunkContainer);
+        chunkContainers.set(chunkKey, chunkContainer);
+      }
+      this.probeEnd(TILEMAP_PROBE_NAMES.CULL_CHECK_MS);
+      if (culledCount > 0) this.probeCount(TILEMAP_PROBE_NAMES.CULL_HITS_COUNT, culledCount);
+    }
+    tryBuildMeshChunk(chunkContainer, chunkKey, blob, loaded, cellW, cellH, _originX, _originY, _layer) {
+      return false;
+    }
+    populateChunkSprites(chunkContainer, chunkKey, blob, record, loaded, cellW, cellH, originX, originY, layer, animDriver, decoded) {
+      let arr;
+      if (decoded) {
+        arr = decoded;
+      } else {
+        try {
+          arr = decodeChunk(blob);
+        } catch (e) {
+          if (typeof console !== 'undefined') {
+            console.warn(`[Tilemap] chunk decode failed for ${chunkKey}`, e);
+          }
+          return;
+        }
+      }
+      const parts = chunkKey.split(',');
+      const ckX = Number.parseInt(parts[0], 10);
+      const ckY = Number.parseInt(parts[1], 10);
+      const baseCx = ckX * CHUNK_SIZE$2;
+      const baseCy = ckY * CHUNK_SIZE$2;
+      const tintNum = parseHexTint(layer.modulate);
+      let spritesInChunk = 0;
+      for (let ly = 0; ly < CHUNK_SIZE$2; ly++) {
+        for (let lx = 0; lx < CHUNK_SIZE$2; lx++) {
+          const packed = arr[ly * CHUNK_SIZE$2 + lx];
+          if (isEmptyCellValue(packed)) continue;
+          const cell = unpackCell(packed);
+          const tex = this.getAtlasFrameTexture(record, loaded, cell);
+          if (!tex) continue;
+          const sprite = new pixi_js.Sprite(tex);
+          spritesInChunk++;
+          sprite.x = originX + (baseCx + lx) * cellW;
+          sprite.y = originY + (baseCy + ly) * cellH;
+          sprite.width = cellW;
+          sprite.height = cellH;
+          if (cell.flipH) sprite.scale.x = -Math.abs(sprite.scale.x || 1);
+          if (cell.flipV) sprite.scale.y = -Math.abs(sprite.scale.y || 1);
+          if (cell.transpose) sprite.rotation = Math.PI / 2;
+          if (cell.flipH) sprite.x += cellW;
+          if (cell.flipV) sprite.y += cellH;
+          if (tintNum != null) sprite.tint = tintNum;
+          chunkContainer.addChild(sprite);
+          if (animDriver && animDriver.isAnimatedSource(cell.sourceSlot, cell.col, cell.row)) {
+            const animKey = `${cell.sourceSlot},${cell.col},${cell.row}`;
+            let bucket = record.animatedSpritesByAnimKey.get(animKey);
+            if (!bucket) {
+              bucket = [];
+              record.animatedSpritesByAnimKey.set(animKey, bucket);
+            }
+            bucket.push(sprite);
+          }
+        }
+      }
+      if (spritesInChunk > 0) {
+        this.probeCount(TILEMAP_PROBE_NAMES.DRAWCALLS_COUNT, spritesInChunk);
+      }
+    }
+    getAtlasFrameTexture(record, loaded, cell) {
+      var _a, _b, _c, _d;
+      const src = loaded.sourcesBySlot[cell.sourceSlot - 1];
+      if (!src) return null;
+      if (src.kind !== 'atlas') {
+        if (src.kind === 'sceneCollection') {
+          this.probeCount(TILEMAP_PROBE_NAMES.SCENECOLLECTION_SKIPPED_COUNT, 1);
+          if (!record.sceneCollectionWarnedSourceIds.has(src.id)) {
+            record.sceneCollectionWarnedSourceIds.add(src.id);
+            if (typeof console !== 'undefined') {
+              console.warn(`[Tilemap] sceneCollection source '${src.id}' cells are not yet rendered ` + `(prefab instantiation pending). Skipped cell at slot=${cell.sourceSlot} col=${cell.col} row=${cell.row}.`);
+            }
+          }
+        }
+        return null;
+      }
+      const atlas = record.atlasTextures.get(src.textureAsset);
+      if (!atlas) return null;
+      const margins = (_a = src.margins) !== null && _a !== void 0 ? _a : {
+        x: 0,
+        y: 0
+      };
+      const sep = (_b = src.separation) !== null && _b !== void 0 ? _b : {
+        x: 0,
+        y: 0
+      };
+      const fw = src.regionSize.width;
+      const fh = src.regionSize.height;
+      const cacheKey = `${src.textureAsset}#${fw}x${fh}|${margins.x},${margins.y}|${sep.x},${sep.y}#${cell.col},${cell.row}`;
+      const cached = record.frameTexturesV2.get(cacheKey);
+      if (cached) return cached;
+      const fx = margins.x + cell.col * (fw + sep.x);
+      const fy = margins.y + cell.row * (fh + sep.y);
+      try {
+        const source = (_d = (_c = atlas.source) !== null && _c !== void 0 ? _c : atlas.baseTexture) !== null && _d !== void 0 ? _d : atlas;
+        const sub = new pixi_js.Texture({
+          source,
+          frame: new pixi_js.Rectangle(fx, fy, fw, fh)
+        });
+        record.frameTexturesV2.set(cacheKey, sub);
+        return sub;
+      } catch (e) {
+        if (typeof console !== 'undefined') {
+          console.warn(`[Tilemap] frame slice failed for ${cacheKey}`, e);
+        }
+        return null;
+      }
+    }
     destroy() {
       var _a;
       for (const key in this.records) {
         const id = parseInt(key);
         const record = this.records[id];
-        this.tearDownChildren(record);
+        this.tearDownChildrenV1(record);
+        this.tearDownChildrenV2(record);
         const container = (_a = this.containerManager) === null || _a === void 0 ? void 0 : _a.getContainer(id);
         if (container) container.removeChild(record.root);
         record.root.destroy({
@@ -334,6 +1278,7 @@ var _EVA_IIFE_tilemap = function (exports, eva_js, pluginRenderer, pixi_js) {
         });
         delete this.records[id];
       }
+      this.uninstallVisibilityHandlers();
     }
   };
   TilemapSystem.systemName = 'Tilemap';
@@ -341,11 +1286,646 @@ var _EVA_IIFE_tilemap = function (exports, eva_js, pluginRenderer, pixi_js) {
     Tilemap: [{
       prop: ['tileset'],
       deep: false
+    }, {
+      prop: ['tilemapRef'],
+      deep: false
+    }, {
+      prop: ['layersV2'],
+      deep: false
     }]
   })], TilemapSystem);
   var TilemapSystem$1 = TilemapSystem;
+  function parseHexTint(modulate) {
+    if (!modulate) return undefined;
+    const m = /^#?([0-9a-fA-F]{6})(?:[0-9a-fA-F]{2})?$/.exec(modulate);
+    if (!m) return undefined;
+    return parseInt(m[1], 16);
+  }
+  const NEIGHBOR_DIRECTIONS = ["topLeft", "top", "topRight", "right", "bottomRight", "bottom", "bottomLeft", "left"];
+  const NO_NEIGHBOR = 0xf;
+  const MAX_TERRAIN_ID = 14;
+  function packBits(values) {
+    var _a;
+    let key = 0;
+    for (let i = 0; i < 8; i++) {
+      const v = ((_a = values[i]) !== null && _a !== void 0 ? _a : NO_NEIGHBOR) & 0xf;
+      key |= v << i * 4;
+    }
+    return key >>> 0;
+  }
+  function readNibble(key, slot) {
+    return key >>> slot * 4 & 0xf;
+  }
+  class PeeringBitIndex {
+    constructor(terrainSetIndex) {
+      this.terrainSetIndex = terrainSetIndex;
+      this.exact = new Map();
+      this.wildcards = [];
+    }
+    add(candidate, bits) {
+      var _a;
+      const present = [];
+      const mask = [];
+      for (let i = 0; i < 8; i++) {
+        const dir = NEIGHBOR_DIRECTIONS[i];
+        const v = bits === null || bits === void 0 ? void 0 : bits[dir];
+        if (v === undefined) {
+          present.push(NO_NEIGHBOR);
+          mask.push(0);
+        } else {
+          present.push(v & 0xf);
+          mask.push(0xf);
+        }
+      }
+      const key = packBits(present);
+      const maskKey = packBits(mask);
+      const isFullExact = mask.every(m => m === 0xf);
+      if (isFullExact) {
+        const list = (_a = this.exact.get(key)) !== null && _a !== void 0 ? _a : [];
+        list.push(candidate);
+        this.exact.set(key, list);
+      } else {
+        this.wildcards.push({
+          key,
+          mask: maskKey,
+          candidate
+        });
+      }
+    }
+    match(actual) {
+      const key = packBits(actual);
+      const exact = this.exact.get(key);
+      if (exact && exact.length > 0) {
+        return {
+          candidates: exact.slice(),
+          exactMatch: true,
+          bestHammingDistance: 0
+        };
+      }
+      let bestDist = Infinity;
+      let pool = [];
+      for (const {
+        key: candKey,
+        mask,
+        candidate
+      } of this.wildcards) {
+        let dist = 0;
+        let viable = true;
+        for (let slot = 0; slot < 8; slot++) {
+          const m = readNibble(mask, slot);
+          if (m === 0) continue;
+          const a = readNibble(key, slot);
+          const b = readNibble(candKey, slot);
+          if (a !== b) {
+            dist++;
+            if (dist > bestDist) {
+              viable = false;
+              break;
+            }
+          }
+        }
+        if (!viable) continue;
+        if (dist < bestDist) {
+          bestDist = dist;
+          pool = [candidate];
+        } else if (dist === bestDist) {
+          pool.push(candidate);
+        }
+      }
+      return {
+        candidates: pool,
+        exactMatch: false,
+        bestHammingDistance: bestDist === Infinity ? -1 : bestDist
+      };
+    }
+    get exactBucketCount() {
+      return this.exact.size;
+    }
+    get wildcardCount() {
+      return this.wildcards.length;
+    }
+  }
+  function pickAutotileCandidate(candidates, rng) {
+    if (candidates.length === 0) return null;
+    if (candidates.length === 1) return candidates[0];
+    const totalProb = candidates.reduce((sum, c) => sum + (c.probability > 0 ? c.probability : 1), 0);
+    const t = rng() * totalProb;
+    let acc = 0;
+    for (const c of candidates) {
+      acc += c.probability > 0 ? c.probability : 1;
+      if (t < acc) return c;
+    }
+    return candidates[candidates.length - 1];
+  }
+  const TILE_VERT_SHADER = `#version 300 es
+precision highp float;
+
+in vec2 aPosition;
+in vec2 aTexCoord;
+in vec4 aFlags;
+
+uniform mat3 uProjectionMatrix;
+uniform mat3 uWorldTransformMatrix;
+
+out vec2 vTexCoord;
+
+void main() {
+  vec3 worldPos = uWorldTransformMatrix * vec3(aPosition, 1.0);
+  gl_Position = vec4((uProjectionMatrix * worldPos).xy, 0.0, 1.0);
+
+  vec2 uv = aTexCoord;
+  if (aFlags.x > 0.5) uv.x = 1.0 - uv.x;
+  if (aFlags.y > 0.5) uv.y = 1.0 - uv.y;
+  if (aFlags.z > 0.5) { float t = uv.x; uv.x = uv.y; uv.y = t; }
+  vTexCoord = uv;
+}
+`;
+  const TILE_FRAG_SHADER = `#version 300 es
+precision highp float;
+
+in vec2 vTexCoord;
+out vec4 fragColor;
+
+uniform sampler2D uTexture;
+uniform vec4 uModulate;
+
+void main() {
+  vec4 sampled = texture(uTexture, vTexCoord);
+  fragColor = sampled * uModulate;
+  if (fragColor.a < 0.01) discard;
+}
+`;
+  const TILE_SHADER_SOURCES = {
+    vertex: TILE_VERT_SHADER,
+    fragment: TILE_FRAG_SHADER
+  };
+  const CHUNK_SIZE$1 = 16;
+  const VERTS_PER_QUAD = 4;
+  const FLOATS_PER_VERT = 8;
+  function buildChunkGeometry(args) {
+    const {
+      cells,
+      chunkWorldX,
+      chunkWorldY,
+      cellWidth,
+      cellHeight,
+      atlasInfo
+    } = args;
+    if (cells.length !== CHUNK_SIZE$1 * CHUNK_SIZE$1) {
+      throw new Error(`buildChunkGeometry: cells length ${cells.length} != ${CHUNK_SIZE$1 * CHUNK_SIZE$1}`);
+    }
+    let nonEmpty = 0;
+    for (let i = 0; i < cells.length; i++) if (!isEmptyCellValue(cells[i])) nonEmpty++;
+    const vertexData = new Float32Array(nonEmpty * VERTS_PER_QUAD * FLOATS_PER_VERT);
+    const indices = new Uint16Array(nonEmpty * 6);
+    let v = 0;
+    let i = 0;
+    let quadIdx = 0;
+    for (let ly = 0; ly < CHUNK_SIZE$1; ly++) {
+      for (let lx = 0; lx < CHUNK_SIZE$1; lx++) {
+        const packed = cells[ly * CHUNK_SIZE$1 + lx];
+        if (isEmptyCellValue(packed)) continue;
+        const cell = unpackCell(packed);
+        const x0 = chunkWorldX + lx * cellWidth;
+        const y0 = chunkWorldY + ly * cellHeight;
+        const x1 = x0 + cellWidth;
+        const y1 = y0 + cellHeight;
+        const u0 = (atlasInfo.margins.x + cell.col * (atlasInfo.regionWidth + atlasInfo.separation.x)) / atlasInfo.textureWidth;
+        const u1 = u0 + atlasInfo.regionWidth / atlasInfo.textureWidth;
+        const v0 = (atlasInfo.margins.y + cell.row * (atlasInfo.regionHeight + atlasInfo.separation.y)) / atlasInfo.textureHeight;
+        const v1 = v0 + atlasInfo.regionHeight / atlasInfo.textureHeight;
+        const fh = cell.flipH ? 1 : 0;
+        const fv = cell.flipV ? 1 : 0;
+        const tr = cell.transpose ? 1 : 0;
+        const animPhase = 0;
+        const writeVert = (x, y, u, vv) => {
+          vertexData[v++] = x;
+          vertexData[v++] = y;
+          vertexData[v++] = u;
+          vertexData[v++] = vv;
+          vertexData[v++] = fh;
+          vertexData[v++] = fv;
+          vertexData[v++] = tr;
+          vertexData[v++] = animPhase;
+        };
+        writeVert(x0, y0, u0, v0);
+        writeVert(x1, y0, u1, v0);
+        writeVert(x1, y1, u1, v1);
+        writeVert(x0, y1, u0, v1);
+        const base = quadIdx * VERTS_PER_QUAD;
+        indices[i++] = base;
+        indices[i++] = base + 1;
+        indices[i++] = base + 2;
+        indices[i++] = base;
+        indices[i++] = base + 2;
+        indices[i++] = base + 3;
+        quadIdx++;
+      }
+    }
+    return {
+      vertexData,
+      indices,
+      quadCount: quadIdx
+    };
+  }
+  function diffTilesetForChunkRebuild(prev, next) {
+    const prevSources = new Map();
+    const nextSources = new Map();
+    for (const s of prev.sources) prevSources.set(s.id, s);
+    for (const s of next.sources) nextSources.set(s.id, s);
+    const addedSources = [];
+    const removedSourceIds = [];
+    const changedSourceIds = [];
+    for (const id of nextSources.keys()) {
+      if (!prevSources.has(id)) addedSources.push(nextSources.get(id));else if (JSON.stringify(prevSources.get(id)) !== JSON.stringify(nextSources.get(id))) changedSourceIds.push(id);
+    }
+    for (const id of prevSources.keys()) {
+      if (!nextSources.has(id)) removedSourceIds.push(id);
+    }
+    const addedTilesByKey = new Set();
+    const removedTilesByKey = new Set();
+    const changedTilesByKey = new Set();
+    const indexTiles = src => {
+      const m = new Map();
+      if (src.kind !== "atlas") return m;
+      for (const t of src.tiles) m.set(`${src.id}/${t.atlasCoords.col},${t.atlasCoords.row}`, t);
+      return m;
+    };
+    for (const [id, src] of nextSources) {
+      const prevSrc = prevSources.get(id);
+      if (!prevSrc) {
+        const tiles = indexTiles(src);
+        for (const k of tiles.keys()) addedTilesByKey.add(k);
+        continue;
+      }
+      const a = indexTiles(prevSrc);
+      const b = indexTiles(src);
+      for (const k of b.keys()) {
+        if (!a.has(k)) addedTilesByKey.add(k);else if (JSON.stringify(a.get(k)) !== JSON.stringify(b.get(k))) changedTilesByKey.add(k);
+      }
+      for (const k of a.keys()) {
+        if (!b.has(k)) removedTilesByKey.add(k);
+      }
+    }
+    for (const id of removedSourceIds) {
+      const a = indexTiles(prevSources.get(id));
+      for (const k of a.keys()) removedTilesByKey.add(k);
+    }
+    return {
+      addedSources,
+      removedSourceIds,
+      changedSourceIds,
+      addedTilesByKey,
+      removedTilesByKey,
+      changedTilesByKey
+    };
+  }
+  const diffTilesetDocuments = diffTilesetForChunkRebuild;
+  function computeAffectedChunks(chunks, sourceIdBySlot, diff) {
+    const dirty = new Set();
+    const cellKeyMatches = (cellSlot, col, row) => {
+      const sourceId = sourceIdBySlot.get(cellSlot);
+      if (!sourceId) return false;
+      const k = `${sourceId}/${col},${row}`;
+      return diff.changedTilesByKey.has(k) || diff.removedTilesByKey.has(k) || diff.addedTilesByKey.has(k);
+    };
+    for (const [chunkKey, arr] of Object.entries(chunks)) {
+      for (let i = 0; i < arr.length; i++) {
+        const packed = arr[i];
+        const slot = packed & 0xff;
+        if (slot === 0) continue;
+        const col = packed >>> 8 & 0xff;
+        const row = packed >>> 16 & 0xff;
+        if (cellKeyMatches(slot, col, row)) {
+          dirty.add(chunkKey);
+          break;
+        }
+      }
+    }
+    return dirty;
+  }
+  function expandSceneCollectionSource(src) {
+    if (src.kind !== "sceneCollection") return [];
+    return src.prefabRefs.map((p, i) => ({
+      sourceId: src.id,
+      prefabName: p,
+      index: i
+    }));
+  }
+  function resolveCellPrefabName(packed, sourcesBySlot) {
+    var _a;
+    const slot = packed & 0xff;
+    if (slot === 0) return null;
+    const src = sourcesBySlot[slot - 1];
+    if (!src || src.kind !== "sceneCollection") return null;
+    const col = packed >>> 8 & 0xff;
+    return (_a = src.prefabRefs[col]) !== null && _a !== void 0 ? _a : null;
+  }
+  function cacheKeyOf(k) {
+    return `${k.sourceSlot},${k.col},${k.row},${k.altIdx},${k.layerId}`;
+  }
+  class DecompositionCache {
+    constructor(maxEntries = 1000) {
+      this.cache = new Map();
+      this.accessOrder = new Map();
+      this.accessCounter = 0;
+      this.maxEntries = maxEntries;
+    }
+    get(key) {
+      const k = cacheKeyOf(key);
+      const cached = this.cache.get(k);
+      if (cached) this.accessOrder.set(k, ++this.accessCounter);
+      return cached;
+    }
+    set(key, value) {
+      const k = cacheKeyOf(key);
+      this.cache.set(k, value);
+      this.accessOrder.set(k, ++this.accessCounter);
+      if (this.cache.size > this.maxEntries) this.evictLRU();
+    }
+    has(key) {
+      return this.cache.has(cacheKeyOf(key));
+    }
+    clear() {
+      this.cache.clear();
+      this.accessOrder.clear();
+      this.accessCounter = 0;
+    }
+    get size() {
+      return this.cache.size;
+    }
+    evictLRU() {
+      let oldestKey;
+      let oldestAccess = Infinity;
+      for (const [k, c] of this.accessOrder) {
+        if (c < oldestAccess) {
+          oldestAccess = c;
+          oldestKey = k;
+        }
+      }
+      if (oldestKey) {
+        this.cache.delete(oldestKey);
+        this.accessOrder.delete(oldestKey);
+      }
+    }
+  }
+  function translateConvexParts(parts, dx, dy) {
+    return parts.map(p => ({
+      vertices: p.vertices.map(v => ({
+        x: v.x + dx,
+        y: v.y + dy
+      }))
+    }));
+  }
+  function isConvex(polygon) {
+    if (polygon.length < 3) return true;
+    let sign = 0;
+    const n = polygon.length;
+    for (let i = 0; i < n; i++) {
+      const a = polygon[i];
+      const b = polygon[(i + 1) % n];
+      const c = polygon[(i + 2) % n];
+      const ex1 = b.x - a.x;
+      const ey1 = b.y - a.y;
+      const ex2 = c.x - b.x;
+      const ey2 = c.y - b.y;
+      const cross = ex1 * ey2 - ey1 * ex2;
+      if (cross !== 0) {
+        if (sign === 0) sign = cross > 0 ? 1 : -1;else if ((cross > 0 ? 1 : -1) !== sign) return false;
+      }
+    }
+    return true;
+  }
+  function decomposePolygon(polygon) {
+    if (polygon.length < 3) return [];
+    if (!isConvex(polygon)) {
+      const err = new Error(`decomposePolygon: input polygon (${polygon.length} vertices) is non-convex. ` + `This is a placeholder implementation that assumes convex input — concave polygons silently produce ` + `invalid Matter.js bodies. Real concave decomposition requires the 'poly-decomp' npm dependency ` + `(see ADR-0019 Phase 1). If you need concave physics tiles right now, split into convex parts manually.`);
+      if (typeof console !== 'undefined') console.error('[Tilemap]', err.message);
+      throw err;
+    }
+    return [{
+      vertices: polygon.slice()
+    }];
+  }
+  function cacheKeyOfNum(slot, col, row, altIdx) {
+    return ((slot & 0xff) << 24 | (altIdx & 0x3f) << 18 | (row & 0x1ff) << 9 | col & 0x1ff) >>> 0;
+  }
+  DecompositionCache.prototype.getNum = function (key) {
+    return this.get({
+      sourceSlot: key >>> 24 & 0xff,
+      altIdx: key >>> 18 & 0x3f,
+      row: key >>> 9 & 0x1ff,
+      col: key & 0x1ff,
+      layerId: "__num__"
+    });
+  };
+  DecompositionCache.prototype.setNum = function (key, value) {
+    this.set({
+      sourceSlot: key >>> 24 & 0xff,
+      altIdx: key >>> 18 & 0x3f,
+      row: key >>> 9 & 0x1ff,
+      col: key & 0x1ff,
+      layerId: "__num__"
+    }, value);
+  };
+  class BodySourceRegistryImpl {
+    constructor() {
+      this.builders = new Map();
+    }
+    register(name, builder) {
+      this.builders.set(name, builder);
+    }
+    unregister(name) {
+      this.builders.delete(name);
+    }
+    has(name) {
+      return this.builders.has(name);
+    }
+    build(name, ctx) {
+      const b = this.builders.get(name);
+      if (!b) return null;
+      return b(ctx);
+    }
+    listRegisteredNames() {
+      return Array.from(this.builders.keys());
+    }
+    clear() {
+      this.builders.clear();
+    }
+  }
+  const TILEMAP_BODY_SOURCE_REGISTRY = new BodySourceRegistryImpl();
+  const CHUNK_SIZE = 16;
+  function unpackSlot(packed) {
+    return packed & 0xff;
+  }
+  function unpackCol(packed) {
+    return packed >>> 8 & 0xff;
+  }
+  function unpackRow(packed) {
+    return packed >>> 16 & 0xff;
+  }
+  function unpackAlt(packed) {
+    return packed >>> 24 & 0x1f;
+  }
+  function buildTileMapStaticBodies(input, ctx) {
+    var _a;
+    const out = [];
+    for (const [chunkKey, arr] of Object.entries(input.chunksByKey)) {
+      const [ckxStr, ckyStr] = chunkKey.split(",");
+      const ckx = Number.parseInt(ckxStr, 10);
+      const cky = Number.parseInt(ckyStr, 10);
+      if (!Number.isFinite(ckx) || !Number.isFinite(cky)) continue;
+      for (let ly = 0; ly < CHUNK_SIZE; ly++) {
+        for (let lx = 0; lx < CHUNK_SIZE; lx++) {
+          const packed = arr[ly * CHUNK_SIZE + lx];
+          const slot = unpackSlot(packed);
+          if (slot === 0) continue;
+          const col = unpackCol(packed);
+          const row = unpackRow(packed);
+          const altIdx = unpackAlt(packed);
+          const physicsKey = `${slot},${col},${row},${altIdx}`;
+          const physicsEntries = input.physicsByCellKey.get(physicsKey);
+          if (!physicsEntries || physicsEntries.length === 0) continue;
+          const cellWorldX = input.mapOriginX + (ckx * CHUNK_SIZE + lx) * input.cellWidth + ctx.worldX;
+          const cellWorldY = input.mapOriginY + (cky * CHUNK_SIZE + ly) * input.cellHeight + ctx.worldY;
+          for (const entry of physicsEntries) {
+            for (const poly of entry.polygons) {
+              const cacheKeyNum = cacheKeyOfNum(slot, col, row, altIdx);
+              let parts = (_a = input.cache.getNum(cacheKeyNum)) === null || _a === void 0 ? void 0 : _a.parts;
+              if (!parts) {
+                parts = decomposePolygon(poly.points);
+                input.cache.setNum(cacheKeyNum, {
+                  parts
+                });
+              }
+              const translated = translateConvexParts(parts, cellWorldX, cellWorldY);
+              for (let pi = 0; pi < translated.length; pi++) {
+                out.push({
+                  id: `tile-${chunkKey}-${lx}-${ly}-${entry.layerId}-${pi}`,
+                  vertices: translated[pi].vertices,
+                  centerX: cellWorldX + input.cellWidth / 2,
+                  centerY: cellWorldY + input.cellHeight / 2,
+                  isStatic: true,
+                  oneWay: entry.oneWay,
+                  friction: entry.friction,
+                  restitution: entry.restitution,
+                  metadata: {
+                    layerId: entry.layerId,
+                    chunkKey,
+                    cellLocal: [lx, ly]
+                  }
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+    return out;
+  }
+  function buildTileMapStaticBodyDefinitions(input, ctx, probes) {
+    var _a, _b;
+    probes === null || probes === void 0 ? void 0 : probes.beginTiming(TILEMAP_PROBE_NAMES.PHYSICS_REBAKE_MS);
+    let bodies;
+    try {
+      bodies = buildTileMapStaticBodies(input, ctx);
+    } finally {
+      probes === null || probes === void 0 ? void 0 : probes.endTiming(TILEMAP_PROBE_NAMES.PHYSICS_REBAKE_MS);
+    }
+    const bodiesByLayerId = new Map();
+    for (const b of bodies) {
+      const layerId = (_b = (_a = b.metadata) === null || _a === void 0 ? void 0 : _a.layerId) !== null && _b !== void 0 ? _b : "<unlabeled>";
+      let bucket = bodiesByLayerId.get(layerId);
+      if (!bucket) {
+        bucket = [];
+        bodiesByLayerId.set(layerId, bucket);
+      }
+      bucket.push(b);
+    }
+    const totalBodyCount = bodies.length;
+    probes === null || probes === void 0 ? void 0 : probes.gauge(TILEMAP_PROBE_NAMES.BODIES_TOTAL, totalBodyCount);
+    if (totalBodyCount > 0) {
+      probes === null || probes === void 0 ? void 0 : probes.count(TILEMAP_PROBE_NAMES.BODIES_CREATED, totalBodyCount);
+    }
+    return {
+      bodies,
+      totalBodyCount,
+      bodiesByLayerId
+    };
+  }
+  function extractPhysicsByCellKey(tilesetRaw) {
+    const out = new Map();
+    for (let slotIdx = 0; slotIdx < tilesetRaw.sources.length; slotIdx++) {
+      const src = tilesetRaw.sources[slotIdx];
+      if (!src || src.kind !== "atlas" || !src.tiles) continue;
+      const slot = slotIdx + 1;
+      for (const tile of src.tiles) {
+        const {
+          col,
+          row
+        } = tile.atlasCoords;
+        for (const alt of tile.alternatives) {
+          if (!alt.physics || alt.physics.length === 0) continue;
+          const key = `${slot},${col},${row},${alt.altId & 0x1f}`;
+          out.set(key, alt.physics);
+        }
+      }
+    }
+    return out;
+  }
+  const ADR_0019_NATIVE_REGISTRY_AVAILABLE = false;
+  try {
+    eva_js.resource.registerResourceType('TILESET');
+  } catch (_a) {}
+  try {
+    eva_js.resource.registerInstance('TILESET', res => {
+      var _a, _b, _c, _d;
+      const fromData = (_a = res.data) === null || _a === void 0 ? void 0 : _a.json;
+      const fromSrc = (_c = (_b = res.src) === null || _b === void 0 ? void 0 : _b.json) === null || _c === void 0 ? void 0 : _c.data;
+      return (_d = fromData !== null && fromData !== void 0 ? fromData : fromSrc) !== null && _d !== void 0 ? _d : null;
+    });
+  } catch (_b) {}
+  exports.ADR_0019_NATIVE_REGISTRY_AVAILABLE = ADR_0019_NATIVE_REGISTRY_AVAILABLE;
+  exports.CHUNK_SIZE = CHUNK_SIZE$2;
+  exports.DecompositionCache = DecompositionCache;
+  exports.MAX_TERRAIN_ID = MAX_TERRAIN_ID;
+  exports.NEIGHBOR_DIRECTIONS = NEIGHBOR_DIRECTIONS;
+  exports.NO_NEIGHBOR = NO_NEIGHBOR;
+  exports.PeeringBitIndex = PeeringBitIndex;
+  exports.TILEMAP_BODY_SOURCE_REGISTRY = TILEMAP_BODY_SOURCE_REGISTRY;
+  exports.TILEMAP_PROBE_NAMES = TILEMAP_PROBE_NAMES;
+  exports.TILE_FRAG_SHADER = TILE_FRAG_SHADER;
+  exports.TILE_SHADER_SOURCES = TILE_SHADER_SOURCES;
+  exports.TILE_VERT_SHADER = TILE_VERT_SHADER;
+  exports.TileAnimationDriver = TileAnimationDriver;
   exports.Tilemap = Tilemap;
   exports.TilemapSystem = TilemapSystem$1;
+  exports.adaptGamePerfProbes = adaptGamePerfProbes;
+  exports.buildChunkGeometry = buildChunkGeometry;
+  exports.buildChunkMesh = buildChunkMesh;
+  exports.buildTileMapStaticBodies = buildTileMapStaticBodies;
+  exports.buildTileMapStaticBodyDefinitions = buildTileMapStaticBodyDefinitions;
+  exports.cacheKeyOf = cacheKeyOf;
+  exports.cacheKeyOfNum = cacheKeyOfNum;
+  exports.computeAffectedChunks = computeAffectedChunks;
+  exports.createInMemoryProbeRegistry = createInMemoryProbeRegistry;
+  exports.decodeChunk = decodeChunk;
+  exports.decomposePolygon = decomposePolygon;
+  exports.diffTilesetDocuments = diffTilesetDocuments;
+  exports.diffTilesetForChunkRebuild = diffTilesetForChunkRebuild;
+  exports.estimateChunkMeshMemoryKB = estimateChunkMeshMemoryKB;
+  exports.estimateSpriteNodes = estimateSpriteNodes;
+  exports.expandSceneCollectionSource = expandSceneCollectionSource;
+  exports.extractPhysicsByCellKey = extractPhysicsByCellKey;
+  exports.getRequiredTilemapProbes = getRequiredTilemapProbes;
+  exports.isEmptyCellValue = isEmptyCellValue;
+  exports.isMeshPathAvailable = isMeshPathAvailable;
+  exports.makeLoadedTileset = makeLoadedTileset;
+  exports.pickAutotileCandidate = pickAutotileCandidate;
+  exports.resolveCellPrefabName = resolveCellPrefabName;
+  exports.resolveChunkRenderStrategy = resolveChunkRenderStrategy;
+  exports.translateConvexParts = translateConvexParts;
+  exports.unpackCell = unpackCell;
   Object.defineProperty(exports, '__esModule', {
     value: true
   });