@codexo/exojs-tilemap 0.15.3 → 0.16.0

package/dist/esm/types.js

@@ -1,138 +1,129 @@
-// ── Properties ────────────────────────────────────────────────────────────
+//#region src/types.ts
 /**
- * Discriminant for the three structured, non-scalar {@link TilePropertyValue}
- * variants: {@link TilePropertyPoint}, {@link TilePropertyObjectRef}, and
- * {@link TilePropertyTileRef}.
- *
- * Modelled as a frozen string map (not a TS `enum`) so the values stay
- * wire-stable, survive `verbatimModuleSyntax` (no emitted runtime helper),
- * and follow the package convention for enum-like constants (see
- * {@link import('./ObjectLayer').ObjectKind}).
- * @stable
- */
+* Discriminant for the three structured, non-scalar {@link TilePropertyValue}
+* variants: {@link TilePropertyPoint}, {@link TilePropertyObjectRef}, and
+* {@link TilePropertyTileRef}.
+*
+* Modelled as a frozen string map (not a TS `enum`) so the values stay
+* wire-stable, survive `verbatimModuleSyntax` (no emitted runtime helper),
+* and follow the package convention for enum-like constants (see
+* {@link import('./ObjectLayer').ObjectKind}).
+* @stable
+*/
 const TilePropertyKind = {
-    Point: 'point',
-    ObjectRef: 'objectRef',
-    TileRef: 'tileRef',
+	Point: "point",
+	ObjectRef: "objectRef",
+	TileRef: "tileRef"
 };
 /** The identity transform: no flip, no diagonal. */
 const TILE_TRANSFORM_IDENTITY = Object.freeze({
-    flipX: false,
-    flipY: false,
-    diagonal: false,
+	flipX: false,
+	flipY: false,
+	diagonal: false
 });
 /** Bit width allocated to the local tile ID within a packed tile word. */
 const PACKED_LOCAL_BITS = 20;
-/** Bit width allocated to the tileset index within a packed tile word. */
-const PACKED_TILESET_BITS = 9;
-/** Bit width allocated to the transform/flip bits. */
-const PACKED_TRANSFORM_BITS = 3;
-const PACKED_LOCAL_MASK = (1 << PACKED_LOCAL_BITS) - 1;
-const PACKED_TILESET_MASK = ((1 << PACKED_TILESET_BITS) - 1) << PACKED_LOCAL_BITS;
-const PACKED_TRANSFORM_MASK = ((1 << PACKED_TRANSFORM_BITS) - 1) << (PACKED_LOCAL_BITS + PACKED_TILESET_BITS);
-const PACKED_TILESET_SHIFT = PACKED_LOCAL_BITS;
-const PACKED_TRANSFORM_SHIFT = PACKED_LOCAL_BITS + PACKED_TILESET_BITS;
+const PACKED_LOCAL_MASK = (1 << 20) - 1;
+const PACKED_TILESET_MASK = 511 << 20;
+const PACKED_TRANSFORM_MASK = 7 << 29;
+const PACKED_TILESET_SHIFT = 20;
+const PACKED_TRANSFORM_SHIFT = 29;
 /** Maximum tileset index representable in a packed tile. */
-const MAX_TILESET_INDEX = (1 << PACKED_TILESET_BITS) - 1;
+const MAX_TILESET_INDEX = 511;
 /** Maximum local tile ID representable in a packed tile (1-based storage). */
