@codexo/exojs-tilemap 0.15.2 → 0.16.0

package/dist/esm/TileChunkNode.js

@@ -1,89 +1,108 @@
-import { Drawable } from '@codexo/exojs/renderer-sdk';
-import { buildChunkPages } from './chunkGeometry.js';
+import { buildChunkPages } from "./chunkGeometry.js";
+import { TileChunk } from "./TileChunk.js";
+import { Drawable } from "@codexo/exojs/renderer-sdk";
 
+//#region src/TileChunkNode.ts
 /**
- * A single renderable tile chunk. One `TileChunkNode` is a {@link Drawable}
- * that owns the batched quad geometry for exactly one {@link ReadonlyTileChunk}
- * of one {@link import('./TileLayer').TileLayer}, positioned at the chunk's
- * pixel origin within the owning {@link TileLayerNode}.
- *
- * Geometry is built lazily and cached against the source chunk's `revision`:
- * the renderer reads {@link TileChunkNode.pages} on each visible frame, but a
- * rebuild only happens when the underlying chunk actually changed. Off-screen
- * chunks are culled by their accurate {@link getLocalBounds} before `render`
- * is ever called, so a camera pan rebuilds nothing.
- *
- * The node references — but never owns — the runtime chunk, tilesets, and
- * tileset textures. Destroying it releases only its cached CPU geometry; the
- * `TileMap`/`TileLayer` data and Loader-owned textures are untouched.
- *
- * @internal Package-internal render node; the renderer is registered for this
- * class. Applications use {@link TileMapNode} / {@link TileLayerNode}.
- */
-class TileChunkNode extends Drawable {
-    _chunk;
-    _tilesets;
-    _tileWidth;
-    _tileHeight;
-    _pixelWidth;
-    _pixelHeight;
-    _pages = [];
-    _builtRevision = -1;
-    /**
-     * @param chunk          The readonly chunk this node renders.
-     * @param tilesets       The owning layer's tileset array.
-     * @param tileWidth      Map/layer tile cell width in pixels.
-     * @param tileHeight     Map/layer tile cell height in pixels.
-     * @param chunkWidthTiles  The layer's (unclamped) chunk width in tiles, used
-     *                         to compute the chunk's pixel origin. Edge chunks
-     *                         report a smaller `chunk.width`, but always start at
-     *                         `cx * chunkWidthTiles`.
-     * @param chunkHeightTiles The layer's (unclamped) chunk height in tiles.
-     */
-    constructor(chunk, tilesets, tileWidth, tileHeight, chunkWidthTiles, chunkHeightTiles) {
-        super();
-        this._chunk = chunk;
-        this._tilesets = tilesets;
-        this._tileWidth = tileWidth;
-        this._tileHeight = tileHeight;
-        this._pixelWidth = chunk.width * tileWidth;
-        this._pixelHeight = chunk.height * tileHeight;
-        this.setPosition(chunk.cx * chunkWidthTiles * tileWidth, chunk.cy * chunkHeightTiles * tileHeight);
-    }
-    /** The signed chunk coordinates this node renders. */
-    get chunkX() {
-        return this._chunk.cx;
-    }
-    get chunkY() {
-        return this._chunk.cy;
-    }
-    /**
-     * The revision-cached per-tileset page geometry. Rebuilt only when the source
-     * chunk's `revision` advances; otherwise the same arrays are returned.
-     * @internal Read by the per-backend tile chunk renderer.
-     */
-    get pages() {
-        if (this._builtRevision !== this._chunk.revision) {
-            this._pages = buildChunkPages(this._chunk, this._tilesets, this._tileWidth, this._tileHeight);
-            this._builtRevision = this._chunk.revision;
-        }
-        return this._pages;
-    }
-    /** `true` when the chunk has no drawable tiles (no geometry, no draw calls). */
-    get isEmpty() {
-        return this.pages.length === 0;
-    }
-    getLocalBounds() {
-        const bounds = super.getLocalBounds();
-        bounds.set(0, 0, this._pixelWidth, this._pixelHeight);
-        return bounds;
-    }
-    destroy() {
-        this._pages = [];
-        this._builtRevision = -1;
-        super.destroy();
-    }
-}
+* A single renderable tile chunk. One `TileChunkNode` is a {@link Drawable}
+* that owns the batched quad geometry for exactly one {@link ReadonlyTileChunk}
+* of one {@link import('./TileLayer').TileLayer}, positioned at the chunk's
+* pixel origin within the owning {@link TileLayerNode}.
+*
+* Geometry is built lazily and cached against the source chunk's `revision`:
+* the renderer reads {@link TileChunkNode.pages} on each visible frame, but a
+* rebuild only happens when the underlying chunk actually changed. Off-screen
+* chunks are culled by their accurate {@link getLocalBounds} before `render`
+* is ever called, so a camera pan rebuilds nothing.
+*
+* The node references - but never owns - the runtime chunk, tilesets, and
+* tileset textures. Destroying it releases only its cached CPU geometry; the
+* `TileMap`/`TileLayer` data and Loader-owned textures are untouched.
+*
+* @internal Package-internal render node; the renderer is registered for this
+* class. Applications use {@link TileMapNode} / {@link TileLayerNode}.
+*/
+var TileChunkNode = class extends Drawable {
+	_chunk;
+	_tilesets;
+	_tileWidth;
+	_tileHeight;
+	_pixelWidth;
+	_pixelHeight;
+	_pages = [];
+	_builtRevision = -1;
+	/**
+	* Bound once so `TileChunk._addDirtyListener`/`_removeDirtyListener` add and
+	* remove the SAME function reference. Pushes the chunk's revision bump onto
+	* this node's own content revision (see `TileChunk._dirtyListeners`) so a
+	* `RetainedContainer` ancestor - which skips walking a content-clean
+	* subtree entirely - observes the mutation and re-collects instead of
+	* replaying stale cached geometry.
+	*/
+	_onChunkDirty = () => {
+		this.invalidateContent();
+	};
+	/**
+	* @param chunk          The readonly chunk this node renders.
+	* @param tilesets       The owning layer's tileset array.
+	* @param tileWidth      Map/layer tile cell width in pixels.
+	* @param tileHeight     Map/layer tile cell height in pixels.
+	* @param chunkWidthTiles  The layer's (unclamped) chunk width in tiles, used
+	*                         to compute the chunk's pixel origin. Edge chunks
+	*                         report a smaller `chunk.width`, but always start at
+	*                         `cx * chunkWidthTiles`.
+	* @param chunkHeightTiles The layer's (unclamped) chunk height in tiles.
+	*/
+	constructor(chunk, tilesets, tileWidth, tileHeight, chunkWidthTiles, chunkHeightTiles) {
+		super();
+		this._chunk = chunk;
+		this._tilesets = tilesets;
+		this._tileWidth = tileWidth;
+		this._tileHeight = tileHeight;
+		this._pixelWidth = chunk.width * tileWidth;
+		this._pixelHeight = chunk.height * tileHeight;
+		this.setPosition(chunk.cx * chunkWidthTiles * tileWidth, chunk.cy * chunkHeightTiles * tileHeight);
+		if (chunk instanceof TileChunk) chunk._addDirtyListener(this._onChunkDirty);
+	}
+	/** The signed chunk coordinates this node renders. */
+	get chunkX() {
+		return this._chunk.cx;
+	}
+	get chunkY() {
+		return this._chunk.cy;
+	}
+	/**
+	* The revision-cached per-tileset page geometry. Rebuilt only when the source
+	* chunk's `revision` advances; otherwise the same arrays are returned.
+	* @internal Read by the per-backend tile chunk renderer.
+	*/
+	get pages() {
+		if (this._builtRevision !== this._chunk.revision) {
+			this._pages = buildChunkPages(this._chunk, this._tilesets, this._tileWidth, this._tileHeight);
+			this._builtRevision = this._chunk.revision;
+		}
+		return this._pages;
+	}
+	/** `true` when the chunk has no drawable tiles (no geometry, no draw calls). */
+	get isEmpty() {
+		return this.pages.length === 0;
+	}
+	/**
+	* Recomputed lazily on read, so it writes `_localBounds` directly rather than
+	* going through `_setLocalBounds`: an invalidating write inside a getter
+	* would re-dirty the node on every read.
+	*/
+	getLocalBounds() {
+		return this._localBounds.set(0, 0, this._pixelWidth, this._pixelHeight);
+	}
+	destroy() {
+		if (this._chunk instanceof TileChunk) this._chunk._removeDirtyListener(this._onChunkDirty);
+		this._pages = [];
+		this._builtRevision = -1;
+		super.destroy();
+	}
+};
 
