@codexo/exojs-tilemap 0.15.2 → 0.16.0

package/dist/esm/SampledChunkSource.d.ts

@@ -0,0 +1,43 @@
+import type { ChunkSource } from './ChunkSource';
+import type { TileLayer } from './TileLayer';
+import type { ResolvedTile } from './types';
+/**
+ * Options for {@link createSampledChunkSource}.
+ * @advanced
+ */
+export interface SampledChunkSourceOptions {
+    /**
+     * Sample a scalar value at a tile coordinate. Called once per tile within
+     * each requested chunk. Must be a pure, deterministic function of
+     * `(tx, ty)` - {@link import('./ChunkStreamer').ChunkStreamer} regenerates
+     * a chunk from scratch via this source whenever it's revisited after
+     * eviction, so a non-deterministic sampler would make previously-visited
+     * terrain silently change underneath the player.
+     */
+    sample(tx: number, ty: number): number;
+    /**
+     * Convert a sampled value (and its tile coordinate, for position-dependent
+     * logic such as river carving or map edges) into a resolved tile, or
+     * `null` for an empty cell. Must be pure and deterministic, same
+     * requirement as {@link sample}.
+     */
+    mapValueToTile(value: number, tx: number, ty: number): ResolvedTile | null;
+}
+/**
+ * Build a {@link import('./ChunkStreamer').ChunkStreamer}-ready
+ * {@link ChunkSource} from a caller-supplied sampling function - the
+ * generic mechanism behind procedurally generated tile content (noise,
+ * a heightmap, or any other per-tile-coordinate scalar function). This
+ * module intentionally has no opinion on the sampling algorithm itself
+ * ({@link SampledChunkSourceOptions.sample}/`mapValueToTile` are both
+ * required, not defaulted) - pick or write whatever generation function
+ * fits your game.
+ *
+ * `layer` supplies the target chunk grid ({@link TileLayer.chunkWidth}/
+ * `chunkHeight`) and the tileset list tiles are packed against
+ * ({@link TileLayer.tilesets}) - the same `TileLayer` you'll construct the
+ * `ChunkStreamer` with.
+ * @advanced
+ */
+export declare const createSampledChunkSource: (layer: TileLayer, options: SampledChunkSourceOptions) => ChunkSource;
+//# sourceMappingURL=SampledChunkSource.d.ts.map

package/dist/esm/SampledChunkSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SampledChunkSource.d.ts","sourceRoot":"","sources":["../../src/SampledChunkSource.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,WAAW,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAG5C;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IACvC;;;;;OAKG;IACH,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAAC;CAC5E;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,wBAAwB,GAAI,OAAO,SAAS,EAAE,SAAS,yBAAyB,KAAG,WAiC/F,CAAC"}

package/dist/esm/SampledChunkSource.js

@@ -0,0 +1,48 @@
+import { packTile } from "./types.js";
+
+//#region src/SampledChunkSource.ts
+/**
+* Build a {@link import('./ChunkStreamer').ChunkStreamer}-ready
+* {@link ChunkSource} from a caller-supplied sampling function - the
+* generic mechanism behind procedurally generated tile content (noise,
+* a heightmap, or any other per-tile-coordinate scalar function). This
+* module intentionally has no opinion on the sampling algorithm itself
+* ({@link SampledChunkSourceOptions.sample}/`mapValueToTile` are both
+* required, not defaulted) - pick or write whatever generation function
+* fits your game.
+*
+* `layer` supplies the target chunk grid ({@link TileLayer.chunkWidth}/
+* `chunkHeight`) and the tileset list tiles are packed against
+* ({@link TileLayer.tilesets}) - the same `TileLayer` you'll construct the
+* `ChunkStreamer` with.
+* @advanced
+*/
+const createSampledChunkSource = (layer, options) => {
+	const sample = options.sample.bind(options);
+	const mapValueToTile = options.mapValueToTile.bind(options);
+	return { getChunk(cx, cy) {
+		const chunkWidth = layer.chunkWidth;
+		const chunkHeight = layer.chunkHeight;
+		const startTx = cx * chunkWidth;
+		const startTy = cy * chunkHeight;
+		let out = null;
+		for (let ty = startTy; ty < startTy + chunkHeight; ty++) for (let tx = startTx; tx < startTx + chunkWidth; tx++) {
+			if (layer.width !== void 0 && layer.height !== void 0 && (tx >= layer.width || ty >= layer.height)) continue;
+			const value = sample(tx, ty);
+			const resolved = mapValueToTile(value, tx, ty);
+			if (!resolved) continue;
+			out ??= new Uint32Array(chunkWidth * chunkHeight);
+			const tilesetIndex = layer.tilesets.indexOf(resolved.tileset);
+			out[(ty - startTy) * chunkWidth + (tx - startTx)] = packTile(tilesetIndex, resolved.localTileId, resolved.transform);
+		}
+		return out === null ? null : {
+			width: chunkWidth,
+			height: chunkHeight,
+			tiles: out
+		};
+	} };
+};
+
+//#endregion
+export { createSampledChunkSource };
+//# sourceMappingURL=SampledChunkSource.js.map