-const MAX_LOCAL_TILE_ID = (1 << PACKED_LOCAL_BITS) - 2;
-// Transform bit-field values (bit 0 = flipX, bit 1 = flipY, bit 2 = diagonal).
-const TRANSFORM_FLIP_X = 1 << 0;
-const TRANSFORM_FLIP_Y = 1 << 1;
-const TRANSFORM_DIAGONAL = 1 << 2;
+const MAX_LOCAL_TILE_ID = (1 << 20) - 2;
+const TRANSFORM_FLIP_X = 1;
+const TRANSFORM_FLIP_Y = 2;
+const TRANSFORM_DIAGONAL = 4;
 /**
- * Encode a tileset-local tile reference and transform into a packed word.
- * The localTileId is stored as (localTileId + 1) so that a packed value of 0
- * cleanly represents an empty cell, while tile 0 from tileset 0 with identity
- * transform is stored as 1 (non-zero).
- * Returns 0 for an empty cell.
- * @internal
- */
-function packTile(tilesetIndex, localTileId, transform) {
-    if (tilesetIndex < 0 || tilesetIndex > MAX_TILESET_INDEX) {
-        throw new Error(`Tileset index ${tilesetIndex} exceeds maximum ${MAX_TILESET_INDEX}.`);
-    }
-    if (localTileId < 0 || localTileId > MAX_LOCAL_TILE_ID) {
-        throw new Error(`Local tile ID ${localTileId} exceeds maximum ${MAX_LOCAL_TILE_ID}.`);
-    }
-    let bits = 0;
-    if (transform.flipX)
-        bits |= TRANSFORM_FLIP_X;
-    if (transform.flipY)
-        bits |= TRANSFORM_FLIP_Y;
-    if (transform.diagonal)
-        bits |= TRANSFORM_DIAGONAL;
-    // +1 so 0 means "empty" not "tile 0 without transform"
-    const storedId = localTileId + 1;
-    return (storedId & PACKED_LOCAL_MASK)
-        | ((tilesetIndex << PACKED_TILESET_SHIFT) & PACKED_TILESET_MASK)
-        | ((bits << PACKED_TRANSFORM_SHIFT) & PACKED_TRANSFORM_MASK);
-}
+* Encode a tileset-local tile reference and transform into a packed word.
+* The localTileId is stored as (localTileId + 1) so that a packed value of 0
+* cleanly represents an empty cell, while tile 0 from tileset 0 with identity
+* transform is stored as 1 (non-zero).
+* Returns 0 for an empty cell.
+*
+* Public so chunk-provider authors (e.g. a format adapter or procedural
+* generator) can build a {@link ChunkPayload}'s `tiles` array without
+* duplicating this encoding.
+* @advanced
+*/
+const packTile = (tilesetIndex, localTileId, transform) => {
+	if (tilesetIndex < 0 || tilesetIndex > 511) throw new Error(`Tileset index ${tilesetIndex} exceeds maximum ${511}.`);
+	if (localTileId < 0 || localTileId > 1048574) throw new Error(`Local tile ID ${localTileId} exceeds maximum ${MAX_LOCAL_TILE_ID}.`);
+	let bits = 0;
+	if (transform.flipX) bits |= TRANSFORM_FLIP_X;
+	if (transform.flipY) bits |= TRANSFORM_FLIP_Y;
+	if (transform.diagonal) bits |= TRANSFORM_DIAGONAL;
+	return localTileId + 1 & PACKED_LOCAL_MASK | tilesetIndex << 20 & PACKED_TILESET_MASK | bits << 29 & PACKED_TRANSFORM_MASK;
+};
 /**
- * Decode a packed word into its components.
- * Returns null for an empty cell (packed === 0).
- * @internal
- */
-function unpackTile(packed) {
-    if (packed === 0)
-        return null;
-    const storedId = packed & PACKED_LOCAL_MASK;
-    // Undo the +1 offset applied during packTile.
-    const localTileId = storedId - 1;
-    const tilesetIndex = (packed & PACKED_TILESET_MASK) >>> PACKED_TILESET_SHIFT;
-    const rawTransform = (packed & PACKED_TRANSFORM_MASK) >>> PACKED_TRANSFORM_SHIFT;
-    return {
-        tilesetIndex,
-        localTileId,
-        transform: {
-            flipX: !!(rawTransform & TRANSFORM_FLIP_X),
-            flipY: !!(rawTransform & TRANSFORM_FLIP_Y),
-            diagonal: !!(rawTransform & TRANSFORM_DIAGONAL),
-        },
-    };
-}
+* Decode a packed word into its components.
+* Returns null for an empty cell (packed === 0).
+* @advanced
+*/
+const unpackTile = (packed) => {
+	if (packed === 0) return null;
+	const localTileId = (packed & PACKED_LOCAL_MASK) - 1;
+	const tilesetIndex = (packed & PACKED_TILESET_MASK) >>> 20;
+	const rawTransform = (packed & PACKED_TRANSFORM_MASK) >>> 29;
+	return {
+		tilesetIndex,
+		localTileId,
+		transform: {
+			flipX: !!(rawTransform & TRANSFORM_FLIP_X),
+			flipY: !!(rawTransform & TRANSFORM_FLIP_Y),
+			diagonal: !!(rawTransform & TRANSFORM_DIAGONAL)
+		}
+	};
+};
 /** Convert tile coordinates to chunk coordinates given a chunk size. */
-function tileToChunkCoord(tx, ty, chunkW, chunkH) {
-    return {
-        cx: Math.floor(tx / chunkW),
-        cy: Math.floor(ty / chunkH),
-    };
-}
+const tileToChunkCoord = (tx, ty, chunkW, chunkH) => ({
+	cx: Math.floor(tx / chunkW),
+	cy: Math.floor(ty / chunkH)
+});
 /** Convert tile coordinates to local-in-chunk coordinates. */