+//#endregion
 export { TileChunkNode };
-//# sourceMappingURL=TileChunkNode.js.map
+//# sourceMappingURL=TileChunkNode.js.map

package/dist/esm/TileChunkNode.js.map

@@ -1 +1 @@
-{"version":3,"file":"TileChunkNode.js","sources":["../../../src/TileChunkNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAQA;;;;;;;;;;;;;;;;;;AAkBG;AACG,MAAO,aAAc,SAAQ,QAAQ,CAAA;AACxB,IAAA,MAAM;AACN,IAAA,SAAS;AACT,IAAA,UAAU;AACV,IAAA,WAAW;AACX,IAAA,WAAW;AACX,IAAA,YAAY;IAErB,MAAM,GAAgB,EAAE;IACxB,cAAc,GAAG,EAAE;AAE3B;;;;;;;;;;AAUG;IACH,WAAA,CACE,KAAwB,EACxB,QAA4B,EAC5B,SAAiB,EACjB,UAAkB,EAClB,eAAuB,EACvB,gBAAwB,EAAA;AAExB,QAAA,KAAK,EAAE;AAEP,QAAA,IAAI,CAAC,MAAM,GAAG,KAAK;AACnB,QAAA,IAAI,CAAC,SAAS,GAAG,QAAQ;AACzB,QAAA,IAAI,CAAC,UAAU,GAAG,SAAS;AAC3B,QAAA,IAAI,CAAC,WAAW,GAAG,UAAU;QAC7B,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,KAAK,GAAG,SAAS;QAC1C,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC,MAAM,GAAG,UAAU;AAE7C,QAAA,IAAI,CAAC,WAAW,CACd,KAAK,CAAC,EAAE,GAAG,eAAe,GAAG,SAAS,EACtC,KAAK,CAAC,EAAE,GAAG,gBAAgB,GAAG,UAAU,CACzC;IACH;;AAGA,IAAA,IAAW,MAAM,GAAA;AACf,QAAA,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE;IACvB;AAEA,IAAA,IAAW,MAAM,GAAA;AACf,QAAA,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE;IACvB;AAEA;;;;AAIG;AACH,IAAA,IAAW,KAAK,GAAA;QACd,IAAI,IAAI,CAAC,cAAc,KAAK,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE;YAChD,IAAI,CAAC,MAAM,GAAG,eAAe,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,WAAW,CAAC;YAC7F,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ;QAC5C;QAEA,OAAO,IAAI,CAAC,MAAM;IACpB;;AAGA,IAAA,IAAW,OAAO,GAAA;AAChB,QAAA,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC;IAChC;IAEgB,cAAc,GAAA;AAC5B,QAAA,MAAM,MAAM,GAAG,KAAK,CAAC,cAAc,EAAE;AAErC,QAAA,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,YAAY,CAAC;AAErD,QAAA,OAAO,MAAM;IACf;IAEgB,OAAO,GAAA;AACrB,QAAA,IAAI,CAAC,MAAM,GAAG,EAAE;AAChB,QAAA,IAAI,CAAC,cAAc,GAAG,EAAE;QAExB,KAAK,CAAC,OAAO,EAAE;IACjB;AACD;;;;"}
+{"version":3,"file":"TileChunkNode.js","names":[],"sources":["../../src/TileChunkNode.ts"],"sourcesContent":["import type { ReadonlyRectangle } from '@codexo/exojs';\nimport { Drawable } from '@codexo/exojs/renderer-sdk';\n\nimport type { ChunkPage } from './chunkGeometry';\nimport { buildChunkPages } from './chunkGeometry';\nimport type { ReadonlyTileChunk } from './TileChunk';\nimport { TileChunk } from './TileChunk';\nimport type { TileSet } from './TileSet';\n\n/**\n * A single renderable tile chunk. One `TileChunkNode` is a {@link Drawable}\n * that owns the batched quad geometry for exactly one {@link ReadonlyTileChunk}\n * of one {@link import('./TileLayer').TileLayer}, positioned at the chunk's\n * pixel origin within the owning {@link TileLayerNode}.\n *\n * Geometry is built lazily and cached against the source chunk's `revision`:\n * the renderer reads {@link TileChunkNode.pages} on each visible frame, but a\n * rebuild only happens when the underlying chunk actually changed. Off-screen\n * chunks are culled by their accurate {@link getLocalBounds} before `render`\n * is ever called, so a camera pan rebuilds nothing.\n *\n * The node references - but never owns - the runtime chunk, tilesets, and\n * tileset textures. Destroying it releases only its cached CPU geometry; the\n * `TileMap`/`TileLayer` data and Loader-owned textures are untouched.\n *\n * @internal Package-internal render node; the renderer is registered for this\n * class. Applications use {@link TileMapNode} / {@link TileLayerNode}.\n */\nexport class TileChunkNode extends Drawable {\n  private readonly _chunk: ReadonlyTileChunk;\n  private readonly _tilesets: readonly TileSet[];\n  private readonly _tileWidth: number;\n  private readonly _tileHeight: number;\n  private readonly _pixelWidth: number;\n  private readonly _pixelHeight: number;\n\n  private _pages: ChunkPage[] = [];\n  private _builtRevision = -1;\n\n  /**\n   * Bound once so `TileChunk._addDirtyListener`/`_removeDirtyListener` add and\n   * remove the SAME function reference. Pushes the chunk's revision bump onto\n   * this node's own content revision (see `TileChunk._dirtyListeners`) so a\n   * `RetainedContainer` ancestor - which skips walking a content-clean\n   * subtree entirely - observes the mutation and re-collects instead of\n   * replaying stale cached geometry.\n   */\n  private readonly _onChunkDirty = (): void => {\n    this.invalidateContent();\n  };\n\n  /**\n   * @param chunk          The readonly chunk this node renders.\n   * @param tilesets       The owning layer's tileset array.\n   * @param tileWidth      Map/layer tile cell width in pixels.\n   * @param tileHeight     Map/layer tile cell height in pixels.\n   * @param chunkWidthTiles  The layer's (unclamped) chunk width in tiles, used\n   *                         to compute the chunk's pixel origin. Edge chunks\n   *                         report a smaller `chunk.width`, but always start at\n   *                         `cx * chunkWidthTiles`.\n   * @param chunkHeightTiles The layer's (unclamped) chunk height in tiles.\n   */\n  public constructor(\n    chunk: ReadonlyTileChunk,\n    tilesets: readonly TileSet[],\n    tileWidth: number,\n    tileHeight: number,\n    chunkWidthTiles: number,\n    chunkHeightTiles: number,\n  ) {\n    super();\n\n    this._chunk = chunk;\n    this._tilesets = tilesets;\n    this._tileWidth = tileWidth;\n    this._tileHeight = tileHeight;\n    this._pixelWidth = chunk.width * tileWidth;\n    this._pixelHeight = chunk.height * tileHeight;\n\n    this.setPosition(chunk.cx * chunkWidthTiles * tileWidth, chunk.cy * chunkHeightTiles * tileHeight);\n\n    // `loadedChunks()` always yields the concrete `TileChunk` behind the\n    // readonly view (see TileLayer); the guard is defensive only.\n    if (chunk instanceof TileChunk) {\n      chunk._addDirtyListener(this._onChunkDirty);\n    }\n  }\n\n  /** The signed chunk coordinates this node renders. */\n  public get chunkX(): number {\n    return this._chunk.cx;\n  }\n\n  public get chunkY(): number {\n    return this._chunk.cy;\n  }\n\n  /**\n   * The revision-cached per-tileset page geometry. Rebuilt only when the source\n   * chunk's `revision` advances; otherwise the same arrays are returned.\n   * @internal Read by the per-backend tile chunk renderer.\n   */\n  public get pages(): readonly ChunkPage[] {\n    if (this._builtRevision !== this._chunk.revision) {\n      this._pages = buildChunkPages(this._chunk, this._tilesets, this._tileWidth, this._tileHeight);\n      this._builtRevision = this._chunk.revision;\n    }\n\n    return this._pages;\n  }\n\n  /** `true` when the chunk has no drawable tiles (no geometry, no draw calls). */\n  public get isEmpty(): boolean {\n    return this.pages.length === 0;\n  }\n\n  /**\n   * Recomputed lazily on read, so it writes `_localBounds` directly rather than\n   * going through `_setLocalBounds`: an invalidating write inside a getter\n   * would re-dirty the node on every read.\n   */\n  public override getLocalBounds(): ReadonlyRectangle {\n    return this._localBounds.set(0, 0, this._pixelWidth, this._pixelHeight);\n  }\n\n  public override destroy(): void {\n    if (this._chunk instanceof TileChunk) {\n      this._chunk._removeDirtyListener(this._onChunkDirty);\n    }\n\n    this._pages = [];\n    this._builtRevision = -1;\n\n    super.destroy();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA4BA,IAAa,gBAAb,cAAmC,SAAS;CAC1C,AAAiB;CACjB,AAAiB;CACjB,AAAiB;CACjB,AAAiB;CACjB,AAAiB;CACjB,AAAiB;CAEjB,AAAQ,SAAsB,CAAC;CAC/B,AAAQ,iBAAiB;;;;;;;;;CAUzB,AAAiB,sBAA4B;EAC3C,KAAK,kBAAkB;CACzB;;;;;;;;;;;;CAaA,AAAO,YACL,OACA,UACA,WACA,YACA,iBACA,kBACA;EACA,MAAM;EAEN,KAAK,SAAS;EACd,KAAK,YAAY;EACjB,KAAK,aAAa;EAClB,KAAK,cAAc;EACnB,KAAK,cAAc,MAAM,QAAQ;EACjC,KAAK,eAAe,MAAM,SAAS;EAEnC,KAAK,YAAY,MAAM,KAAK,kBAAkB,WAAW,MAAM,KAAK,mBAAmB,UAAU;EAIjG,IAAI,iBAAiB,WACnB,MAAM,kBAAkB,KAAK,aAAa;CAE9C;;CAGA,IAAW,SAAiB;EAC1B,OAAO,KAAK,OAAO;CACrB;CAEA,IAAW,SAAiB;EAC1B,OAAO,KAAK,OAAO;CACrB;;;;;;CAOA,IAAW,QAA8B;EACvC,IAAI,KAAK,mBAAmB,KAAK,OAAO,UAAU;GAChD,KAAK,SAAS,gBAAgB,KAAK,QAAQ,KAAK,WAAW,KAAK,YAAY,KAAK,WAAW;GAC5F,KAAK,iBAAiB,KAAK,OAAO;EACpC;EAEA,OAAO,KAAK;CACd;;CAGA,IAAW,UAAmB;EAC5B,OAAO,KAAK,MAAM,WAAW;CAC/B;;;;;;CAOA,AAAgB,iBAAoC;EAClD,OAAO,KAAK,aAAa,IAAI,GAAG,GAAG,KAAK,aAAa,KAAK,YAAY;CACxE;CAEA,AAAgB,UAAgB;EAC9B,IAAI,KAAK,kBAAkB,WACzB,KAAK,OAAO,qBAAqB,KAAK,aAAa;EAGrD,KAAK,SAAS,CAAC;EACf,KAAK,iBAAiB;EAEtB,MAAM,QAAQ;CAChB;AACF"}

package/dist/esm/TileLayer.d.ts

@@ -1,3 +1,4 @@
+import type { ChunkPayload } from './ChunkSource';
 import type { ReadonlyTileChunk } from './TileChunk';
 import { TileChunk } from './TileChunk';
 import type { TileSet } from './TileSet';
@@ -12,10 +13,14 @@ export interface TileLayerOptions {
     readonly id: number;
     /** Display name (need not be unique). */
     readonly name: string;
-    /** Layer width in tiles. */
-    readonly width: number;
-    /** Layer height in tiles. */
-    readonly height: number;
+    /**
+     * Layer width in tiles. Omit together with {@link height} for an
+     * unbounded layer - chunk storage then accepts any signed chunk
+     * coordinate instead of being clamped to a fixed grid.
+     */
+    readonly width?: number;
+    /** Layer height in tiles. Must be provided iff {@link width} is. */
+    readonly height?: number;
     /** Chunk width in tiles (default 32). */
     readonly chunkWidth?: number;
     /** Chunk height in tiles (default 32). */
@@ -44,6 +49,11 @@ export interface TileLayerOptions {
      * `0.5` = half speed (farther away), `0.0` = stationary. Default 1.
      */
     readonly parallaxY?: number;
+    /**
+     * Uniform scale applied together with the camera-relative parallax shift.
+     * `1` keeps the layer at its authored size. Default `1`.
+     */
+    readonly parallaxScale?: number;
     /** Layer class/type string (Tiled `class`). Defaults to `''`. */
     readonly class?: string;
     /**
@@ -54,6 +64,30 @@ export interface TileLayerOptions {
     /** Layer properties (copied and frozen). */
     readonly properties?: TileProperties;
 }
+/**
+ * The inclusive range of chunk coordinates that intersect a bounded
+ * {@link TileLayer}. `null` for an unbounded layer (no range limit).
+ * @advanced
+ */
+export interface ChunkRange {
+    readonly minCx: number;
+    readonly minCy: number;
+    readonly maxCx: number;
+    readonly maxCy: number;
+}
+/**
+ * Fired via {@link TileLayer._addStructuralListener} whenever a chunk is
+ * installed ({@link TileLayer._adoptChunk}) or evicted
+ * ({@link TileLayer._evictChunk}) - structural changes only, not per-tile
+ * edits (see {@link import('./TileChunk').TileChunk._addDirtyListener} for
+ * those). `chunk` is `null` on eviction.
+ * @internal
+ */
+export interface ChunkStructuralEvent {
+    readonly cx: number;
+    readonly cy: number;
+    readonly chunk: ReadonlyTileChunk | null;
+}
 /**
  * A generic, format-independent tile layer with chunk-first storage.
  *
@@ -64,10 +98,10 @@ export interface TileLayerOptions {
  * **Mutation must go through the layer's public APIs only.**
  * `setTileAt` / `clearTileAt` validate coordinates, tileset references,
  * and increment revision counters only when the stored value actually
- * changes. Direct chunk mutation is not supported — the layer owns chunk
+ * changes. Direct chunk mutation is not supported - the layer owns chunk
  * storage and exposes only a {@link ReadonlyTileChunk} view.
  *
- * The layer is NOT a SceneNode — that integration lives in
+ * The layer is NOT a SceneNode - that integration lives in
  * {@link import('./TileLayerNode').TileLayerNode}.
  *
  * @advanced
@@ -77,10 +111,10 @@ export declare class TileLayer {
     readonly id: number;
     /** Display name (may not be unique). */
     readonly name: string;
-    /** Width in tiles. */
-    readonly width: number;
-    /** Height in tiles. */
-    readonly height: number;
+    /** Width in tiles, or `undefined` if unbounded. */
+    readonly width: number | undefined;
+    /** Height in tiles, or `undefined` if unbounded. */
+    readonly height: number | undefined;
     /** Chunk width (tiles). */
     readonly chunkWidth: number;
     /** Chunk height (tiles). */
@@ -89,10 +123,12 @@ export declare class TileLayer {
     readonly tileWidth: number;
     /** Tile height in pixels. */
     readonly tileHeight: number;
-    /** Pixel width. */
-    get pixelWidth(): number;
-    /** Pixel height. */
-    get pixelHeight(): number;
+    /** `true` if this layer has a fixed width/height; `false` if unbounded. */
+    get bounded(): boolean;
+    /** Pixel width, or `undefined` if unbounded. */
+    get pixelWidth(): number | undefined;
+    /** Pixel height, or `undefined` if unbounded. */
+    get pixelHeight(): number | undefined;
     /** Visibility flag (mutable). */
     visible: boolean;
     /** Opacity 0..1 (mutable). */
@@ -111,6 +147,8 @@ export declare class TileLayer {
      * `1.0` = full camera speed, `0.5` = half speed, `0.0` = stationary.
      */
     readonly parallaxY: number;
+    /** Uniform scale applied around the layer origin during parallax rendering. */
+    readonly parallaxScale: number;
     /** Layer class/type string (Tiled `class`; may be empty). */
     readonly class: string;
     /** Multiplicative layer tint as `0xRRGGBB`, or `null` for no tint. */
@@ -121,6 +159,8 @@ export declare class TileLayer {
     readonly tilesets: readonly TileSet[];
     /** Chunk storage: chunkKey → mutable TileChunk (internal). */
     private readonly _chunks;
+    /** Package-internal structural (adopt/evict) listeners. */
+    private _structuralListeners;
     /**
      * Monotonic layer revision counter.
      * Increments on every cell mutation that actually changes a stored value.
@@ -135,16 +175,15 @@ export declare class TileLayer {
     constructor(options: TileLayerOptions);
     /**
      * Check whether a tile coordinate lies within the layer bounds.
+     * Always `true` for an unbounded layer.
      * @advanced
      */
     inBounds(tx: number, ty: number): boolean;
-    /** Compute the range of chunk coordinates that intersect this layer. */
-    chunkRange(): {
-        minCx: number;
-        minCy: number;
-        maxCx: number;
-        maxCy: number;
-    };
+    /**
+     * Compute the range of chunk coordinates that intersect this layer, or
+     * `null` if the layer is unbounded (any signed chunk coordinate is valid).
+     */
+    chunkRange(): ChunkRange | null;
     private _chunkKey;
     /**
      * Get a readonly view of a chunk by signed chunk coordinates,
@@ -154,16 +193,56 @@ export declare class TileLayer {
     getChunk(cx: number, cy: number): ReadonlyTileChunk | undefined;
     /**
      * Get or create a chunk at the given coordinates.
-     * For finite layers, creation is only allowed within the valid chunk range.
+     * For a bounded layer, creation is only allowed within the valid chunk
+     * range and edge chunks are clamped to the layer's remaining size. For an
+     * unbounded layer, any signed chunk coordinate is accepted and every
+     * chunk is full-size ({@link chunkWidth} × {@link chunkHeight}).
      *
      * @internal Package-private: used by {@link setTileAt}, {@link fillRect},
      *           and future adapter ingest. External users should not allocate
-     *           chunks — use {@link setTileAt} to populate tiles.
+     *           chunks - use {@link setTileAt} to populate tiles.
      */
     _ensureChunk(cx: number, cy: number): TileChunk;
+    /**
+     * Install a chunk-provider-supplied payload directly, bypassing per-tile
+     * `setTileAt` cost. Overwrites any existing chunk at `(cx, cy)`. Always
+     * bumps the layer revision (installing a chunk is always a structural
+     * change, even if the payload happens to be all-zero).
+     *
+     * Does not validate `(cx, cy)` against {@link chunkRange} - callers
+     * (chunk-streaming controllers) are trusted to request coordinates within
+     * whatever range they intend to manage.
+     *
+     * @internal Package-private: for future chunk-provider/streaming use.
+     */
+    _adoptChunk(cx: number, cy: number, payload: ChunkPayload): void;
+    /**
+     * Evict a chunk from storage, freeing it for garbage collection. No-op if
+     * no chunk is loaded at `(cx, cy)`.
+     *
+     * @returns `true` if a chunk was found and removed, `false` otherwise.
+     * @internal Package-private: for future chunk-streaming eviction use.
+     */
+    _evictChunk(cx: number, cy: number): boolean;
+    /**
+     * Register a callback invoked synchronously whenever a chunk is installed
+     * ({@link _adoptChunk}) or evicted ({@link _evictChunk}). Package-internal:
+     * {@link import('./TileLayerNode').TileLayerNode} subscribes to keep its
+     * chunk-node children in sync with chunk-provider-driven adopt/evict calls
+     * (e.g. from {@link import('./ChunkStreamer').ChunkStreamer}) without
+     * needing a full {@link import('./TileLayerNode').TileLayerNode.refresh}.
+     * @internal
+     */
+    _addStructuralListener(listener: (event: ChunkStructuralEvent) => void): void;
+    /**
+     * Unregister a listener added via {@link _addStructuralListener} (node destroy).
+     * @internal
+     */
+    _removeStructuralListener(listener: (event: ChunkStructuralEvent) => void): void;
+    private _notifyStructural;
     /**
      * Iterate over all loaded chunks in deterministic (cy, cx) ascending order.
-     * Returns readonly chunk views — callers cannot mutate storage.
+     * Returns readonly chunk views - callers cannot mutate storage.
      * @advanced
      */
     loadedChunks(): IterableIterator<ReadonlyTileChunk>;
@@ -258,3 +337,4 @@ export declare class TileLayer {
      */
     countNonEmptyTiles(): number;
 }
+//# sourceMappingURL=TileLayer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TileLayer.d.ts","sourceRoot":"","sources":["../../src/TileLayer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAIxD;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,oEAAoE;IACpE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,yCAAyC;IACzC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,0CAA0C;IAC1C,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,8DAA8D;IAC9D,QAAQ,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IACtC,wDAAwD;IACxD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,yDAAyD;IACzD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,wCAAwC;IACxC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,+BAA+B;IAC/B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,uCAAuC;IACvC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,uCAAuC;IACvC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,iEAAiE;IACjE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,4CAA4C;IAC5C,QAAQ,CAAC,UAAU,CAAC,EAAE,cAAc,CAAC;CACtC;AAID;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAAC;CAC1C;AAuED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,SAAS;IACpB,uCAAuC;IACvC,SAAgB,EAAE,EAAE,MAAM,CAAC;IAC3B,wCAAwC;IACxC,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B,mDAAmD;IACnD,SAAgB,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C,oDAAoD;IACpD,SAAgB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAE3C,2BAA2B;IAC3B,SAAgB,UAAU,EAAE,MAAM,CAAC;IACnC,4BAA4B;IAC5B,SAAgB,WAAW,EAAE,MAAM,CAAC;IAEpC,4BAA4B;IAC5B,SAAgB,SAAS,EAAE,MAAM,CAAC;IAClC,6BAA6B;IAC7B,SAAgB,UAAU,EAAE,MAAM,CAAC;IAEnC,2EAA2E;IAC3E,IAAW,OAAO,IAAI,OAAO,CAE5B;IAED,gDAAgD;IAChD,IAAW,UAAU,IAAI,MAAM,GAAG,SAAS,CAE1C;IACD,iDAAiD;IACjD,IAAW,WAAW,IAAI,MAAM,GAAG,SAAS,CAE3C;IAED,iCAAiC;IAC1B,OAAO,EAAE,OAAO,CAAC;IACxB,8BAA8B;IACvB,OAAO,EAAE,MAAM,CAAC;IACvB,yCAAyC;IAClC,OAAO,EAAE,MAAM,CAAC;IACvB,uCAAuC;IAChC,OAAO,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,SAAgB,SAAS,EAAE,MAAM,CAAC;IAClC;;;OAGG;IACH,SAAgB,SAAS,EAAE,MAAM,CAAC;IAClC,+EAA+E;IAC/E,SAAgB,aAAa,EAAE,MAAM,CAAC;IAEtC,6DAA6D;IAC7D,SAAgB,KAAK,EAAE,MAAM,CAAC;IAC9B,sEAAsE;IACtE,SAAgB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAEzC,kCAAkC;IAClC,SAAgB,UAAU,EAAE,cAAc,CAAC;IAE3C,qEAAqE;IACrE,SAAgB,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IAE7C,8DAA8D;IAC9D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgC;IAExD,2DAA2D;IAC3D,OAAO,CAAC,oBAAoB,CAA2D;IAEvF;;;;OAIG;IACH,OAAO,CAAC,SAAS,CAAK;IAEtB,4CAA4C;IAC5C,OAAO,CAAC,UAAU,CAAS;IAE3B;;OAEG;gBACgB,OAAO,EAAE,gBAAgB;IA0B5C;;;;OAIG;IACI,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO;IAKhD;;;OAGG;IACI,UAAU,IAAI,UAAU,GAAG,IAAI;IAYtC,OAAO,CAAC,SAAS;IAIjB;;;;OAIG;IACI,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAItE;;;;;;;;;;OAUG;IACI,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS;IAwBtD;;;;;;;;;;;OAWG;IACI,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG,IAAI;IAQvE;;;;;;OAMG;IACI,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO;IASnD;;;;;;;;OAQG;IACI,sBAAsB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,GAAG,IAAI;IAIpF;;;OAGG;IACI,yBAAyB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,GAAG,IAAI;IAIvF,OAAO,CAAC,iBAAiB;IAOzB;;;;OAIG;IACI,YAAY,IAAI,gBAAgB,CAAC,iBAAiB,CAAC;IAQ1D;;;OAGG;IACI,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU;IAWvD;;;OAGG;IACI,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI;IAiB7D;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAcxB;;;;;OAKG;IACI,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI;IAiBlE;;;;;OAKG;IACI,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAmBhD;;;OAGG;IACI,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI;IAkBrF;;;OAGG;IACI,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAoBlE;;;;OAIG;IACK,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,YAAY,CAAA;KAAE,CAAC;IA4C1H;;;;OAIG;IACI,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE;IAOpE;;;;;OAKG;IACI,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE;IAStE;;;;;OAKG;IACH,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED,4CAA4C;IAC5C,IAAW,SAAS,IAAI,OAAO,CAE9B;IAED,OAAO,CAAC,eAAe;IAMvB;;;;OAIG;IACI,OAAO,IAAI,IAAI;IAMtB;;;;OAIG;IACI,kBAAkB,IAAI,MAAM;CAWpC"}