package/dist/esm/SampledChunkSource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SampledChunkSource.js","names":[],"sources":["../../src/SampledChunkSource.ts"],"sourcesContent":["import type { ChunkPayload, ChunkSource } from './ChunkSource';\nimport type { TileLayer } from './TileLayer';\nimport type { ResolvedTile } from './types';\nimport { packTile } from './types';\n\n/**\n * Options for {@link createSampledChunkSource}.\n * @advanced\n */\nexport interface SampledChunkSourceOptions {\n  /**\n   * Sample a scalar value at a tile coordinate. Called once per tile within\n   * each requested chunk. Must be a pure, deterministic function of\n   * `(tx, ty)` - {@link import('./ChunkStreamer').ChunkStreamer} regenerates\n   * a chunk from scratch via this source whenever it's revisited after\n   * eviction, so a non-deterministic sampler would make previously-visited\n   * terrain silently change underneath the player.\n   */\n  sample(tx: number, ty: number): number;\n  /**\n   * Convert a sampled value (and its tile coordinate, for position-dependent\n   * logic such as river carving or map edges) into a resolved tile, or\n   * `null` for an empty cell. Must be pure and deterministic, same\n   * requirement as {@link sample}.\n   */\n  mapValueToTile(value: number, tx: number, ty: number): ResolvedTile | null;\n}\n\n/**\n * Build a {@link import('./ChunkStreamer').ChunkStreamer}-ready\n * {@link ChunkSource} from a caller-supplied sampling function - the\n * generic mechanism behind procedurally generated tile content (noise,\n * a heightmap, or any other per-tile-coordinate scalar function). This\n * module intentionally has no opinion on the sampling algorithm itself\n * ({@link SampledChunkSourceOptions.sample}/`mapValueToTile` are both\n * required, not defaulted) - pick or write whatever generation function\n * fits your game.\n *\n * `layer` supplies the target chunk grid ({@link TileLayer.chunkWidth}/\n * `chunkHeight`) and the tileset list tiles are packed against\n * ({@link TileLayer.tilesets}) - the same `TileLayer` you'll construct the\n * `ChunkStreamer` with.\n * @advanced\n */\nexport const createSampledChunkSource = (layer: TileLayer, options: SampledChunkSourceOptions): ChunkSource => {\n  const sample = options.sample.bind(options);\n  const mapValueToTile = options.mapValueToTile.bind(options);\n\n  return {\n    getChunk(cx: number, cy: number): ChunkPayload | null {\n      const chunkWidth = layer.chunkWidth;\n      const chunkHeight = layer.chunkHeight;\n      const startTx = cx * chunkWidth;\n      const startTy = cy * chunkHeight;\n\n      let out: Uint32Array | null = null;\n      for (let ty = startTy; ty < startTy + chunkHeight; ty++) {\n        for (let tx = startTx; tx < startTx + chunkWidth; tx++) {\n          // Bounded-layer edge chunks may be smaller than a full chunk\n          // (TileLayer._ensureChunk clamps them); this provider always\n          // samples a full chunk rect, so clamp here instead of letting\n          // _adoptChunk over-report tiles past the layer's declared bounds.\n          if (layer.width !== undefined && layer.height !== undefined && (tx >= layer.width || ty >= layer.height)) continue;\n\n          const value = sample(tx, ty);\n          const resolved = mapValueToTile(value, tx, ty);\n          if (!resolved) continue;\n\n          out ??= new Uint32Array(chunkWidth * chunkHeight);\n          const tilesetIndex = layer.tilesets.indexOf(resolved.tileset);\n          out[(ty - startTy) * chunkWidth + (tx - startTx)] = packTile(tilesetIndex, resolved.localTileId, resolved.transform);\n        }\n      }\n\n      return out === null ? null : { width: chunkWidth, height: chunkHeight, tiles: out };\n    },\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA4CA,MAAa,4BAA4B,OAAkB,YAAoD;CAC7G,MAAM,SAAS,QAAQ,OAAO,KAAK,OAAO;CAC1C,MAAM,iBAAiB,QAAQ,eAAe,KAAK,OAAO;CAE1D,OAAO,EACL,SAAS,IAAY,IAAiC;EACpD,MAAM,aAAa,MAAM;EACzB,MAAM,cAAc,MAAM;EAC1B,MAAM,UAAU,KAAK;EACrB,MAAM,UAAU,KAAK;EAErB,IAAI,MAA0B;EAC9B,KAAK,IAAI,KAAK,SAAS,KAAK,UAAU,aAAa,MACjD,KAAK,IAAI,KAAK,SAAS,KAAK,UAAU,YAAY,MAAM;GAKtD,IAAI,MAAM,UAAU,UAAa,MAAM,WAAW,WAAc,MAAM,MAAM,SAAS,MAAM,MAAM,SAAS;GAE1G,MAAM,QAAQ,OAAO,IAAI,EAAE;GAC3B,MAAM,WAAW,eAAe,OAAO,IAAI,EAAE;GAC7C,IAAI,CAAC,UAAU;GAEf,QAAQ,IAAI,YAAY,aAAa,WAAW;GAChD,MAAM,eAAe,MAAM,SAAS,QAAQ,SAAS,OAAO;GAC5D,KAAK,KAAK,WAAW,cAAc,KAAK,YAAY,SAAS,cAAc,SAAS,aAAa,SAAS,SAAS;EACrH;EAGF,OAAO,QAAQ,OAAO,OAAO;GAAE,OAAO;GAAY,QAAQ;GAAa,OAAO;EAAI;CACpF,EACF;AACF"}

package/dist/esm/TileAnimator.d.ts

@@ -5,12 +5,21 @@ import type { TileLayer } from './TileLayer';
  * On construction it scans the given layer(s) once and registers every cell
  * whose tile carries an `animation` (see {@link import('./types').TileDefinition}).
  * Each {@link update} advances a shared clock and rewrites **only** the
- * registered animated cells, and **only** when a cell crosses a frame boundary —
+ * registered animated cells, and **only** when a cell crosses a frame boundary -
  * static tiles are never touched. Because a tile rewrite goes through
  * `layer.setTileAt`, only the chunks that actually contain animated cells rebuild
  * their geometry, and only on the (infrequent) frames where a boundary is
  * crossed. The large static body of the map never rebuilds.
  *
+ * An unbounded {@link import('./TileLayer').TileLayer} (see
+ * {@link import('./TileLayer').TileLayer.bounded}) is skipped entirely by
+ * the initial scan and reports zero animated cells for that layer, rather
+ * than sweeping every ever-loaded chunk. Streaming/procedural chunk
+ * providers that need animated tiles must drive per-chunk `TileAnimator`
+ * instances themselves (scanning only the newly-adopted chunk's tile
+ * range) - a whole-layer `TileAnimator` is not currently wired to react to
+ * chunk load/unload.
+ *
  * Tick it from your update loop, like `TweenSequencer`:
  *
  * ```ts
@@ -18,7 +27,7 @@ import type { TileLayer } from './TileLayer';
  * scene.systems.add({ update: (t) => animator.update(t.deltaSeconds) });
  * ```
  *
- * The animator references — but never owns — the layers and their tilesets;
+ * The animator references - but never owns - the layers and their tilesets;
  * {@link destroy} only drops its own cell registry.
  *
  * @advanced
@@ -60,3 +69,4 @@ export declare class TileAnimator {
     /** Scan all layers for cells whose tile carries a (multi-frame) animation. */
     private _scan;
 }
+//# sourceMappingURL=TileAnimator.d.ts.map

package/dist/esm/TileAnimator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TileAnimator.d.ts","sourceRoot":"","sources":["../../src/TileAnimator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAmB7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;IAC/C,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,UAAU,CAAK;IAEvB;;;OAGG;gBACgB,MAAM,EAAE,SAAS,GAAG,SAAS,SAAS,EAAE;IAK3D,uEAAuE;IACvE,IAAW,iBAAiB,IAAI,MAAM,CAErC;IAED,6EAA6E;IAC7E,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED;;;;;;OAMG;IACI,MAAM,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IA0BzC;;;OAGG;IACI,KAAK,IAAI,IAAI;IAgBpB;;;;OAIG;IACI,MAAM,IAAI,IAAI;IAKrB,sEAAsE;IAC/D,OAAO,IAAI,IAAI;IAKtB,8EAA8E;IAC9E,OAAO,CAAC,KAAK;CAqDd"}

package/dist/esm/TileAnimator.js

@@ -1,169 +1,158 @@
+//#region src/TileAnimator.ts
 /**
- * Drives per-tile animations on one or more {@link TileLayer}s, RPG-Maker style.
- *
- * On construction it scans the given layer(s) once and registers every cell
- * whose tile carries an `animation` (see {@link import('./types').TileDefinition}).
- * Each {@link update} advances a shared clock and rewrites **only** the
- * registered animated cells, and **only** when a cell crosses a frame boundary —
- * static tiles are never touched. Because a tile rewrite goes through
- * `layer.setTileAt`, only the chunks that actually contain animated cells rebuild
- * their geometry, and only on the (infrequent) frames where a boundary is
- * crossed. The large static body of the map never rebuilds.
- *
- * Tick it from your update loop, like `TweenSequencer`:
- *
- * ```ts
- * const animator = new TileAnimator(map.layers);
- * scene.systems.add({ update: (t) => animator.update(t.deltaSeconds) });
- * ```
- *
- * The animator references — but never owns — the layers and their tilesets;
- * {@link destroy} only drops its own cell registry.
- *
- * @advanced
- */
-class TileAnimator {
-    _layers;
-    _cells = [];
-    _elapsedMs = 0;
-    /**
-     * @param layers One layer, or an array of layers (e.g. `map.layers`), to scan
-     *               for animated tiles.
-     */
-    constructor(layers) {
-        this._layers = Array.isArray(layers) ? layers : [layers];
-        this._scan();
-    }
-    /** Number of animated cells currently registered across all layers. */
-    get animatedCellCount() {
-        return this._cells.length;
-    }
-    /** Total elapsed animation time in milliseconds since construction/reset. */
-    get elapsedMs() {
-        return this._elapsedMs;
-    }
-    /**
-     * Advance all registered animations by `deltaSeconds` and write the current
-     * frame into any cell that crossed a frame boundary. Cells that did not change
-     * frame are not touched, so their chunks do not rebuild.
-     *
-     * @param deltaSeconds Elapsed wall-clock time since the last call, in seconds.
-     */
-    update(deltaSeconds) {
-        if (!Number.isFinite(deltaSeconds) || deltaSeconds <= 0 || this._cells.length === 0) {
-            return;
-        }
-        this._elapsedMs += deltaSeconds * 1000;
-        for (const cell of this._cells) {
-            const t = this._elapsedMs % cell.totalMs;
-            const frameIndex = frameIndexAt(cell.cumulative, t);
-            if (frameIndex === cell.currentFrame) {
-                continue;
-            }
-            cell.currentFrame = frameIndex;
-            const frame = cell.frames[frameIndex];
-            if (frame === undefined) {
-                continue;
-            }
-            cell.layer.setTileAt(cell.tx, cell.ty, {
-                tileset: cell.tileset,
-                localTileId: frame.localTileId,
-                transform: cell.transform,
-            });
-        }
-    }
-    /**
-     * Restore every animated cell to its first frame and reset the clock.
-     * Useful before serialising or pausing.
-     */
-    reset() {
-        this._elapsedMs = 0;
-        for (const cell of this._cells) {
-            const frame = cell.frames[0];
-            if (frame === undefined) {
-                continue;
-            }
-            cell.currentFrame = 0;
-            cell.layer.setTileAt(cell.tx, cell.ty, {
-                tileset: cell.tileset,
-                localTileId: frame.localTileId,
-                transform: cell.transform,
-            });
-        }
-    }
-    /**
-     * Re-scan the layers for animated cells. Call after structural edits that add
-     * or remove animated tiles. Resets all currently-tracked cells to frame 0
-     * first so the rescan starts from a clean, deterministic state.
-     */
-    rescan() {
-        this.reset();
-        this._scan();
-    }
-    /** Drop the cell registry. Does not modify the layers or tilesets. */
-    destroy() {
-        this._cells = [];
-        this._elapsedMs = 0;
-    }
-    /** Scan all layers for cells whose tile carries a (multi-frame) animation. */
-    _scan() {
-        const cells = [];
-        for (const layer of this._layers) {
-            for (let ty = 0; ty < layer.height; ty++) {
-                for (let tx = 0; tx < layer.width; tx++) {
-                    const tile = layer.getTileAt(tx, ty);
-                    if (!tile) {
-                        continue;
-                    }
-                    const def = tile.tileset.getTileDefinition(tile.localTileId);
-                    const frames = def?.animation;
-                    if (!frames || frames.length < 2) {
-                        continue;
-                    }
-                    // Skip animations referencing out-of-range frames so update() never
-                    // throws from setTileAt; such data is malformed and silently ignored.
-                    if (frames.some(f => f.localTileId < 0 || f.localTileId >= tile.tileset.tileCount)) {
-                        continue;
-                    }
-                    const cumulative = [];
-                    let total = 0;
-                    for (const frame of frames) {
-                        total += Math.max(0, frame.duration);
-                        cumulative.push(total);
-                    }
-                    if (total <= 0) {
-                        continue;
-                    }
-                    cells.push({
-                        layer,
-                        tx,
-                        ty,
-                        tileset: tile.tileset,
-                        transform: tile.transform,
-                        frames,
-                        cumulative,
-                        totalMs: total,
-                        currentFrame: -1,
-                    });
-                }
-            }
-        }
-        this._cells = cells;
-    }
-}
+* Drives per-tile animations on one or more {@link TileLayer}s, RPG-Maker style.
+*
+* On construction it scans the given layer(s) once and registers every cell
+* whose tile carries an `animation` (see {@link import('./types').TileDefinition}).
+* Each {@link update} advances a shared clock and rewrites **only** the
+* registered animated cells, and **only** when a cell crosses a frame boundary -
+* static tiles are never touched. Because a tile rewrite goes through
+* `layer.setTileAt`, only the chunks that actually contain animated cells rebuild
+* their geometry, and only on the (infrequent) frames where a boundary is
+* crossed. The large static body of the map never rebuilds.
+*
+* An unbounded {@link import('./TileLayer').TileLayer} (see
+* {@link import('./TileLayer').TileLayer.bounded}) is skipped entirely by
+* the initial scan and reports zero animated cells for that layer, rather
+* than sweeping every ever-loaded chunk. Streaming/procedural chunk
+* providers that need animated tiles must drive per-chunk `TileAnimator`
+* instances themselves (scanning only the newly-adopted chunk's tile
+* range) - a whole-layer `TileAnimator` is not currently wired to react to
+* chunk load/unload.
+*
+* Tick it from your update loop, like `TweenSequencer`:
+*
+* ```ts
+* const animator = new TileAnimator(map.layers);
+* scene.systems.add({ update: (t) => animator.update(t.deltaSeconds) });
+* ```
+*
+* The animator references - but never owns - the layers and their tilesets;
+* {@link destroy} only drops its own cell registry.
+*
+* @advanced
+*/
+var TileAnimator = class {
+	_layers;
+	_cells = [];
+	_elapsedMs = 0;
+	/**
+	* @param layers One layer, or an array of layers (e.g. `map.layers`), to scan
+	*               for animated tiles.
+	*/
+	constructor(layers) {
+		this._layers = Array.isArray(layers) ? layers : [layers];
+		this._scan();
+	}
+	/** Number of animated cells currently registered across all layers. */
+	get animatedCellCount() {
+		return this._cells.length;
+	}
+	/** Total elapsed animation time in milliseconds since construction/reset. */
+	get elapsedMs() {
+		return this._elapsedMs;
+	}
+	/**
+	* Advance all registered animations by `deltaSeconds` and write the current
+	* frame into any cell that crossed a frame boundary. Cells that did not change
+	* frame are not touched, so their chunks do not rebuild.
+	*
+	* @param deltaSeconds Elapsed wall-clock time since the last call, in seconds.
+	*/
+	update(deltaSeconds) {
+		if (!Number.isFinite(deltaSeconds) || deltaSeconds <= 0 || this._cells.length === 0) return;
+		this._elapsedMs += deltaSeconds * 1e3;
+		for (const cell of this._cells) {
+			const t = this._elapsedMs % cell.totalMs;
+			const frameIndex = frameIndexAt(cell.cumulative, t);
+			if (frameIndex === cell.currentFrame) continue;
+			cell.currentFrame = frameIndex;
+			const frame = cell.frames[frameIndex];
+			if (frame === void 0) continue;
+			cell.layer.setTileAt(cell.tx, cell.ty, {
+				tileset: cell.tileset,
+				localTileId: frame.localTileId,
+				transform: cell.transform
+			});
+		}
+	}
+	/**
+	* Restore every animated cell to its first frame and reset the clock.
+	* Useful before serialising or pausing.
+	*/
+	reset() {
+		this._elapsedMs = 0;
+		for (const cell of this._cells) {
+			const frame = cell.frames[0];
+			if (frame === void 0) continue;
+			cell.currentFrame = 0;
+			cell.layer.setTileAt(cell.tx, cell.ty, {
+				tileset: cell.tileset,
+				localTileId: frame.localTileId,
+				transform: cell.transform
+			});
+		}
+	}
+	/**
+	* Re-scan the layers for animated cells. Call after structural edits that add
+	* or remove animated tiles. Resets all currently-tracked cells to frame 0
+	* first so the rescan starts from a clean, deterministic state.
+	*/
+	rescan() {
+		this.reset();
+		this._scan();
+	}
+	/** Drop the cell registry. Does not modify the layers or tilesets. */
+	destroy() {
+		this._cells = [];
+		this._elapsedMs = 0;
+	}
+	/** Scan all layers for cells whose tile carries a (multi-frame) animation. */
+	_scan() {
+		const cells = [];
+		for (const layer of this._layers) {
+			if (layer.width === void 0 || layer.height === void 0) continue;
+			for (let ty = 0; ty < layer.height; ty++) for (let tx = 0; tx < layer.width; tx++) {
+				const tile = layer.getTileAt(tx, ty);
+				if (!tile) continue;
+				const frames = tile.tileset.getTileDefinition(tile.localTileId)?.animation;
+				if (!frames || frames.length < 2) continue;
+				if (frames.some((f) => f.localTileId < 0 || f.localTileId >= tile.tileset.tileCount)) continue;
+				const cumulative = [];
+				let total = 0;
+				for (const frame of frames) {
+					total += Math.max(0, frame.duration);
+					cumulative.push(total);
+				}
+				if (total <= 0) continue;
+				cells.push({
+					layer,
+					tx,
+					ty,
+					tileset: tile.tileset,
+					transform: tile.transform,
+					frames,
+					cumulative,
+					totalMs: total,
+					currentFrame: -1
+				});
+			}
+		}
+		this._cells = cells;
+	}
+};
 /**
- * Find the frame index whose cumulative window contains time `t` (0 ≤ t < total).
- * `cumulative[i]` is the end time of frame `i`; the last entry equals the total.
- */
-function frameIndexAt(cumulative, t) {
-    for (let i = 0; i < cumulative.length; i++) {
-        const end = cumulative[i];
-        if (end !== undefined && t < end) {
-            return i;
-        }
-    }
-    return cumulative.length - 1;
-}
+* Find the frame index whose cumulative window contains time `t` (0 ≤ t < total).
+* `cumulative[i]` is the end time of frame `i`; the last entry equals the total.
+*/
+const frameIndexAt = (cumulative, t) => {
+	for (let i = 0; i < cumulative.length; i++) {
+		const end = cumulative[i];
+		if (end !== void 0 && t < end) return i;
+	}
+	return cumulative.length - 1;
+};
 
+//#endregion
 export { TileAnimator };
-//# sourceMappingURL=TileAnimator.js.map
+//# sourceMappingURL=TileAnimator.js.map

package/dist/esm/TileAnimator.js.map

@@ -1 +1 @@
-{"version":3,"file":"TileAnimator.js","sources":["../../../src/TileAnimator.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"TileAnimator.js","names":[],"sources":["../../src/TileAnimator.ts"],"sourcesContent":["import type { TileLayer } from './TileLayer';\nimport type { TileSet } from './TileSet';\nimport type { TileAnimationFrame, TileTransform } from './types';\n\n/** Internal per-cell animation record. */\ninterface AnimatedCell {\n  readonly layer: TileLayer;\n  readonly tx: number;\n  readonly ty: number;\n  readonly tileset: TileSet;\n  readonly transform: TileTransform;\n  readonly frames: readonly TileAnimationFrame[];\n  /** Cumulative end-time (ms) of each frame, so `cumulative.at(-1) === totalMs`. */\n  readonly cumulative: readonly number[];\n  readonly totalMs: number;\n  /** Index of the frame currently written into the layer (-1 = none yet). */\n  currentFrame: number;\n}\n\n/**\n * Drives per-tile animations on one or more {@link TileLayer}s, RPG-Maker style.\n *\n * On construction it scans the given layer(s) once and registers every cell\n * whose tile carries an `animation` (see {@link import('./types').TileDefinition}).\n * Each {@link update} advances a shared clock and rewrites **only** the\n * registered animated cells, and **only** when a cell crosses a frame boundary -\n * static tiles are never touched. Because a tile rewrite goes through\n * `layer.setTileAt`, only the chunks that actually contain animated cells rebuild\n * their geometry, and only on the (infrequent) frames where a boundary is\n * crossed. The large static body of the map never rebuilds.\n *\n * An unbounded {@link import('./TileLayer').TileLayer} (see\n * {@link import('./TileLayer').TileLayer.bounded}) is skipped entirely by\n * the initial scan and reports zero animated cells for that layer, rather\n * than sweeping every ever-loaded chunk. Streaming/procedural chunk\n * providers that need animated tiles must drive per-chunk `TileAnimator`\n * instances themselves (scanning only the newly-adopted chunk's tile\n * range) - a whole-layer `TileAnimator` is not currently wired to react to\n * chunk load/unload.\n *\n * Tick it from your update loop, like `TweenSequencer`:\n *\n * ```ts\n * const animator = new TileAnimator(map.layers);\n * scene.systems.add({ update: (t) => animator.update(t.deltaSeconds) });\n * ```\n *\n * The animator references - but never owns - the layers and their tilesets;\n * {@link destroy} only drops its own cell registry.\n *\n * @advanced\n */\nexport class TileAnimator {\n  private readonly _layers: readonly TileLayer[];\n  private _cells: AnimatedCell[] = [];\n  private _elapsedMs = 0;\n\n  /**\n   * @param layers One layer, or an array of layers (e.g. `map.layers`), to scan\n   *               for animated tiles.\n   */\n  public constructor(layers: TileLayer | readonly TileLayer[]) {\n    this._layers = Array.isArray(layers) ? layers : [layers as TileLayer];\n    this._scan();\n  }\n\n  /** Number of animated cells currently registered across all layers. */\n  public get animatedCellCount(): number {\n    return this._cells.length;\n  }\n\n  /** Total elapsed animation time in milliseconds since construction/reset. */\n  public get elapsedMs(): number {\n    return this._elapsedMs;\n  }\n\n  /**\n   * Advance all registered animations by `deltaSeconds` and write the current\n   * frame into any cell that crossed a frame boundary. Cells that did not change\n   * frame are not touched, so their chunks do not rebuild.\n   *\n   * @param deltaSeconds Elapsed wall-clock time since the last call, in seconds.\n   */\n  public update(deltaSeconds: number): void {\n    if (!Number.isFinite(deltaSeconds) || deltaSeconds <= 0 || this._cells.length === 0) {\n      return;\n    }\n\n    this._elapsedMs += deltaSeconds * 1000;\n\n    for (const cell of this._cells) {\n      const t = this._elapsedMs % cell.totalMs;\n      const frameIndex = frameIndexAt(cell.cumulative, t);\n      if (frameIndex === cell.currentFrame) {\n        continue;\n      }\n      cell.currentFrame = frameIndex;\n      const frame = cell.frames[frameIndex];\n      if (frame === undefined) {\n        continue;\n      }\n      cell.layer.setTileAt(cell.tx, cell.ty, {\n        tileset: cell.tileset,\n        localTileId: frame.localTileId,\n        transform: cell.transform,\n      });\n    }\n  }\n\n  /**\n   * Restore every animated cell to its first frame and reset the clock.\n   * Useful before serialising or pausing.\n   */\n  public reset(): void {\n    this._elapsedMs = 0;\n    for (const cell of this._cells) {\n      const frame = cell.frames[0];\n      if (frame === undefined) {\n        continue;\n      }\n      cell.currentFrame = 0;\n      cell.layer.setTileAt(cell.tx, cell.ty, {\n        tileset: cell.tileset,\n        localTileId: frame.localTileId,\n        transform: cell.transform,\n      });\n    }\n  }\n\n  /**\n   * Re-scan the layers for animated cells. Call after structural edits that add\n   * or remove animated tiles. Resets all currently-tracked cells to frame 0\n   * first so the rescan starts from a clean, deterministic state.\n   */\n  public rescan(): void {\n    this.reset();\n    this._scan();\n  }\n\n  /** Drop the cell registry. Does not modify the layers or tilesets. */\n  public destroy(): void {\n    this._cells = [];\n    this._elapsedMs = 0;\n  }\n\n  /** Scan all layers for cells whose tile carries a (multi-frame) animation. */\n  private _scan(): void {\n    const cells: AnimatedCell[] = [];\n\n    for (const layer of this._layers) {\n      if (layer.width === undefined || layer.height === undefined) {\n        continue; // unbounded layers are not scanned in v1 — see class doc comment.\n      }\n      for (let ty = 0; ty < layer.height; ty++) {\n        for (let tx = 0; tx < layer.width; tx++) {\n          const tile = layer.getTileAt(tx, ty);\n          if (!tile) {\n            continue;\n          }\n\n          const def = tile.tileset.getTileDefinition(tile.localTileId);\n          const frames = def?.animation;\n          if (!frames || frames.length < 2) {\n            continue;\n          }\n\n          // Skip animations referencing out-of-range frames so update() never\n          // throws from setTileAt; such data is malformed and silently ignored.\n          if (frames.some(f => f.localTileId < 0 || f.localTileId >= tile.tileset.tileCount)) {\n            continue;\n          }\n\n          const cumulative: number[] = [];\n          let total = 0;\n          for (const frame of frames) {\n            total += Math.max(0, frame.duration);\n            cumulative.push(total);\n          }\n          if (total <= 0) {\n            continue;\n          }\n\n          cells.push({\n            layer,\n            tx,\n            ty,\n            tileset: tile.tileset,\n            transform: tile.transform,\n            frames,\n            cumulative,\n            totalMs: total,\n            currentFrame: -1,\n          });\n        }\n      }\n    }\n\n    this._cells = cells;\n  }\n}\n\n/**\n * Find the frame index whose cumulative window contains time `t` (0 ≤ t < total).\n * `cumulative[i]` is the end time of frame `i`; the last entry equals the total.\n */\nconst frameIndexAt = (cumulative: readonly number[], t: number): number => {\n  for (let i = 0; i < cumulative.length; i++) {\n    const end = cumulative[i];\n    if (end !== undefined && t < end) {\n      return i;\n    }\n  }\n  return cumulative.length - 1;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,IAAa,eAAb,MAA0B;CACxB,AAAiB;CACjB,AAAQ,SAAyB,CAAC;CAClC,AAAQ,aAAa;;;;;CAMrB,AAAO,YAAY,QAA0C;EAC3D,KAAK,UAAU,MAAM,QAAQ,MAAM,IAAI,SAAS,CAAC,MAAmB;EACpE,KAAK,MAAM;CACb;;CAGA,IAAW,oBAA4B;EACrC,OAAO,KAAK,OAAO;CACrB;;CAGA,IAAW,YAAoB;EAC7B,OAAO,KAAK;CACd;;;;;;;;CASA,AAAO,OAAO,cAA4B;EACxC,IAAI,CAAC,OAAO,SAAS,YAAY,KAAK,gBAAgB,KAAK,KAAK,OAAO,WAAW,GAChF;EAGF,KAAK,cAAc,eAAe;EAElC,KAAK,MAAM,QAAQ,KAAK,QAAQ;GAC9B,MAAM,IAAI,KAAK,aAAa,KAAK;GACjC,MAAM,aAAa,aAAa,KAAK,YAAY,CAAC;GAClD,IAAI,eAAe,KAAK,cACtB;GAEF,KAAK,eAAe;GACpB,MAAM,QAAQ,KAAK,OAAO;GAC1B,IAAI,UAAU,QACZ;GAEF,KAAK,MAAM,UAAU,KAAK,IAAI,KAAK,IAAI;IACrC,SAAS,KAAK;IACd,aAAa,MAAM;IACnB,WAAW,KAAK;GAClB,CAAC;EACH;CACF;;;;;CAMA,AAAO,QAAc;EACnB,KAAK,aAAa;EAClB,KAAK,MAAM,QAAQ,KAAK,QAAQ;GAC9B,MAAM,QAAQ,KAAK,OAAO;GAC1B,IAAI,UAAU,QACZ;GAEF,KAAK,eAAe;GACpB,KAAK,MAAM,UAAU,KAAK,IAAI,KAAK,IAAI;IACrC,SAAS,KAAK;IACd,aAAa,MAAM;IACnB,WAAW,KAAK;GAClB,CAAC;EACH;CACF;;;;;;CAOA,AAAO,SAAe;EACpB,KAAK,MAAM;EACX,KAAK,MAAM;CACb;;CAGA,AAAO,UAAgB;EACrB,KAAK,SAAS,CAAC;EACf,KAAK,aAAa;CACpB;;CAGA,AAAQ,QAAc;EACpB,MAAM,QAAwB,CAAC;EAE/B,KAAK,MAAM,SAAS,KAAK,SAAS;GAChC,IAAI,MAAM,UAAU,UAAa,MAAM,WAAW,QAChD;GAEF,KAAK,IAAI,KAAK,GAAG,KAAK,MAAM,QAAQ,MAClC,KAAK,IAAI,KAAK,GAAG,KAAK,MAAM,OAAO,MAAM;IACvC,MAAM,OAAO,MAAM,UAAU,IAAI,EAAE;IACnC,IAAI,CAAC,MACH;IAIF,MAAM,SADM,KAAK,QAAQ,kBAAkB,KAAK,WAC/B,CAAC,EAAE;IACpB,IAAI,CAAC,UAAU,OAAO,SAAS,GAC7B;IAKF,IAAI,OAAO,MAAK,MAAK,EAAE,cAAc,KAAK,EAAE,eAAe,KAAK,QAAQ,SAAS,GAC/E;IAGF,MAAM,aAAuB,CAAC;IAC9B,IAAI,QAAQ;IACZ,KAAK,MAAM,SAAS,QAAQ;KAC1B,SAAS,KAAK,IAAI,GAAG,MAAM,QAAQ;KACnC,WAAW,KAAK,KAAK;IACvB;IACA,IAAI,SAAS,GACX;IAGF,MAAM,KAAK;KACT;KACA;KACA;KACA,SAAS,KAAK;KACd,WAAW,KAAK;KAChB;KACA;KACA,SAAS;KACT,cAAc;IAChB,CAAC;GACH;EAEJ;EAEA,KAAK,SAAS;CAChB;AACF;;;;;AAMA,MAAM,gBAAgB,YAA+B,MAAsB;CACzE,KAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;EAC1C,MAAM,MAAM,WAAW;EACvB,IAAI,QAAQ,UAAa,IAAI,KAC3B,OAAO;CAEX;CACA,OAAO,WAAW,SAAS;AAC7B"}

package/dist/esm/TileChunk.d.ts

@@ -42,7 +42,7 @@ export interface ReadonlyTileChunk {
  * laid out row-major. Each cell is a packed tile word (0 = empty).
  * Chunk coordinates are signed to support future infinite maps.
  *
- * The backing array is **private** — external code cannot mutate storage
+ * The backing array is **private** - external code cannot mutate storage
  * directly. All mutation must flow through {@link TileLayer} public APIs,
  * which call the package-internal `_setRawAt` method.
  *
@@ -60,12 +60,21 @@ export declare class TileChunk implements ReadonlyTileChunk {
     readonly width: number;
     /** Height of this chunk in tiles. */
     readonly height: number;
-    /** Packed tile storage (row-major). Private — never exposed directly. */
+    /** Packed tile storage (row-major). Private - never exposed directly. */
     private readonly _tiles;
     /** Whether every cell in this chunk is empty (0). Lazy-computed. */
     private _empty;
-    /** Monotonic revision counter — incremented on every mutation. */
+    /** Monotonic revision counter - incremented on every mutation. */
     private _revision;
+    /**
+     * Render-node-owned callbacks notified whenever `_revision` advances.
+     * `TileChunkNode.pages` caches geometry against `revision`, but that cache
+     * is only consulted from `render()` - a call the engine skips entirely for
+     * a content-clean subtree under a `RetainedContainer`. Without
+     * this push, an in-place tile edit after capture would replay stale cached
+     * geometry forever. Package-internal; not part of {@link ReadonlyTileChunk}.
+     */
+    private _dirtyListeners;
     /**
      * @param cx Signed chunk X coordinate (must be finite safe integer).
      * @param cy Signed chunk Y coordinate (must be finite safe integer).
@@ -91,7 +100,7 @@ export declare class TileChunk implements ReadonlyTileChunk {
     cloneTiles(): Uint32Array;
     /**
      * Package-internal access to the underlying tile storage.
-     * Returns the actual mutable `Uint32Array` — DO NOT USE publicly.
+     * Returns the actual mutable `Uint32Array` - DO NOT USE publicly.
      *
      * Provided for the future tilemap renderer (same package) so it can
      * read chunk data efficiently without a full `cloneTiles()` copy per frame.
@@ -102,7 +111,7 @@ export declare class TileChunk implements ReadonlyTileChunk {
     _getRawStorage(): Uint32Array;
     /**
      * Validate a packed tile value before storing.
-     * Accepts any finite integer — `Uint32Array` stores via unsigned 32-bit
+     * Accepts any finite integer - `Uint32Array` stores via unsigned 32-bit
      * truncation (`ToUint32`). Negative values produced by JavaScript's
      * signed bitwise ops (e.g. when the transform bits set bit 31) are valid.
      * @throws If the value is NaN, Infinity, or non-integer.
@@ -133,4 +142,20 @@ export declare class TileChunk implements ReadonlyTileChunk {
      * @internal
      */
     _clear(): void;
+    /**
+     * Register a callback invoked synchronously whenever this chunk's revision
+     * advances. Multiple listeners are supported (a chunk may back more than one
+     * `TileChunkNode` - e.g. two `TileLayerNode`s over the same `TileLayer`).
+     * Package-internal: called by `TileChunkNode` to push mutations onto the
+     * scene-node content-revision chain (see the `_dirtyListeners` field).
+     * @internal
+     */
+    _addDirtyListener(listener: () => void): void;
+    /**
+     * Unregister a listener added via {@link _addDirtyListener} (node destroy).
+     * @internal
+     */
+    _removeDirtyListener(listener: () => void): void;
+    private _notifyDirty;
 }
+//# sourceMappingURL=TileChunk.d.ts.map

package/dist/esm/TileChunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TileChunk.d.ts","sourceRoot":"","sources":["../../src/TileChunk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAG1C;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB;IAChC,iCAAiC;IACjC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,iCAAiC;IACjC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,oCAAoC;IACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,qCAAqC;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,8CAA8C;IAC9C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,CAAC;IAE7C;;;OAGG;IACH,UAAU,IAAI,WAAW,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,SAAU,YAAW,iBAAiB;IACjD,iCAAiC;IACjC,SAAgB,EAAE,EAAE,MAAM,CAAC;IAC3B,iCAAiC;IACjC,SAAgB,EAAE,EAAE,MAAM,CAAC;IAE3B,oCAAoC;IACpC,SAAgB,KAAK,EAAE,MAAM,CAAC;IAC9B,qCAAqC;IACrC,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,yEAAyE;IACzE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IAErC,oEAAoE;IACpE,OAAO,CAAC,MAAM,CAAwB;IAEtC,kEAAkE;IAClE,OAAO,CAAC,SAAS,CAAK;IAEtB;;;;;;;OAOG;IACH,OAAO,CAAC,eAAe,CAAgC;IAEvD;;;;;;OAMG;gBACgB,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW;IA0C9F,2DAA2D;IAC3D,OAAO,CAAC,MAAM;IAId;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAa3B,kBAAkB;IACX,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU;IAKnD,kBAAkB;IAClB,IAAW,KAAK,IAAI,OAAO,CAK1B;IAED,kBAAkB;IAClB,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED,kBAAkB;IACX,UAAU,IAAI,WAAW;IAMhC;;;;;;;;;OASG;IACI,cAAc,IAAI,WAAW;IAIpC;;;;;;;OAOG;IACH,OAAO,CAAC,eAAe;IAMvB;;;;;;OAMG;IACI,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,OAAO;IAarE;;;;;;OAMG;IACI,UAAU,IAAI,IAAI;IAMzB;;;;;;OAMG;IACI,MAAM,IAAI,IAAI;IASrB;;;;;;;OAOG;IACI,iBAAiB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IAIpD;;;OAGG;IACI,oBAAoB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IAIvD,OAAO,CAAC,YAAY;CAMrB"}