-function tileToLocalInChunk(tx, ty, chunkW, chunkH) {
-    return {
-        lx: ((tx % chunkW) + chunkW) % chunkW,
-        ly: ((ty % chunkH) + chunkH) % chunkH,
-    };
-}
+const tileToLocalInChunk = (tx, ty, chunkW, chunkH) => ({
+	lx: (tx % chunkW + chunkW) % chunkW,
+	ly: (ty % chunkH + chunkH) % chunkH
+});
 /**
- * Validate that a value is a finite, safe, positive integer.
- * Used for dimensions, tile counts, chunk sizes.
- */
-function validatePositiveInteger(value, label) {
-    if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
-        throw new Error(`${label} must be a positive integer (got ${value}).`);
-    }
-    if (value > Number.MAX_SAFE_INTEGER) {
-        throw new Error(`${label} exceeds safe integer range (got ${value}).`);
-    }
-}
+* Validate that a value is a finite, safe, positive integer.
+* Used for dimensions, tile counts, chunk sizes.
+*/
+const validatePositiveInteger = (value, label) => {
+	if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) throw new Error(`${label} must be a positive integer (got ${value}).`);
+	if (value > Number.MAX_SAFE_INTEGER) throw new Error(`${label} exceeds safe integer range (got ${value}).`);
+};
 /**
- * Validate a non-negative finite integer.
- */
-function validateNonNegativeInteger(value, label) {
-    if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
-        throw new Error(`${label} must be a non-negative integer (got ${value}).`);
-    }
-}
+* Validate a non-negative finite integer.
+*/
+const validateNonNegativeInteger = (value, label) => {
+	if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) throw new Error(`${label} must be a non-negative integer (got ${value}).`);
+};
+/**
+* Validate that a value is a finite integer (may be negative).
+*/
+const validateInteger = (value, label) => {
+	if (!Number.isFinite(value) || !Number.isInteger(value)) throw new Error(`${label} must be a finite integer (got ${value}).`);
+};
 /**
- * Validate that a value is a finite integer (may be negative).
- */
-function validateInteger(value, label) {
-    if (!Number.isFinite(value) || !Number.isInteger(value)) {
-        throw new Error(`${label} must be a finite integer (got ${value}).`);
-    }
-}
+* Validate a `width`/`height` pair that must be provided together (bounded)
+* or omitted together (unbounded) - shared by {@link import('./TileLayer').TileLayer}
+* and {@link import('./TileMap').TileMap}. When both are provided, each is
+* validated as a positive integer via {@link validatePositiveInteger}.
+*
+* @param entityName Used in the paired-presence error message (e.g. `"TileLayer"`).
+* @param fieldPrefix Used as the field-name prefix passed to {@link validatePositiveInteger} (e.g. `"layer"` for `"layer.width"`).
+* @throws If exactly one of `width`/`height` is provided, or either is not a positive integer.
+*/
+const validatePairedDimensions = (width, height, entityName, fieldPrefix) => {
+	if (width !== void 0 || height !== void 0) {
+		if (width === void 0 || height === void 0) throw new Error(`${entityName} width and height must both be provided (bounded) or both omitted (unbounded).`);
+		validatePositiveInteger(width, `${fieldPrefix}.width`);
+		validatePositiveInteger(height, `${fieldPrefix}.height`);
+	}
+};
 
-export { MAX_LOCAL_TILE_ID, MAX_TILESET_INDEX, PACKED_LOCAL_BITS, PACKED_LOCAL_MASK, PACKED_TILESET_BITS, PACKED_TILESET_MASK, PACKED_TILESET_SHIFT, PACKED_TRANSFORM_BITS, PACKED_TRANSFORM_MASK, PACKED_TRANSFORM_SHIFT, TILE_TRANSFORM_IDENTITY, TilePropertyKind, packTile, tileToChunkCoord, tileToLocalInChunk, unpackTile, validateInteger, validateNonNegativeInteger, validatePositiveInteger };
-//# sourceMappingURL=types.js.map
+//#endregion
+export { MAX_LOCAL_TILE_ID, PACKED_LOCAL_MASK, PACKED_TILESET_MASK, PACKED_TRANSFORM_MASK, TILE_TRANSFORM_IDENTITY, TilePropertyKind, packTile, tileToChunkCoord, tileToLocalInChunk, unpackTile, validateInteger, validateNonNegativeInteger, validatePairedDimensions, validatePositiveInteger };
+//# sourceMappingURL=types.js.map

package/dist/esm/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sources":["../../../src/types.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"types.js","names":[],"sources":["../../src/types.ts"],"sourcesContent":["import type { TileMapObject } from './ObjectLayer';\nimport type { TileSet } from './TileSet';\n\n// ── Properties ────────────────────────────────────────────────────────────\n\n/**\n * Discriminant for the three structured, non-scalar {@link TilePropertyValue}\n * variants: {@link TilePropertyPoint}, {@link TilePropertyObjectRef}, and\n * {@link TilePropertyTileRef}.\n *\n * Modelled as a frozen string map (not a TS `enum`) so the values stay\n * wire-stable, survive `verbatimModuleSyntax` (no emitted runtime helper),\n * and follow the package convention for enum-like constants (see\n * {@link import('./ObjectLayer').ObjectKind}).\n * @stable\n */\nexport const TilePropertyKind = {\n  Point: 'point',\n  ObjectRef: 'objectRef',\n  TileRef: 'tileRef',\n} as const;\n\n/** Structured-value discriminant for {@link TilePropertyValue}. */\nexport type TilePropertyKind = (typeof TilePropertyKind)[keyof typeof TilePropertyKind];\n\n/** A 2D point-valued tile property (e.g. an LDtk `Point` field). */\nexport interface TilePropertyPoint {\n  readonly kind: typeof TilePropertyKind.Point;\n  readonly cx: number;\n  readonly cy: number;\n}\n\n/**\n * A reference to another object/entity. `id` is the referenced object's\n * identity - Tiled's numeric object id, or LDtk's `entityIid`. The extra\n * fields are LDtk-only navigation context (`undefined` for Tiled-sourced\n * refs) that lets a consumer resolve the reference without searching the\n * whole level tree.\n */\nexport interface TilePropertyObjectRef {\n  readonly kind: typeof TilePropertyKind.ObjectRef;\n  readonly id: string | number;\n  readonly layerIid?: string;\n  readonly levelIid?: string;\n  readonly worldIid?: string;\n}\n\n/** A reference into a tileset region (e.g. an LDtk `Tile`-typed field). */\nexport interface TilePropertyTileRef {\n  readonly kind: typeof TilePropertyKind.TileRef;\n  readonly tilesetUid: number;\n  readonly x: number;\n  readonly y: number;\n  readonly w: number;\n  readonly h: number;\n}\n\n/**\n * Union of legal tile-property value types in the generic runtime.\n * Format-neutral; adapters map their native property systems into this set -\n * including the structured {@link TilePropertyPoint}, {@link TilePropertyObjectRef},\n * and {@link TilePropertyTileRef} variants, arrays of any of the above, and\n * nested property bags (e.g. Tiled `class`-typed properties).\n * @advanced\n */\nexport type TilePropertyValue =\n  null | boolean | number | string | TilePropertyPoint | TilePropertyObjectRef | TilePropertyTileRef | readonly TilePropertyValue[] | TileProperties;\n\n/**\n * An immutable, flat key-value bag of generic tile properties.\n * Adapters copy and freeze source properties; the runtime never retains\n * a caller-owned mutable object.\n *\n * Declared as an interface (not a `Record<...>` type alias) so it can\n * mutually recurse with {@link TilePropertyValue} - a nested-bag member of\n * that union - without TypeScript's \"circularly references itself\" alias\n * restriction; structurally it behaves exactly like\n * `Readonly<Record<string, TilePropertyValue>>`.\n * @advanced\n */\nexport interface TileProperties {\n  readonly [key: string]: TilePropertyValue;\n}\n\n// ── Tile orientation / transform ──────────────────────────────────────────\n\n/**\n * Describes the orientation of a placed tile independent of source-format\n * flip-bit encodings. The eight legal combinations map to the eight distinct\n * 90°-rotation-and-flip states of a rectangular texture quad.\n *\n * Applying the transform at geometry-build time (reordering UV corners)\n * avoids per-tile runtime cost and per-frame matrix allocation.\n * @stable\n */\nexport interface TileTransform {\n  /** Horizontal flip (mirror left-right). */\n  readonly flipX: boolean;\n  /** Vertical flip (mirror top-bottom). */\n  readonly flipY: boolean;\n  /** Anti-diagonal flip (transpose of the UV axes). Combined with flips produces 90° rotations. */\n  readonly diagonal: boolean;\n}\n\n/** The identity transform: no flip, no diagonal. */\nexport const TILE_TRANSFORM_IDENTITY: Readonly<TileTransform> = Object.freeze({\n  flipX: false,\n  flipY: false,\n  diagonal: false,\n});\n\n/**\n * Short string label for a {@link TileTransform} (debug / serialisation).\n * Returns one of the eight deterministic names, e.g. `\"flipX\"` or `\"diag+flipX+flipY\"`.\n * @internal\n */\nexport const tileTransformLabel = (t: TileTransform): string => {\n  const parts: string[] = [];\n  if (t.diagonal) parts.push('diag');\n  if (t.flipX) parts.push('flipX');\n  if (t.flipY) parts.push('flipY');\n  return parts.length === 0 ? 'identity' : parts.join('+');\n};\n\n// ── Tile identity ─────────────────────────────────────────────────────────\n\n/**\n * Opaque packed tile data stored in a {@link TileChunk}'s compact array.\n * 0 means \"empty cell\". Any non-zero value encodes localTileId, tilesetIndex,\n * and flip bits according to the bit-layout constants below.\n *\n * A `PackedTile` is **not** a source-format GID - it is a fully resolved\n * internal compact representation. Use {@link packTile} / {@link unpackTile}\n * to convert between packed form and a {@link ResolvedTile} if writing\n * adapters.\n *\n * In public APIs, prefer {@link ResolvedTile} or null for queries.\n * `PackedTile` is exposed as `@advanced` so `ReadonlyTileChunk.getRawAt()`\n * has a self-documenting return type.\n * @advanced\n */\nexport type PackedTile = number;\n\n/** Bit width allocated to the local tile ID within a packed tile word. */\nexport const PACKED_LOCAL_BITS = 20;\n/** Bit width allocated to the tileset index within a packed tile word. */\nexport const PACKED_TILESET_BITS = 9;\n/** Bit width allocated to the transform/flip bits. */\nexport const PACKED_TRANSFORM_BITS = 3;\n\nexport const PACKED_LOCAL_MASK = (1 << PACKED_LOCAL_BITS) - 1;\nexport const PACKED_TILESET_MASK = ((1 << PACKED_TILESET_BITS) - 1) << PACKED_LOCAL_BITS;\nexport const PACKED_TRANSFORM_MASK = ((1 << PACKED_TRANSFORM_BITS) - 1) << (PACKED_LOCAL_BITS + PACKED_TILESET_BITS);\n\nexport const PACKED_TILESET_SHIFT = PACKED_LOCAL_BITS;\nexport const PACKED_TRANSFORM_SHIFT = PACKED_LOCAL_BITS + PACKED_TILESET_BITS;\n\n/** Maximum tileset index representable in a packed tile. */\nexport const MAX_TILESET_INDEX = (1 << PACKED_TILESET_BITS) - 1;\n/** Maximum local tile ID representable in a packed tile (1-based storage). */\nexport const MAX_LOCAL_TILE_ID = (1 << PACKED_LOCAL_BITS) - 2;\n\n// Transform bit-field values (bit 0 = flipX, bit 1 = flipY, bit 2 = diagonal).\nconst TRANSFORM_FLIP_X = 1 << 0;\nconst TRANSFORM_FLIP_Y = 1 << 1;\nconst TRANSFORM_DIAGONAL = 1 << 2;\n\n/**\n * Encode a tileset-local tile reference and transform into a packed word.\n * The localTileId is stored as (localTileId + 1) so that a packed value of 0\n * cleanly represents an empty cell, while tile 0 from tileset 0 with identity\n * transform is stored as 1 (non-zero).\n * Returns 0 for an empty cell.\n *\n * Public so chunk-provider authors (e.g. a format adapter or procedural\n * generator) can build a {@link ChunkPayload}'s `tiles` array without\n * duplicating this encoding.\n * @advanced\n */\nexport const packTile = (tilesetIndex: number, localTileId: number, transform: TileTransform): PackedTile => {\n  if (tilesetIndex < 0 || tilesetIndex > MAX_TILESET_INDEX) {\n    throw new Error(`Tileset index ${tilesetIndex} exceeds maximum ${MAX_TILESET_INDEX}.`);\n  }\n  if (localTileId < 0 || localTileId > MAX_LOCAL_TILE_ID) {\n    throw new Error(`Local tile ID ${localTileId} exceeds maximum ${MAX_LOCAL_TILE_ID}.`);\n  }\n  let bits = 0;\n  if (transform.flipX) bits |= TRANSFORM_FLIP_X;\n  if (transform.flipY) bits |= TRANSFORM_FLIP_Y;\n  if (transform.diagonal) bits |= TRANSFORM_DIAGONAL;\n  // +1 so 0 means \"empty\" not \"tile 0 without transform\"\n  const storedId = localTileId + 1;\n  return (\n    (storedId & PACKED_LOCAL_MASK) | ((tilesetIndex << PACKED_TILESET_SHIFT) & PACKED_TILESET_MASK) | ((bits << PACKED_TRANSFORM_SHIFT) & PACKED_TRANSFORM_MASK)\n  );\n};\n\n/**\n * Decode a packed word into its components.\n * Returns null for an empty cell (packed === 0).\n * @advanced\n */\nexport const unpackTile = (\n  packed: PackedTile,\n): {\n  tilesetIndex: number;\n  localTileId: number;\n  transform: TileTransform;\n} | null => {\n  if (packed === 0) return null;\n  const storedId = packed & PACKED_LOCAL_MASK;\n  // Undo the +1 offset applied during packTile.\n  const localTileId = storedId - 1;\n  const tilesetIndex = (packed & PACKED_TILESET_MASK) >>> PACKED_TILESET_SHIFT;\n  const rawTransform = (packed & PACKED_TRANSFORM_MASK) >>> PACKED_TRANSFORM_SHIFT;\n  return {\n    tilesetIndex,\n    localTileId,\n    transform: {\n      flipX: !!(rawTransform & TRANSFORM_FLIP_X),\n      flipY: !!(rawTransform & TRANSFORM_FLIP_Y),\n      diagonal: !!(rawTransform & TRANSFORM_DIAGONAL),\n    },\n  };\n};\n\n// ── Resolved tile reference (public query result) ─────────────────────────\n\n/**\n * A fully resolved, format-independent tile reference returned by queries.\n * Materialised on-demand from the packed storage; never stored as a per-cell\n * heap object.\n * @advanced\n */\nexport interface ResolvedTile {\n  /** The owning tileset (already resolved from source-format GID). */\n  readonly tileset: TileSet;\n  /** 0-based tile index within the tileset. */\n  readonly localTileId: number;\n  /** Orientation transform for this placed tile. */\n  readonly transform: TileTransform;\n}\n\n// ── Tile animation ────────────────────────────────────────────────────────\n\n/**\n * One frame of a tile animation: which local tile to show, and for how long.\n * Mirrors Tiled's per-tile animation frame model.\n * @advanced\n */\nexport interface TileAnimationFrame {\n  /** Local tile ID shown during this frame (within the tile's own tileset). */\n  readonly localTileId: number;\n  /** Frame duration in milliseconds. */\n  readonly duration: number;\n}\n\n// ── TileDefinition ────────────────────────────────────────────────────────\n\n/**\n * Optional per-tile metadata in a {@link TileSet}. Sparse - only defined\n * tiles carry a definition.\n * @advanced\n */\nexport interface TileDefinition {\n  /** The local tile ID this definition belongs to. */\n  readonly localTileId: number;\n  /** Tile properties (copied and frozen by the tileset). */\n  readonly properties?: TileProperties;\n  /**\n   * Animation frame sequence for this tile, if animated. The frames are\n   * driven at runtime by a {@link import('./TileAnimator').TileAnimator};\n   * frame[0] is the tile's resting/base frame.\n   */\n  readonly animation?: readonly TileAnimationFrame[];\n  /**\n   * Per-tile collision shapes sourced from the Tiled `objectgroup` on the tile.\n   * Shapes are in tile-local pixel space (origin = top-left of the tile cell).\n   * Only present when the source map defines collision geometry for this tile.\n   */\n  readonly collision?: readonly TileMapObject[];\n}\n\n// ── Chunk coordinate helpers ──────────────────────────────────────────────\n\n/** A signed chunk coordinate pair. */\nexport interface ChunkCoord {\n  readonly cx: number;\n  readonly cy: number;\n}\n\n/** Convert tile coordinates to chunk coordinates given a chunk size. */\nexport const tileToChunkCoord = (tx: number, ty: number, chunkW: number, chunkH: number): ChunkCoord => ({\n  cx: Math.floor(tx / chunkW),\n  cy: Math.floor(ty / chunkH),\n});\n\n/** Convert tile coordinates to local-in-chunk coordinates. */\nexport const tileToLocalInChunk = (tx: number, ty: number, chunkW: number, chunkH: number): { lx: number; ly: number } => ({\n  lx: ((tx % chunkW) + chunkW) % chunkW,\n  ly: ((ty % chunkH) + chunkH) % chunkH,\n});\n\n/**\n * Validate that a value is a finite, safe, positive integer.\n * Used for dimensions, tile counts, chunk sizes.\n */\nexport const validatePositiveInteger = (value: number, label: string): void => {\n  if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {\n    throw new Error(`${label} must be a positive integer (got ${value}).`);\n  }\n  if (value > Number.MAX_SAFE_INTEGER) {\n    throw new Error(`${label} exceeds safe integer range (got ${value}).`);\n  }\n};\n\n/**\n * Validate a non-negative finite integer.\n */\nexport const validateNonNegativeInteger = (value: number, label: string): void => {\n  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {\n    throw new Error(`${label} must be a non-negative integer (got ${value}).`);\n  }\n};\n\n/**\n * Validate that a value is a finite integer (may be negative).\n */\nexport const validateInteger = (value: number, label: string): void => {\n  if (!Number.isFinite(value) || !Number.isInteger(value)) {\n    throw new Error(`${label} must be a finite integer (got ${value}).`);\n  }\n};\n\n/**\n * Validate a `width`/`height` pair that must be provided together (bounded)\n * or omitted together (unbounded) - shared by {@link import('./TileLayer').TileLayer}\n * and {@link import('./TileMap').TileMap}. When both are provided, each is\n * validated as a positive integer via {@link validatePositiveInteger}.\n *\n * @param entityName Used in the paired-presence error message (e.g. `\"TileLayer\"`).\n * @param fieldPrefix Used as the field-name prefix passed to {@link validatePositiveInteger} (e.g. `\"layer\"` for `\"layer.width\"`).\n * @throws If exactly one of `width`/`height` is provided, or either is not a positive integer.\n */\nexport const validatePairedDimensions = (width: number | undefined, height: number | undefined, entityName: string, fieldPrefix: string): void => {\n  if (width !== undefined || height !== undefined) {\n    if (width === undefined || height === undefined) {\n      throw new Error(`${entityName} width and height must both be provided (bounded) or both omitted (unbounded).`);\n    }\n    validatePositiveInteger(width, `${fieldPrefix}.width`);\n    validatePositiveInteger(height, `${fieldPrefix}.height`);\n  }\n};\n"],"mappings":";;;;;;;;;;;;AAgBA,MAAa,mBAAmB;CAC9B,OAAO;CACP,WAAW;CACX,SAAS;AACX;;AAqFA,MAAa,0BAAmD,OAAO,OAAO;CAC5E,OAAO;CACP,OAAO;CACP,UAAU;AACZ,CAAC;;AAmCD,MAAa,oBAAoB;AAMjC,MAAa,qBAAqB,WAA0B;AAC5D,MAAa,sBAAuB;AACpC,MAAa,wBAAyB,KAAsC;AAE5E,MAAa;AACb,MAAa,yBAAyB;;AAGtC,MAAa,oBAAoB;;AAEjC,MAAa,qBAAqB,WAA0B;AAG5D,MAAM,mBAAmB;AACzB,MAAM,mBAAmB;AACzB,MAAM,qBAAqB;;;;;;;;;;;;;AAc3B,MAAa,YAAY,cAAsB,aAAqB,cAAyC;CAC3G,IAAI,eAAe,KAAK,oBACtB,MAAM,IAAI,MAAM,iBAAiB,aAAa,uBAAqC,EAAE;CAEvF,IAAI,cAAc,KAAK,uBACrB,MAAM,IAAI,MAAM,iBAAiB,YAAY,mBAAmB,kBAAkB,EAAE;CAEtF,IAAI,OAAO;CACX,IAAI,UAAU,OAAO,QAAQ;CAC7B,IAAI,UAAU,OAAO,QAAQ;CAC7B,IAAI,UAAU,UAAU,QAAQ;CAGhC,OADiB,cAAc,IAEjB,oBAAuB,qBAAwC,sBAAyB,aAAkC;AAE1I;;;;;;AAOA,MAAa,cACX,WAKU;CACV,IAAI,WAAW,GAAG,OAAO;CAGzB,MAAM,eAFW,SAAS,qBAEK;CAC/B,MAAM,gBAAgB,SAAS;CAC/B,MAAM,gBAAgB,SAAS;CAC/B,OAAO;EACL;EACA;EACA,WAAW;GACT,OAAO,CAAC,EAAE,eAAe;GACzB,OAAO,CAAC,EAAE,eAAe;GACzB,UAAU,CAAC,EAAE,eAAe;EAC9B;CACF;AACF;;AAoEA,MAAa,oBAAoB,IAAY,IAAY,QAAgB,YAAgC;CACvG,IAAI,KAAK,MAAM,KAAK,MAAM;CAC1B,IAAI,KAAK,MAAM,KAAK,MAAM;AAC5B;;AAGA,MAAa,sBAAsB,IAAY,IAAY,QAAgB,YAAgD;CACzH,KAAM,KAAK,SAAU,UAAU;CAC/B,KAAM,KAAK,SAAU,UAAU;AACjC;;;;;AAMA,MAAa,2BAA2B,OAAe,UAAwB;CAC7E,IAAI,CAAC,OAAO,SAAS,KAAK,KAAK,CAAC,OAAO,UAAU,KAAK,KAAK,SAAS,GAClE,MAAM,IAAI,MAAM,GAAG,MAAM,mCAAmC,MAAM,GAAG;CAEvE,IAAI,QAAQ,OAAO,kBACjB,MAAM,IAAI,MAAM,GAAG,MAAM,mCAAmC,MAAM,GAAG;AAEzE;;;;AAKA,MAAa,8BAA8B,OAAe,UAAwB;CAChF,IAAI,CAAC,OAAO,SAAS,KAAK,KAAK,CAAC,OAAO,UAAU,KAAK,KAAK,QAAQ,GACjE,MAAM,IAAI,MAAM,GAAG,MAAM,uCAAuC,MAAM,GAAG;AAE7E;;;;AAKA,MAAa,mBAAmB,OAAe,UAAwB;CACrE,IAAI,CAAC,OAAO,SAAS,KAAK,KAAK,CAAC,OAAO,UAAU,KAAK,GACpD,MAAM,IAAI,MAAM,GAAG,MAAM,iCAAiC,MAAM,GAAG;AAEvE;;;;;;;;;;;AAYA,MAAa,4BAA4B,OAA2B,QAA4B,YAAoB,gBAA8B;CAChJ,IAAI,UAAU,UAAa,WAAW,QAAW;EAC/C,IAAI,UAAU,UAAa,WAAW,QACpC,MAAM,IAAI,MAAM,GAAG,WAAW,+EAA+E;EAE/G,wBAAwB,OAAO,GAAG,YAAY,OAAO;EACrD,wBAAwB,QAAQ,GAAG,YAAY,QAAQ;CACzD;AACF"}

package/dist/esm/webgl2/WebGl2TileChunkRenderer.d.ts

@@ -1,4 +1,4 @@
-import type { WebGl2Backend } from '@codexo/exojs/renderer-sdk';
+import type { WebGl2Backend, WebGl2RetainedBatchPayload, WebGl2RetainedBatchReplayer, WebGl2RetainedNodeIndexRange } from '@codexo/exojs/renderer-sdk';
 import { AbstractWebGl2Renderer } from '@codexo/exojs/renderer-sdk';
 import type { TileChunkNode } from '../TileChunkNode';
 /**
@@ -9,19 +9,35 @@ import type { TileChunkNode } from '../TileChunkNode';
  * orientation-neutral and never re-uploaded for a camera pan.
  * @internal
  */
-export declare class WebGl2TileChunkRenderer extends AbstractWebGl2Renderer<TileChunkNode> {
+export declare class WebGl2TileChunkRenderer extends AbstractWebGl2Renderer<TileChunkNode> implements WebGl2RetainedBatchReplayer {
+    /**
+     * Retained-batch capability opt-in: a tile chunk's per-flush
+     * instanced batches (fixed 32-byte layout, tile word at word 7) can be
+     * recorded into a group's instruction set and replayed from group-owned
+     * resources. Pixel-snapped draws are excluded by the collect-time
+     * recordability predicate (and belt-and-braces poisoning in {@link render});
+     * tile chunks have no custom-material path to exclude.
+     * @internal
+     */
+    readonly _supportsRetainedBatches = true;
     private readonly _shader;
     private readonly _batchSize;
     private readonly _instanceData;
     private readonly _instanceFloat32;
     private readonly _instanceUint32;
     private readonly _transformUnitScratch;
+    private readonly _baseTextureUnitScratch;
+    private readonly _recordTextures;
     private _quadIndex;
     private _maxNodeIndex;
+    private _batchNodeCount;
+    private _nodeBooked;
     private _currentBlendMode;
     private _currentTexture;
     private _currentView;
     private _currentViewId;
+    private _hasWrittenGroup;
+    private readonly _writtenGroupData;
     private _instanceBuffer;
     private _vao;
     private _connection;
@@ -30,6 +46,37 @@ export declare class WebGl2TileChunkRenderer extends AbstractWebGl2Renderer<Tile
     private _renderPage;
     private _writeRun;
     flush(): void;
+    /**
+     * Stage `u_projection` (live view) and `u_group` (live composed group
+     * matrix) on the shader, guarded by cached view/group stamps. Shared by the
+     * live flush path and retained-batch replay - replay resolves exactly the
+     * same live state a slow-path flush would.
+     */
+    private _stageViewUniforms;
+    /** @internal See {@link WebGl2RetainedBatchReplayer._scanRetainedNodeIndexRange}. */
+    _scanRetainedNodeIndexRange(payload: WebGl2RetainedBatchPayload, range: WebGl2RetainedNodeIndexRange): void;
+    /** @internal See {@link WebGl2RetainedBatchReplayer._rebaseRetainedNodeIndices} (group-local indices). */
+    _rebaseRetainedNodeIndices(payload: WebGl2RetainedBatchPayload, base: number): void;
+    /**
+     * Point the batch VAO's per-instance attributes at the bundle's persistent
+     * instance buffer, based at the batch's byte offset (WebGL2 has no
+     * baseInstance, hence one small VAO per recorded batch). Same attribute
+     * set/locations as the live VAO in {@link onConnect}.
+     * @internal
+     */
+    _configureRetainedVao(payload: WebGl2RetainedBatchPayload): void;
+    /**
+     * Replay one recorded batch: all STATE is resolved live - blend mode via
+     * the backend's dedup, `u_projection`/`u_group` from the live view + live
+     * composed group matrix (the camera-pan / group-move win), the single
+     * tileset texture bound to unit 0 by recorded slot order - and only the
+     * DATA is cached: the instance bytes in the bundle buffer (bound through
+     * the per-batch VAO) and the group-owned transform texture on the shared
+     * transform unit. The backend hook flushed any pending live batch before
+     * dispatching here and bumps the stats from the instruction descriptor.
+     * @internal
+     */
+    _replayRetainedBatch(payload: WebGl2RetainedBatchPayload): void;
     protected onConnect(backend: WebGl2Backend): void;
     protected onDisconnect(): void;
     destroy(): void;
@@ -37,3 +84,4 @@ export declare class WebGl2TileChunkRenderer extends AbstractWebGl2Renderer<Tile
     private _createBufferRuntime;
     private _createVaoRuntime;
 }
+//# sourceMappingURL=WebGl2TileChunkRenderer.d.ts.map

package/dist/esm/webgl2/WebGl2TileChunkRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGl2TileChunkRenderer.d.ts","sourceRoot":"","sources":["../../../src/webgl2/WebGl2TileChunkRenderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,aAAa,EAEb,0BAA0B,EAC1B,2BAA2B,EAC3B,4BAA4B,EAE7B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,sBAAsB,EAavB,MAAM,4BAA4B,CAAC;AAGpC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAqBtD;;;;;;;GAOG;AACH,qBAAa,uBAAwB,SAAQ,sBAAsB,CAAC,aAAa,CAAE,YAAW,2BAA2B;IACvH;;;;;;;;OAQG;IACH,SAAgB,wBAAwB,QAAQ;IAEhD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAc;IAC5C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAe;IAChD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAc;IAE9C,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAsD;IAG5F,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAmC;IAG3E,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAiD;IAEjF,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,aAAa,CAAK;IAM1B,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,iBAAiB,CAA2B;IACpD,OAAO,CAAC,eAAe,CAAwB;IAC/C,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,cAAc,CAAM;IAC5B,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAuB;IAEzD,OAAO,CAAC,eAAe,CAAmC;IAC1D,OAAO,CAAC,IAAI,CAAwC;IACpD,OAAO,CAAC,WAAW,CAAuC;gBAEvC,SAAS,EAAE,MAAM;IAU7B,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI;IAsBxC,OAAO,CAAC,WAAW;IA8CnB,OAAO,CAAC,SAAS;IA0DV,KAAK,IAAI,IAAI;IAqDpB;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;IA4B1B,qFAAqF;IAC9E,2BAA2B,CAAC,OAAO,EAAE,0BAA0B,EAAE,KAAK,EAAE,4BAA4B,GAAG,IAAI;IAqBlH,0GAA0G;IACnG,0BAA0B,CAAC,OAAO,EAAE,0BAA0B,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAgB1F;;;;;;OAMG;IACI,qBAAqB,CAAC,OAAO,EAAE,0BAA0B,GAAG,IAAI;IAkBvE;;;;;;;;;;OAUG;IACI,oBAAoB,CAAC,OAAO,EAAE,0BAA0B,GAAG,IAAI;IAgDtE,SAAS,CAAC,SAAS,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAkBjD,SAAS,CAAC,YAAY,IAAI,IAAI;IAkBvB,OAAO,IAAI,IAAI;IAKtB,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,oBAAoB;IAiC5B,OAAO,CAAC,iBAAiB;CA8C1B"}