@codexo/exojs 0.12.0 → 0.13.0

package/dist/exo.esm.js

@@ -2567,7 +2567,7 @@ var CollisionType;
     CollisionType[CollisionType["SceneNode"] = 6] = "SceneNode";
 })(CollisionType || (CollisionType = {}));
 
-const epsilon = 1e-10;
+const epsilon$1 = 1e-10;
 const getCurveSegments = (radiusA, radiusB = radiusA) => Math.max(16, Math.ceil(Math.sqrt(Math.max(radiusA, radiusB)) * 8));
 /** Generate a polygon approximation of an ellipse as an array of world-space points. Segment count scales with the larger radius. */
 const buildEllipsePoints = ({ x: centerX, y: centerY, rx, ry }) => {
@@ -2612,10 +2612,10 @@ const buildRectanglePoints = ({ x, y, width, height }) => [
 ];
 /** Translate a polygon's local-space `points` by its world offset `(x, y)`. */
 const buildPolygonWorldPoints = ({ x: offsetX, y: offsetY, points }) => points.map(({ x, y }) => ({ x: x + offsetX, y: y + offsetY }));
-const pointOnSegment = ({ x: px, y: py }, { x: x1, y: y1 }, { x: x2, y: y2 }) => px <= Math.max(x1, x2) + epsilon && px >= Math.min(x1, x2) - epsilon && py <= Math.max(y1, y2) + epsilon && py >= Math.min(y1, y2) - epsilon;
+const pointOnSegment = ({ x: px, y: py }, { x: x1, y: y1 }, { x: x2, y: y2 }) => px <= Math.max(x1, x2) + epsilon$1 && px >= Math.min(x1, x2) - epsilon$1 && py <= Math.max(y1, y2) + epsilon$1 && py >= Math.min(y1, y2) - epsilon$1;
 const orientation = ({ x: x1, y: y1 }, { x: x2, y: y2 }, { x: x3, y: y3 }) => {
     const determinant = (y2 - y1) * (x3 - x2) - (x2 - x1) * (y3 - y2);
-    if (Math.abs(determinant) <= epsilon) {
+    if (Math.abs(determinant) <= epsilon$1) {
         return 0;
     }
     return determinant > 0 ? 1 : 2;
@@ -2705,7 +2705,7 @@ const intersectionPointEllipse$1 = ({ x: x1, y: y1 }, { x: x2, y: y2, rx, ry })
 const intersectionPointPoly$1 = (point, { points }) => polygonContainsPoint(point, points);
 const intersectionLineLineSegments = (a1, a2, b1, b2) => {
     const denominator = (a2.x - a1.x) * (b2.y - b1.y) - (b2.x - b1.x) * (a2.y - a1.y);
-    if (Math.abs(denominator) <= epsilon) {
+    if (Math.abs(denominator) <= epsilon$1) {
         return false;
     }
     const uA = ((b2.x - b1.x) * (a1.y - b1.y) - (b2.y - b1.y) * (a1.x - b1.x)) / denominator;
@@ -7975,8 +7975,9 @@ const emptySnapshot = Object.freeze({
     assets: Object.freeze([]),
 });
 /**
- * Flatten an ordered extension list into a snapshot.
- * De-duplicates same-id/same-object entries; throws on same-id/different-object.
+ * Flatten an ordered extension list into a snapshot using stable depth-first
+ * post-order traversal. Dependencies are materialised before their dependents.
+ * De-duplicates same-object entries; throws on same-id/different-object or cycles.
  * Binding-level conflicts are checked per Application at materialisation time.
  * @internal
  */
@@ -7984,19 +7985,47 @@ function buildSnapshot(input) {
     if (input.length === 0) {
         return emptySnapshot;
     }
-    const seenById = new Map();
-    const extensions = [];
+    const byId = new Map();
+    const visiting = new Set();
+    const visited = new Set();
+    const stack = [];
+    const ordered = [];
+    function visit(ext) {
+        // (1) Reserve ID + mismatch check FIRST — before dependency traversal.
+        //     This catches nested same-id/different-object descriptors immediately.
+        const existing = byId.get(ext.id);
+        if (existing !== undefined && existing !== ext) {
+            throw new Error(`Extension "${ext.id}" was provided by multiple descriptor objects.`);
+        }
+        if (existing === undefined) {
+            byId.set(ext.id, ext);
+        }
+        // (2) Already fully processed — diamond / shared dependency.
+        if (visited.has(ext))
+            return;
+        // (3) Back-edge in current DFS stack — cycle.
+        if (visiting.has(ext)) {
+            const cyclePath = [...stack.slice(stack.indexOf(ext)), ext].map(e => e.id).join(' → ');
+            throw new Error(`Extension dependency cycle detected: ${cyclePath}`);
+        }
+        // (4) Recurse into dependencies (post-order: deps before this extension).
+        visiting.add(ext);
+        stack.push(ext);
+        for (const dep of ext.dependencies ?? []) {
+            visit(dep);
+        }
+        stack.pop();
+        visiting.delete(ext);
+        // (5) Finalise — remove from in-progress, mark as fully processed, push to output.
+        visited.add(ext);
+        ordered.push(ext);
+    }
+    for (const ext of input)
+        visit(ext);
+    // Flatten in topological (post-order) order — deps before dependents.
     const renderers = [];
     const assets = [];
-    for (const ext of input) {
-        const existing = seenById.get(ext.id);
-        if (existing !== undefined) {
-            if (existing === ext)
-                continue;
-            throw new Error(`Duplicate extension id "${ext.id}" with a different descriptor in the provided extensions list.`);
-        }
-        seenById.set(ext.id, ext);
-        extensions.push(ext);
+    for (const ext of ordered) {
         if (ext.renderers) {
             for (const binding of ext.renderers) {
                 renderers.push(binding);
@@ -8009,7 +8038,7 @@ function buildSnapshot(input) {
         }
     }
     return Object.freeze({
-        extensions: Object.freeze(extensions),
+        extensions: Object.freeze(ordered),
         renderers: Object.freeze(renderers),
         assets: Object.freeze(assets),
     });
@@ -13819,13 +13848,33 @@ class RenderPlanPlayer {
         let groupCursor = 0;
         let currentGroup = null;
         let currentInstructionIndex = 0;
+        // Phase 1 — populate the CPU transform buffer for all groups in this scope
+        // before any renderer draws execute. Without this separation, each
+        // per-group upload changes the buffer hash while a renderer holds an
+        // in-flight batch; the next flush detects the changed hash and re-uploads
+        // the growing buffer, producing O(groups²) GPU transform writes per pass
+        // (measured: ~240 KB/frame for 100 NineSlice sprites across 8 textures,
+        // ~600 MB/frame for 5000 RepeatingSprites). Writing every group's
+        // transforms first ensures the hash is stable by the time the first flush
+        // calls bindTransformBufferTexture/getTransformStorageBuffer, so all
+        // subsequent flushes within the same scope find an unchanged hash and skip
+        // the upload entirely.
+        if (hooks._prepareRenderGroupUpload !== undefined) {
+            let preInstructionIndex = context.passInstructionIndex;
+            for (let gi = 0; gi < groups.length; gi++) {
+                const group = groups[gi];
+                hooks._prepareRenderGroupUpload(group, this._createRenderGroupPlaybackContext(group.instructions.length, preInstructionIndex, context.passGroupIndex + gi));
+                preInstructionIndex += group.instructions.length;
+            }
+        }
+        // Phase 2 — execute draws in document order. Transform writes are already
+        // done; _prepareRenderGroupUpload is intentionally not called a second time.
         for (const entry of scope.entries) {
             if (entry.kind === RenderEntryKind.Draw) {
                 if (currentGroup === null) {
                     currentGroup = groups[groupCursor];
                     currentInstructionIndex = 0;
                     hooks._beginRenderGroup?.(currentGroup);
-                    hooks._prepareRenderGroupUpload?.(currentGroup, this._createRenderGroupPlaybackContext(currentGroup.instructions.length, context.passInstructionIndex, context.passGroupIndex));
                     context.passGroupIndex++;
                 }
                 // Allocate the per-draw instruction slot only when a backend consumes
@@ -15091,6 +15140,190 @@ class InteractionManager {
     }
 }
 
+const pixelSnapModes = new Set(['none', 'position', 'geometry']);
+/**
+ * Runtime guard for the {@link PixelSnapMode} union. Used by the public setter to
+ * reject JavaScript-invalid values atomically.
+ * @internal
+ */
+function isPixelSnapMode(value) {
+    return typeof value === 'string' && pixelSnapModes.has(value);
+}
+/** Below this magnitude an axis is treated as collapsed / cross-coupled. @internal */
+const epsilon = 1e-6;
+/**
+ * Build the device-pixel snap context for `world` (a node's global transform)
+ * under `view`, targeting a surface of `targetPxWidth` × `targetPxHeight` device
+ * pixels. Pure — does not mutate `world` or `view`. Falls back to a no-op context
+ * (snapped origin = original origin) when the target size or projection is
+ * degenerate, so callers can always use the result safely.
+ * @internal
+ */
+function buildPixelSnapContext(world, view, targetPxWidth, targetPxHeight) {
+    const ox = world.x;
+    const oy = world.y;
+    if (!(targetPxWidth > 0) || !(targetPxHeight > 0)) {
+        return noopContext(ox, oy);
+    }
+    // Forward projection only (world → device). The view's inverse is deliberately
+    // avoided; instead the origin plus two world-unit axis tips give the exact
+    // world→device Jacobian, which we invert ourselves (a 2×2) to map the snapped
+    // device origin back to world space. This stays exact for any affine view.
+    const origin = view.worldToScreen(ox, oy, targetPxWidth, targetPxHeight);
+    if (!Number.isFinite(origin.x) || !Number.isFinite(origin.y)) {
+        return noopContext(ox, oy);
+    }
+    const tipWorldX = view.worldToScreen(ox + 1, oy, targetPxWidth, targetPxHeight);
+    const tipWorldY = view.worldToScreen(ox, oy + 1, targetPxWidth, targetPxHeight);
+    // Columns of the world→device Jacobian J = [[jxx, jyx], [jxy, jyy]].
+    const jxx = tipWorldX.x - origin.x;
+    const jxy = tipWorldX.y - origin.y;
+    const jyx = tipWorldY.x - origin.x;
+    const jyy = tipWorldY.y - origin.y;
+    // Local axes in device pixels: apply the node's linear part to the Jacobian —
+    // local (1,0)→world (a,c), local (0,1)→world (b,d).
+    const scaleX = world.a * jxx + world.c * jyx; // device-x per local-x unit
+    const crossXy = world.a * jxy + world.c * jyy; // device-y per local-x unit
+    const crossYx = world.b * jxx + world.d * jyx; // device-x per local-y unit
+    const scaleY = world.b * jxy + world.d * jyy; // device-y per local-y unit
+    const axisAligned = Math.abs(crossXy) < epsilon && Math.abs(crossYx) < epsilon;
+    const snappedOriginX = Math.round(origin.x);
+    const snappedOriginY = Math.round(origin.y);
+    // Map the snapped device origin back to world via J⁻¹ so that, re-projected
+    // through the (unchanged) view, the rendered origin lands on the device pixel.
+    let worldX = ox;
+    let worldY = oy;
+    const det = jxx * jyy - jyx * jxy;
+    if (Math.abs(det) > epsilon) {
+        const ddx = snappedOriginX - origin.x;
+        const ddy = snappedOriginY - origin.y;
+        worldX = ox + (jyy * ddx - jyx * ddy) / det;
+        worldY = oy + (jxx * ddy - jxy * ddx) / det;
+    }
+    return {
+        originX: origin.x,
+        originY: origin.y,
+        snappedOriginX,
+        snappedOriginY,
+        worldX,
+        worldY,
+        scaleX,
+        scaleY,
+        axisAligned,
+    };
+}
+function noopContext(ox, oy) {
+    return {
+        originX: ox,
+        originY: oy,
+        snappedOriginX: ox,
+        snappedOriginY: oy,
+        worldX: ox,
+        worldY: oy,
+        scaleX: 0,
+        scaleY: 0,
+        axisAligned: false,
+    };
+}
+/**
+ * Copy `world` into `out`, replacing only the translation with the snapped world
+ * origin from `ctx`. The linear part `(a, b, c, d)` and homogeneous row are
+ * preserved, so rotation / scale / skew are untouched — position snapping is safe
+ * under any transform. The source `world` matrix is never mutated.
+ * @internal
+ */
+function snapWorldTranslationInto(out, world, ctx) {
+    out.copy(world);
+    out.x = ctx.worldX;
+    out.y = ctx.worldY;
+    return out;
+}
+/**
+ * Snap a single local boundary coordinate to the device-pixel grid along an axis
+ * whose local→device scale is `scale`. Returns the local value whose device
+ * position (relative to the already-snapped origin) lands on an integer device
+ * pixel: `round(L · scale) / scale`.
+ *
+ * The function is pure, so two boundaries with the same input value snap to the
+ * same output — shared boundaries stay shared and seams cannot open. It is also
+ * monotonic non-decreasing in `L` for any non-zero `scale` (including negative
+ * scale from a flip), so boundary order is preserved and snapped spans never go
+ * negative. Degenerate scales (`|scale| < epsilon`) and non-finite inputs return
+ * the value unchanged.
+ * @internal
+ */
+function snapLocalBoundary(localValue, scale) {
+    if (!Number.isFinite(localValue) || Math.abs(scale) < epsilon) {
+        return localValue;
+    }
+    return Math.round(localValue * scale) / scale;
+}
+/**
+ * Snap every quad's local X/Y boundaries to the device grid using the per-axis
+ * scale in `ctx`, writing the result into the reusable `out` buffer (grown /
+ * truncated to match `source`, never reallocated per frame once warm). UVs are
+ * copied verbatim — sampling is unchanged. Because {@link snapLocalBoundary} is
+ * pure, quads sharing a boundary value stay seam-free without any explicit
+ * de-duplication.
+ * @internal
+ */
+function snapQuadsInto(source, ctx, out) {
+    const { scaleX, scaleY } = ctx;
+    out.length = source.length;
+    for (let i = 0; i < source.length; i++) {
+        const q = source[i];
+        let t = out[i];
+        if (t === undefined) {
+            t = out[i] = { x0: 0, y0: 0, x1: 0, y1: 0, u0: 0, v0: 0, u1: 0, v1: 0 };
+        }
+        t.x0 = snapLocalBoundary(q.x0, scaleX);
+        t.x1 = snapLocalBoundary(q.x1, scaleX);
+        t.y0 = snapLocalBoundary(q.y0, scaleY);
+        t.y1 = snapLocalBoundary(q.y1, scaleY);
+        t.u0 = q.u0;
+        t.v0 = q.v0;
+        t.u1 = q.u1;
+        t.v1 = q.v1;
+    }
+    return out;
+}
+/**
+ * Resolve the world transform to upload for `drawable` at the transform-buffer
+ * write seam. Returns the drawable's live global transform unchanged when its
+ * mode is `'none'` (zero overhead), otherwise a snapped copy written into the
+ * caller-owned `scratch` matrix — the logical global transform is never mutated.
+ *
+ * Both backends call this at their single transform-write boundary, so position
+ * snapping (and tilemap chunk/layer origin snapping) is applied once, backend-
+ * neutrally, to every drawable. `view` and the target device-pixel dimensions
+ * come from the active pass.
+ * @internal
+ */
+function resolveUploadTransform(drawable, view, targetPxWidth, targetPxHeight, scratch) {
+    const world = drawable.getGlobalTransform();
+    if (drawable.pixelSnapMode === 'none') {
+        return world;
+    }
+    const ctx = buildPixelSnapContext(world, view, targetPxWidth, targetPxHeight);
+    return snapWorldTranslationInto(scratch, world, ctx);
+}
+/**
+ * Snap a single local-space bounds rectangle (e.g. a sprite quad) to the device
+ * grid using the per-axis scale in `ctx`, writing the result into `out`. Each of
+ * the four edges is snapped by {@link snapLocalBoundary}, so combined with the
+ * device-snapped origin every corner lands on a whole device pixel. `out` may be
+ * the same instance across frames (no allocation). UV/texture mapping is the
+ * caller's concern and is unaffected.
+ * @internal
+ */
+function snapBoundsInto(base, ctx, out) {
+    const left = snapLocalBoundary(base.left, ctx.scaleX);
+    const top = snapLocalBoundary(base.top, ctx.scaleY);
+    const right = snapLocalBoundary(base.right, ctx.scaleX);
+    const bottom = snapLocalBoundary(base.bottom, ctx.scaleY);
+    return out.set(left, top, right - left, bottom - top);
+}
+
 /**
  * Base class for every renderable scene object.
  *
@@ -15101,6 +15334,7 @@ class InteractionManager {
 class Drawable extends RenderNode {
     _tint = Color.white.clone();
     _blendMode = BlendModes.Normal;
+    _pixelSnapMode = 'none';
     get tint() {
         return this._tint;
     }
@@ -15113,6 +15347,38 @@ class Drawable extends RenderNode {
     set blendMode(blendMode) {
         this.setBlendMode(blendMode);
     }
+    /**
+     * Render-only pixel-snapping policy for this drawable. Aligns the rendered
+     * origin (`'position'`) or origin plus shared geometry boundaries
+     * (`'geometry'`) to the active render target's device-pixel grid. Purely
+     * visual: logical `x`/`y`, transforms, bounds, collision, tween and physics
+     * state are never affected, and {@link getBounds}/{@link getGlobalTransform}
+     * keep returning logical values.
+     *
+     * `'geometry'` is guaranteed only for axis-aligned transforms; rotation or
+     * skew (on this node, an ancestor, or the view) downgrade it to `'position'`
+     * for the affected frame, with no logical-state change. Snapping targets
+     * device pixels (× view scale × pixel ratio), not integer world units.
+     *
+     * Setting the current value is a no-op. Setting a value outside the
+     * {@link PixelSnapMode} union throws and leaves the prior mode unchanged.
+     *
+     * @default 'none'
+     * @stable
+     */
+    get pixelSnapMode() {
+        return this._pixelSnapMode;
+    }
+    set pixelSnapMode(mode) {
+        if (mode === this._pixelSnapMode) {
+            return;
+        }
+        if (!isPixelSnapMode(mode)) {
+            throw new Error(`Drawable.pixelSnapMode must be 'none', 'position', or 'geometry' (got ${String(mode)}).`);
+        }
+        this._pixelSnapMode = mode;
+        this.invalidateCache();
+    }
     /**
      * Set the tint colour by copying `color` into the internal {@link Color} instance.
      * Invalidates the render cache so the change is picked up on the next frame.
@@ -15387,6 +15653,1264 @@ function clamp01(value) {
     return value;
 }
 
+function isFinite(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function normalizeExtrusion(extrusion) {
+    if (extrusion === undefined) {
+        return Object.freeze({
+            left: 0,
+            top: 0,
+            right: 0,
+            bottom: 0,
+        });
+    }
+    if (typeof extrusion === 'number') {
+        return Object.freeze({
+            left: extrusion,
+            top: extrusion,
+            right: extrusion,
+            bottom: extrusion,
+        });
+    }
+    // Copy caller-owned values into an engine-owned frozen object so that
+    // external mutation of the original never affects the region.
+    return Object.freeze({
+        left: extrusion.left,
+        top: extrusion.top,
+        right: extrusion.right,
+        bottom: extrusion.bottom,
+    });
+}
+function validateExtrusion(extrusion, x, y, width, height, textureWidth, textureHeight) {
+    const { left, top, right, bottom } = extrusion;
+    if (!isFinite(left) || !isFinite(top) || !isFinite(right) || !isFinite(bottom)) {
+        throw new Error(`TextureRegion extrusion values must be finite numbers (got left=${left}, top=${top}, right=${right}, bottom=${bottom}).`);
+    }
+    if (left < 0 || top < 0 || right < 0 || bottom < 0) {
+        throw new Error(`TextureRegion extrusion values must be non-negative (got left=${left}, top=${top}, right=${right}, bottom=${bottom}).`);
+    }
+    if (left > x || top > y || right > textureWidth - (x + width) || bottom > textureHeight - (y + height)) {
+        throw new Error(`TextureRegion extrusion exceeds available source texture bounds: left=${left} (>${x}), top=${top} (>${y}), ` +
+            `right=${right} (>${textureWidth - (x + width)}), bottom=${bottom} (>${textureHeight - (y + height)}).`);
+    }
+}
+function validateOptions(options, textureWidth, textureHeight) {
+    const { x, y, width, height } = options;
+    if (!isFinite(x) || !isFinite(y) || !isFinite(width) || !isFinite(height)) {
+        throw new Error(`TextureRegion coordinates and dimensions must be finite numbers (got x=${x}, y=${y}, width=${width}, height=${height}).`);
+    }
+    if (width <= 0 || height <= 0) {
+        throw new Error(`TextureRegion dimensions must be positive (got width=${width}, height=${height}).`);
+    }
+    if (textureWidth <= 0 || textureHeight <= 0) {
+        throw new Error(`Texture must have positive dimensions (got ${textureWidth}x${textureHeight}).`);
+    }
+    if (x < 0 || y < 0) {
+        throw new Error(`TextureRegion origin must be non-negative (got x=${x}, y=${y}).`);
+    }
+    if (x >= textureWidth || y >= textureHeight) {
+        throw new Error(`TextureRegion origin (${x}, ${y}) is outside texture bounds (${textureWidth}x${textureHeight}).`);
+    }
+    if (x + width > textureWidth) {
+        throw new Error(`TextureRegion right edge (${x + width}) exceeds texture width (${textureWidth}).`);
+    }
+    if (y + height > textureHeight) {
+        throw new Error(`TextureRegion bottom edge (${y + height}) exceeds texture height (${textureHeight}).`);
+    }
+}
+/**
+ * An immutable descriptor for a rectangular sub-region of a {@link Texture}.
+ *
+ * Stores the pixel-space source rectangle, pre-computed normalised UV bounds,
+ * and optional extrusion/padding metadata for atlas-safe linear filtering.
+ * Constructed once and reused across sprites, tile-sets, atlas lookups, and
+ * the scalable-sprite repeat planners.
+ *
+ * All region descriptor fields are stable after construction. Extrusion
+ * metadata is copied and frozen during construction — the caller retains no
+ * mutable reference to the stored object. The underlying {@link Texture}
+ * reference is stable, but the Texture's own lifecycle and sampler state
+ * remain owned by {@link Texture}.
+ *
+ * Texture dimensions **must** be known at construction time; a texture with
+ * zero dimensions will cause the constructor to throw.
+ *
+ * @example
+ * ```ts
+ * const region = new TextureRegion(texture, {
+ *   x: 32,  y: 16,
+ *   width: 64, height: 32,
+ * });
+ * ```
+ * @stable
+ */
+class TextureRegion {
+    /** The underlying {@link Texture} this region belongs to. */
+    texture;
+    /** Left edge of the region in texture pixels. */
+    x;
+    /** Top edge of the region in texture pixels. */
+    y;
+    /** Width of the region in texture pixels. */
+    width;
+    /** Height of the region in texture pixels. */
+    height;
+    /** Normalised left texture coordinate (U-min). */
+    u0;
+    /** Normalised top texture coordinate (V-min). */
+    v0;
+    /** Normalised right texture coordinate (U-max). */
+    u1;
+    /** Normalised bottom texture coordinate (V-max). */
+    v1;
+    /** Per-edge extrusion/padding metadata (engine-owned, frozen). */
+    extrusion;
+    /**
+     * Create a new immutable region.
+     *
+     * @throws When coordinates or dimensions are non-finite, zero, negative, or
+     *         extend beyond the texture bounds, or when extrusion values are
+     *         invalid.
+     */
+    constructor(texture, options) {
+        if (!texture) {
+            throw new Error('TextureRegion requires a non-null Texture.');
+        }
+        const textureWidth = texture.width;
+        const textureHeight = texture.height;
+        validateOptions(options, textureWidth, textureHeight);
+        const extrusion = normalizeExtrusion(options.extrusion);
+        validateExtrusion(extrusion, options.x, options.y, options.width, options.height, textureWidth, textureHeight);
+        this.texture = texture;
+        this.x = options.x;
+        this.y = options.y;
+        this.width = options.width;
+        this.height = options.height;
+        this.u0 = options.x / textureWidth;
+        this.v0 = options.y / textureHeight;
+        this.u1 = (options.x + options.width) / textureWidth;
+        this.v1 = (options.y + options.height) / textureHeight;
+        this.extrusion = extrusion;
+    }
+}
+
+/**
+ * Validate generic numeric inputs shared across all modes.
+ * Throws unconditionally — these are user/programming errors, not dev-only
+ * assertions.
+ */
+function validateInputs(sourceLength, destinationLength) {
+    if (!Number.isFinite(sourceLength) || !Number.isFinite(destinationLength)) {
+        throw new Error(`RepeatPlanner: sourceLength and destinationLength must be finite numbers (got ${sourceLength}, ${destinationLength}).`);
+    }
+    if (sourceLength <= 0) {
+        throw new Error(`RepeatPlanner: sourceLength must be positive (got ${sourceLength}).`);
+    }
+    if (destinationLength < 0) {
+        throw new Error(`RepeatPlanner: destinationLength must be non-negative (got ${destinationLength}).`);
+    }
+}
+function buildStretchPlan(destinationLength, sourceLength) {
+    if (destinationLength === 0) {
+        return {
+            destinationLength: 0,
+            sourceLength,
+            segments: [],
+        };
+    }
+    const segment = {
+        destinationStart: 0,
+        destinationLength,
+        sourceStart: 0,
+        sourceEnd: 1,
+        mirrored: false,
+    };
+    return {
+        destinationLength,
+        sourceLength,
+        segments: [segment],
+    };
+}
+function buildClipPlan(destinationLength, sourceLength, mirror) {
+    if (destinationLength === 0) {
+        return {
+            destinationLength: 0,
+            sourceLength,
+            segments: [],
+        };
+    }
+    const segments = [];
+    let cursor = 0;
+    let index = 0;
+    while (cursor < destinationLength) {
+        const remaining = destinationLength - cursor;
+        const segLength = Math.min(sourceLength, remaining);
+        const sourceFraction = segLength / sourceLength;
+        const mirrored = mirror && (index % 2 === 1);
+        const segment = {
+            destinationStart: cursor,
+            destinationLength: segLength,
+            sourceStart: mirrored ? 1 : 0,
+            sourceEnd: mirrored ? 1 - sourceFraction : sourceFraction,
+            mirrored,
+        };
+        segments.push(segment);
+        cursor += segLength;
+        index++;
+    }
+    return {
+        destinationLength,
+        sourceLength,
+        segments,
+    };
+}
+function buildRoundPlan(destinationLength, sourceLength, mirror) {
+    if (destinationLength === 0) {
+        return {
+            destinationLength: 0,
+            sourceLength,
+            segments: [],
+        };
+    }
+    const ratio = destinationLength / sourceLength;
+    const count = Math.max(1, Math.round(ratio));
+    const segLength = destinationLength / count;
+    const segments = [];
+    for (let i = 0; i < count; i++) {
+        const mirrored = mirror && (i % 2 === 1);
+        const segment = {
+            destinationStart: i * segLength,
+            destinationLength: segLength,
+            sourceStart: mirrored ? 1 : 0,
+            sourceEnd: mirrored ? 0 : 1,
+            mirrored,
+        };
+        segments.push(segment);
+    }
+    return {
+        destinationLength,
+        sourceLength,
+        segments,
+    };
+}
+/**
+ * Compute a deterministic repeat plan for filling a destination span with a
+ * tiled or stretched source pattern.
+ *
+ * This is a **pure, renderer-independent** function used as the shared repeat
+ * layout engine by {@link NineSliceSprite} edges/center,
+ * {@link RepeatingSprite} geometry path, and tilemap chunk builders.
+ *
+ * ## Modes
+ *
+ * | Mode             | Behaviour |
+ * |------------------|-----------|
+ * | `'stretch'`      | One segment stretched to the full destination. `fit` is ignored. |
+ * | `'repeat'`       | Native-size repeats; final segment is clipped when the destination is not an exact multiple. |
+ * | `'mirror-repeat'`| Alternating normal/mirrored segments (period-2). Clipped final segment when non-exact. |
+ *
+ * ## Fit
+ *
+ * | Fit      | Effect |
+ * |----------|--------|
+ * | `'clip'` | Native-size segments; the final segment is clipped if necessary. |
+ * | `'round'`| Integer count of equally-sized segments stretched or squeezed so the destination fills exactly. |
+ *
+ * ## Allocation and caching
+ *
+ * The planner returns a new result object on every call. Callers should
+ * cache the plan and recompute only when `sourceLength`, `destinationLength`,
+ * `mode`, or `fit` changes — typically on resize or texture change.
+ *
+ * @param sourceLength - Native size of the source pattern in destination units.
+ * @param destinationLength - Total span to fill.
+ * @param mode - Fill strategy.
+ * @param fit - Fitting strategy for `'repeat'` / `'mirror-repeat'`. Ignored for `'stretch'`.
+ * @throws When inputs are non-finite, negative, or zero-length source.
+ * @advanced
+ */
+function planRepeat(sourceLength, destinationLength, mode, fit = 'round') {
+    validateInputs(sourceLength, destinationLength);
+    switch (mode) {
+        case 'stretch':
+            return buildStretchPlan(destinationLength, sourceLength);
+        case 'repeat':
+            if (fit === 'round') {
+                return buildRoundPlan(destinationLength, sourceLength, false);
+            }
+            return buildClipPlan(destinationLength, sourceLength, false);
+        case 'mirror-repeat':
+            if (fit === 'round') {
+                return buildRoundPlan(destinationLength, sourceLength, true);
+            }
+            return buildClipPlan(destinationLength, sourceLength, true);
+        default: {
+            throw new Error(`RepeatPlanner: unknown RepeatMode.`);
+        }
+    }
+}
+
+const halfTexelInset$1 = 0.5;
+// ---------------------------------------------------------------------------
+// Validation helpers (module-private)
+// ---------------------------------------------------------------------------
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function validateSlices(slices, regionWidth, regionHeight) {
+    const { left, top, right, bottom } = slices;
+    if (!isFiniteNumber(left) || !isFiniteNumber(top) ||
+        !isFiniteNumber(right) || !isFiniteNumber(bottom)) {
+        throw new Error(`NineSliceSprite: slice values must be finite numbers (got left=${left}, top=${top}, right=${right}, bottom=${bottom}).`);
+    }
+    if (left < 0 || top < 0 || right < 0 || bottom < 0) {
+        throw new Error(`NineSliceSprite: slice values must be non-negative (got left=${left}, top=${top}, right=${right}, bottom=${bottom}).`);
+    }
+    if (left + right > regionWidth) {
+        throw new Error(`NineSliceSprite: slices.left (${left}) + slices.right (${right}) exceeds region width (${regionWidth}).`);
+    }
+    if (top + bottom > regionHeight) {
+        throw new Error(`NineSliceSprite: slices.top (${top}) + slices.bottom (${bottom}) exceeds region height (${regionHeight}).`);
+    }
+}
+function validateBorder(border) {
+    const { left, top, right, bottom } = border;
+    if (!isFiniteNumber(left) || !isFiniteNumber(top) ||
+        !isFiniteNumber(right) || !isFiniteNumber(bottom)) {
+        throw new Error(`NineSliceSprite: border values must be finite numbers (got left=${left}, top=${top}, right=${right}, bottom=${bottom}).`);
+    }
+    if (left < 0 || top < 0 || right < 0 || bottom < 0) {
+        throw new Error(`NineSliceSprite: border values must be non-negative (got left=${left}, top=${top}, right=${right}, bottom=${bottom}).`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Normalization helpers (module-private)
+// ---------------------------------------------------------------------------
+/** Normalise a uniform number or partial insets object into a full {@link NineSliceInsets}. */
+function normalizeInsets(value, fallback) {
+    if (typeof value === 'number') {
+        return Object.freeze({ left: value, top: value, right: value, bottom: value });
+    }
+    return Object.freeze({
+        left: value.left ?? fallback?.left ?? 0,
+        top: value.top ?? fallback?.top ?? 0,
+        right: value.right ?? fallback?.right ?? 0,
+        bottom: value.bottom ?? fallback?.bottom ?? 0,
+    });
+}
+const validRepeatModes$1 = new Set(['stretch', 'repeat', 'mirror-repeat']);
+const validRepeatFits$1 = new Set(['clip', 'round']);
+function validateModeField(value, label) {
+    if (typeof value !== 'string' || !validRepeatModes$1.has(value)) {
+        throw new Error(`NineSliceSprite: ${label} must be "stretch", "repeat", or "mirror-repeat".`);
+    }
+}
+function validateFitField(value, label) {
+    if (typeof value !== 'string' || !validRepeatFits$1.has(value)) {
+        throw new Error(`NineSliceSprite: ${label} must be "clip" or "round".`);
+    }
+}
+function normalizeModes(modes) {
+    if (!modes) {
+        return _defaultModes;
+    }
+    const normalized = {};
+    if (modes.edges !== undefined) {
+        validateModeField(modes.edges, 'modes.edges');
+        normalized.edges = modes.edges;
+    }
+    if (modes.center !== undefined) {
+        validateModeField(modes.center, 'modes.center');
+        normalized.center = modes.center;
+    }
+    if (modes.top !== undefined) {
+        validateModeField(modes.top, 'modes.top');
+        normalized.top = modes.top;
+    }
+    if (modes.right !== undefined) {
+        validateModeField(modes.right, 'modes.right');
+        normalized.right = modes.right;
+    }
+    if (modes.bottom !== undefined) {
+        validateModeField(modes.bottom, 'modes.bottom');
+        normalized.bottom = modes.bottom;
+    }
+    if (modes.left !== undefined) {
+        validateModeField(modes.left, 'modes.left');
+        normalized.left = modes.left;
+    }
+    if (modes.edgeFit !== undefined) {
+        validateFitField(modes.edgeFit, 'modes.edgeFit');
+        normalized.edgeFit = modes.edgeFit;
+    }
+    if (modes.centerFit !== undefined) {
+        validateFitField(modes.centerFit, 'modes.centerFit');
+        normalized.centerFit = modes.centerFit;
+    }
+    return Object.freeze(normalized);
+}
+const _defaultModes = Object.freeze({});
+function equalInsets(a, b) {
+    return a.left === b.left && a.top === b.top && a.right === b.right && a.bottom === b.bottom;
+}
+function equalModes(a, b) {
+    return a.edges === b.edges
+        && a.center === b.center
+        && a.top === b.top
+        && a.right === b.right
+        && a.bottom === b.bottom
+        && a.left === b.left
+        && a.edgeFit === b.edgeFit
+        && a.centerFit === b.centerFit;
+}
+// ---------------------------------------------------------------------------
+// Mode resolution helpers (module-private)
+// ---------------------------------------------------------------------------
+function resolveEdgeMode(modes, side) {
+    return modes?.[side] ?? modes?.edges ?? 'stretch';
+}
+function resolveCenterMode(modes) {
+    return modes?.center ?? 'stretch';
+}
+function resolveEdgeFit(modes) {
+    return modes?.edgeFit ?? 'round';
+}
+function resolveCenterFit(modes) {
+    return modes?.centerFit ?? 'round';
+}
+/**
+ * Compute exact per-slice UV boundaries from source pixel positions.
+ *
+ * Source-slice boundaries correspond to actual pixel coordinates:
+ *   left bound  = region.x + slices.left
+ *   right bound = region.x + region.width - slices.right
+ *   top bound   = region.y + slices.top
+ *   bottom bound = region.y + region.height - slices.bottom
+ *
+ * A half-texel inset is applied at internal boundaries to prevent bilinear
+ * filtering from sampling across slice seams. Outer boundaries use the full
+ * region UV range when extrusion is present, or a half-texel inset otherwise.
+ */
+function computeSliceUvGrid(region, slices) {
+    const tw = region.texture.width;
+    const th = region.texture.height;
+    const rx = region.x;
+    const ry = region.y;
+    const rw = region.width;
+    const rh = region.height;
+    const ext = region.extrusion;
+    // Outer boundary insets: use extrusion if available, otherwise half-texel.
+    const outerInsetU = ext.left > 0 || ext.right > 0
+        ? 0
+        : halfTexelInset$1 / tw;
+    const outerInsetV = ext.top > 0 || ext.bottom > 0
+        ? 0
+        : halfTexelInset$1 / th;
+    // Inner slice boundary insets: always apply half-texel to prevent
+    // bilinear bleed across internal slice seams.
+    const innerInsetU = halfTexelInset$1 / tw;
+    const innerInsetV = halfTexelInset$1 / th;
+    // Exact source pixel boundaries in UV space
+    const uLeftBound = (rx + slices.left) / tw;
+    const uRightBound = (rx + rw - slices.right) / tw;
+    const vTopBound = (ry + slices.top) / th;
+    const vBottomBound = (ry + rh - slices.bottom) / th;
+    // Outer UV bounds (possibly inset)
+    const uOuter0 = region.u0 + outerInsetU;
+    const uOuter1 = region.u1 - outerInsetU;
+    const vOuter0 = region.v0 + outerInsetV;
+    const vOuter1 = region.v1 - outerInsetV;
+    // Clamp internal boundaries to prevent UV inversion on narrow cells
+    const u1 = clampUv(uLeftBound - innerInsetU, uOuter0, uOuter1);
+    const u2 = clampUv(uRightBound + innerInsetU, uOuter0, uOuter1);
+    const v1 = clampUv(vTopBound - innerInsetV, vOuter0, vOuter1);
+    const v2 = clampUv(vBottomBound + innerInsetV, vOuter0, vOuter1);
+    return {
+        col0: { u0: uOuter0, u1 },
+        col1: { u0: u1, u1: u2 },
+        col2: { u0: u2, u1: uOuter1 },
+        row0: { u0: vOuter0, u1: v1 },
+        row1: { u0: v1, u1: v2 },
+        row2: { u0: v2, u1: vOuter1 },
+    };
+}
+function clampUv(value, min, max) {
+    if (!isFiniteNumber(value) || value < min)
+        return min;
+    if (value > max)
+        return max;
+    return value;
+}
+function compressBorders(border, width, height) {
+    let bl = border.left;
+    let br = border.right;
+    let bt = border.top;
+    let bb = border.bottom;
+    if (bl + br > width && bl + br > 0) {
+        const k = width / (bl + br);
+        bl *= k;
+        br *= k;
+    }
+    if (bt + bb > height && bt + bb > 0) {
+        const k = height / (bt + bb);
+        bt *= k;
+        bb *= k;
+    }
+    return { bl, br, bt, bb };
+}
+// ---------------------------------------------------------------------------
+// Geometry builder
+// ---------------------------------------------------------------------------
+/**
+ * Build the list of quads that collectively render a nine-slice sprite at the
+ * requested destination size. Called lazily by {@link NineSliceSprite}.
+ * @internal
+ */
+function buildNineSliceQuads(region, slices, border, width, height, modes) {
+    const uvGrid = computeSliceUvGrid(region, slices);
+    const compressed = compressBorders(border, width, height);
+    const bl = compressed.bl;
+    const br = compressed.br;
+    const bt = compressed.bt;
+    const bb = compressed.bb;
+    const centerW = Math.max(0, width - bl - br);
+    const centerH = Math.max(0, height - bt - bb);
+    const dx0 = 0;
+    const dx1 = bl;
+    const dx2 = bl + centerW;
+    const dx3 = width;
+    const dy0 = 0;
+    const dy1 = bt;
+    const dy2 = bt + centerH;
+    const dy3 = height;
+    const srcEdgeW = Math.max(0, region.width - slices.left - slices.right);
+    const srcEdgeH = Math.max(0, region.height - slices.top - slices.bottom);
+    const topScale = slices.top > 0 ? bt / slices.top : 1;
+    const bottomScale = slices.bottom > 0 ? bb / slices.bottom : 1;
+    const leftScale = slices.left > 0 ? bl / slices.left : 1;
+    const rightScale = slices.right > 0 ? br / slices.right : 1;
+    const topNativeW = srcEdgeW * topScale;
+    const bottomNativeW = srcEdgeW * bottomScale;
+    const leftNativeH = srcEdgeH * leftScale;
+    const rightNativeH = srcEdgeH * rightScale;
+    const centerNativeW = topNativeW;
+    const centerNativeH = leftNativeH;
+    const topMode = resolveEdgeMode(modes, 'top');
+    const bottomMode = resolveEdgeMode(modes, 'bottom');
+    const leftMode = resolveEdgeMode(modes, 'left');
+    const rightMode = resolveEdgeMode(modes, 'right');
+    const centerMode = resolveCenterMode(modes);
+    const edgeFit = resolveEdgeFit(modes);
+    const centerFit = resolveCenterFit(modes);
+    const quads = [];
+    const { col0, col1, col2, row0, row1, row2 } = uvGrid;
+    // Corners
+    if (bl > 0 && bt > 0) {
+        quads.push({ x0: dx0, y0: dy0, x1: dx1, y1: dy1, u0: col0.u0, v0: row0.u0, u1: col0.u1, v1: row0.u1 });
+    }
+    if (br > 0 && bt > 0) {
+        quads.push({ x0: dx2, y0: dy0, x1: dx3, y1: dy1, u0: col2.u0, v0: row0.u0, u1: col2.u1, v1: row0.u1 });
+    }
+    if (bl > 0 && bb > 0) {
+        quads.push({ x0: dx0, y0: dy2, x1: dx1, y1: dy3, u0: col0.u0, v0: row2.u0, u1: col0.u1, v1: row2.u1 });
+    }
+    if (br > 0 && bb > 0) {
+        quads.push({ x0: dx2, y0: dy2, x1: dx3, y1: dy3, u0: col2.u0, v0: row2.u0, u1: col2.u1, v1: row2.u1 });
+    }
+    const col1U0 = col1.u0;
+    const col1U1 = col1.u1;
+    const row1U0 = row1.u0;
+    const row1U1 = row1.u1;
+    // Top edge
+    if (centerW > 0 && bt > 0 && srcEdgeW > 0 && topNativeW > 0) {
+        const plan = planRepeat(topNativeW, centerW, topMode, edgeFit);
+        for (const seg of plan.segments) {
+            const qx0 = dx1 + seg.destinationStart;
+            const qx1 = dx1 + seg.destinationStart + seg.destinationLength;
+            const qu0 = col1U0 + seg.sourceStart * (col1U1 - col1U0);
+            const qu1 = col1U0 + seg.sourceEnd * (col1U1 - col1U0);
+            quads.push({ x0: qx0, y0: dy0, x1: qx1, y1: dy1, u0: qu0, v0: row0.u0, u1: qu1, v1: row0.u1 });
+        }
+    }
+    // Bottom edge
+    if (centerW > 0 && bb > 0 && srcEdgeW > 0 && bottomNativeW > 0) {
+        const plan = planRepeat(bottomNativeW, centerW, bottomMode, edgeFit);
+        for (const seg of plan.segments) {
+            const qx0 = dx1 + seg.destinationStart;
+            const qx1 = dx1 + seg.destinationStart + seg.destinationLength;
+            const qu0 = col1U0 + seg.sourceStart * (col1U1 - col1U0);
+            const qu1 = col1U0 + seg.sourceEnd * (col1U1 - col1U0);
+            quads.push({ x0: qx0, y0: dy2, x1: qx1, y1: dy3, u0: qu0, v0: row2.u0, u1: qu1, v1: row2.u1 });
+        }
+    }
+    // Left edge
+    if (bl > 0 && centerH > 0 && srcEdgeH > 0 && leftNativeH > 0) {
+        const plan = planRepeat(leftNativeH, centerH, leftMode, edgeFit);
+        for (const seg of plan.segments) {
+            const qy0 = dy1 + seg.destinationStart;
+            const qy1 = dy1 + seg.destinationStart + seg.destinationLength;
+            const qv0 = row1U0 + seg.sourceStart * (row1U1 - row1U0);
+            const qv1 = row1U0 + seg.sourceEnd * (row1U1 - row1U0);
+            quads.push({ x0: dx0, y0: qy0, x1: dx1, y1: qy1, u0: col0.u0, v0: qv0, u1: col0.u1, v1: qv1 });
+        }
+    }
+    // Right edge
+    if (br > 0 && centerH > 0 && srcEdgeH > 0 && rightNativeH > 0) {
+        const plan = planRepeat(rightNativeH, centerH, rightMode, edgeFit);
+        for (const seg of plan.segments) {
+            const qy0 = dy1 + seg.destinationStart;
+            const qy1 = dy1 + seg.destinationStart + seg.destinationLength;
+            const qv0 = row1U0 + seg.sourceStart * (row1U1 - row1U0);
+            const qv1 = row1U0 + seg.sourceEnd * (row1U1 - row1U0);
+            quads.push({ x0: dx2, y0: qy0, x1: dx3, y1: qy1, u0: col2.u0, v0: qv0, u1: col2.u1, v1: qv1 });
+        }
+    }
+    // Center
+    if (centerW > 0 && centerH > 0 && srcEdgeW > 0 && srcEdgeH > 0 && centerNativeW > 0 && centerNativeH > 0) {
+        const planX = planRepeat(centerNativeW, centerW, centerMode, centerFit);
+        const planY = planRepeat(centerNativeH, centerH, centerMode, centerFit);
+        for (const segY of planY.segments) {
+            const qy0 = dy1 + segY.destinationStart;
+            const qy1 = dy1 + segY.destinationStart + segY.destinationLength;
+            const qv0 = row1U0 + segY.sourceStart * (row1U1 - row1U0);
+            const qv1 = row1U0 + segY.sourceEnd * (row1U1 - row1U0);
+            for (const segX of planX.segments) {
+                const qx0 = dx1 + segX.destinationStart;
+                const qx1 = dx1 + segX.destinationStart + segX.destinationLength;
+                const qu0 = col1U0 + segX.sourceStart * (col1U1 - col1U0);
+                const qu1 = col1U0 + segX.sourceEnd * (col1U1 - col1U0);
+                quads.push({ x0: qx0, y0: qy0, x1: qx1, y1: qy1, u0: qu0, v0: qv0, u1: qu1, v1: qv1 });
+            }
+        }
+    }
+    return quads;
+}
+
+function validateSizeInput$1(width, height) {
+    if (!Number.isFinite(width) || !Number.isFinite(height)) {
+        throw new Error(`NineSliceSprite: width and height must be finite numbers (got ${width}, ${height}).`);
+    }
+    if (width < 0) {
+        throw new Error(`NineSliceSprite: width must be non-negative (got ${width}).`);
+    }
+    if (height < 0) {
+        throw new Error(`NineSliceSprite: height must be non-negative (got ${height}).`);
+    }
+}
+/**
+ * A scalable nine-slice (9-patch) sprite.
+ * Corners stay pixel-perfect; edges/center fill by stretch, repeat, or mirror-repeat.
+ * @stable
+ */
+class NineSliceSprite extends Drawable {
+    _region;
+    _slices;
+    _border;
+    _width;
+    _height;
+    _modes;
+    _quads = [];
+    _geometryDirty = true;
+    _renderQuads = [];
+    constructor(texture, options) {
+        super();
+        this._region = texture instanceof TextureRegion
+            ? texture
+            : new TextureRegion(texture, {
+                x: 0,
+                y: 0,
+                width: texture.width,
+                height: texture.height,
+            });
+        const region = this._region;
+        // Validate and own slices
+        const rawSlices = normalizeInsets(options.slices);
+        validateSlices(rawSlices, region.width, region.height);
+        this._slices = rawSlices;
+        // Validate and own border
+        const rawBorder = options.border !== undefined
+            ? normalizeInsets(options.border)
+            : normalizeInsets(options.slices);
+        validateBorder(rawBorder);
+        this._border = rawBorder;
+        // Validate and own size
+        const width = options.width ?? region.width;
+        const height = options.height ?? region.height;
+        validateSizeInput$1(width, height);
+        this._width = width;
+        this._height = height;
+        // Copy and freeze modes
+        this._modes = normalizeModes(options.modes);
+    }
+    // -----------------------------------------------------------------------
+    // Public read-only accessors (engine-owned, frozen)
+    // -----------------------------------------------------------------------
+    /** The TextureRegion this nine-slice samples from. */
+    get region() {
+        return this._region;
+    }
+    /** Convenience accessor: the texture underlying the region. */
+    get texture() {
+        return this._region.texture;
+    }
+    /** The engine-owned, frozen source slice insets. */
+    get slices() {
+        return this._slices;
+    }
+    /** The engine-owned, frozen destination border insets. */
+    get border() {
+        return this._border;
+    }
+    /** The engine-owned, frozen edge/center fill modes. */
+    get modes() {
+        return this._modes;
+    }
+    // -----------------------------------------------------------------------
+    // Width / Height (with atomic validation)
+    // -----------------------------------------------------------------------
+    /** Destination width in local units. */
+    get width() {
+        return this._width;
+    }
+    set width(value) {
+        this.setSize(value, this._height);
+    }
+    /** Destination height in local units. */
+    get height() {
+        return this._height;
+    }
+    set height(value) {
+        this.setSize(this._width, value);
+    }
+    // -----------------------------------------------------------------------
+    // Mutators
+    // -----------------------------------------------------------------------
+    /** Set destination size. Fails atomically — prior state is preserved on invalid input. */
+    setSize(width, height) {
+        validateSizeInput$1(width, height);
+        if (this._width !== width || this._height !== height) {
+            this._width = width;
+            this._height = height;
+            this._geometryDirty = true;
+            this.invalidateCache();
+        }
+        return this;
+    }
+    /** Update the SOURCE-space slice insets. Fails atomically. No-ops on equivalent values. */
+    setSlices(slices) {
+        const region = this._region;
+        const normalized = normalizeInsets(slices);
+        validateSlices(normalized, region.width, region.height);
+        if (equalInsets(normalized, this._slices)) {
+            return this;
+        }
+        this._slices = normalized;
+        this._geometryDirty = true;
+        this.invalidateCache();
+        return this;
+    }
+    /** Update the DESTINATION border sizes. Fails atomically. No-ops on equivalent values. */
+    setBorder(border) {
+        const normalized = normalizeInsets(border);
+        validateBorder(normalized);
+        if (equalInsets(normalized, this._border)) {
+            return this;
+        }
+        this._border = normalized;
+        this._geometryDirty = true;
+        this.invalidateCache();
+        return this;
+    }
+    /** Update the edge/center fill modes. Input is copied, validated, and frozen. No-ops on equivalent values. */
+    setModes(modes) {
+        const normalized = normalizeModes(modes);
+        if (equalModes(normalized, this._modes)) {
+            return this;
+        }
+        this._modes = normalized;
+        this._geometryDirty = true;
+        this.invalidateCache();
+        return this;
+    }
+    // -----------------------------------------------------------------------
+    // Bounds
+    // -----------------------------------------------------------------------
+    getLocalBounds() {
+        const bounds = super.getLocalBounds();
+        bounds.set(0, 0, this._width, this._height);
+        return bounds;
+    }
+    // -----------------------------------------------------------------------
+    // Internal geometry (for renderers)
+    // -----------------------------------------------------------------------
+    /**
+     * Lazily-built geometry quads. Each quad describes one rendered sub-region
+     * in local space with its corresponding UV bounds.
+     * @internal
+     */
+    get quads() {
+        if (this._geometryDirty) {
+            this._rebuildGeometry();
+        }
+        return this._quads;
+    }
+    /**
+     * Render-time quads for the active pass. In `'geometry'` pixel-snap mode (and
+     * only when the combined node+view transform is axis-aligned) the shared
+     * boundary plan is snapped to the render target's device-pixel grid via the
+     * common {@link snapQuadsInto} helper, so every corner/edge/center quad reuses
+     * the exact same snapped boundary value and no seams can open. The content
+     * quad cache ({@link quads}) is never rebuilt by snapping — camera movement
+     * reuses it — and snapped quads are written into a reused buffer. Returns the
+     * unsnapped content quads for `'none'`/`'position'` or under a rotation/skew
+     * downgrade.
+     * @internal
+     */
+    getRenderQuads(view, targetPxWidth, targetPxHeight) {
+        const base = this.quads;
+        if (base.length === 0) {
+            return base;
+        }
+        const ctx = buildPixelSnapContext(this.getGlobalTransform(), view, targetPxWidth, targetPxHeight);
+        if (!ctx.axisAligned) {
+            return base;
+        }
+        return snapQuadsInto(base, ctx, this._renderQuads);
+    }
+    // -----------------------------------------------------------------------
+    // Private helpers
+    // -----------------------------------------------------------------------
+    _rebuildGeometry() {
+        this._quads = buildNineSliceQuads(this._region, this._slices, this._border, this._width, this._height, this._modes);
+        this._geometryDirty = false;
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Validation
+// ---------------------------------------------------------------------------
+const validRepeatModes = new Set(['stretch', 'repeat', 'mirror-repeat']);
+const validRepeatFits = new Set(['clip', 'round']);
+function validateSizeInput(width, height) {
+    if (!Number.isFinite(width) || !Number.isFinite(height)) {
+        throw new Error(`RepeatingSprite: width and height must be finite numbers (got ${width}, ${height}).`);
+    }
+    if (width < 0) {
+        throw new Error(`RepeatingSprite: width must be non-negative (got ${width}).`);
+    }
+    if (height < 0) {
+        throw new Error(`RepeatingSprite: height must be non-negative (got ${height}).`);
+    }
+}
+function validateMode(mode, label) {
+    if (typeof mode !== 'string' || !validRepeatModes.has(mode)) {
+        throw new Error(`RepeatingSprite: ${label} must be "stretch", "repeat", or "mirror-repeat" (got ${String(mode)}).`);
+    }
+}
+function validateFit(fit, label) {
+    if (typeof fit !== 'string' || !validRepeatFits.has(fit)) {
+        throw new Error(`RepeatingSprite: ${label} must be "clip" or "round" (got ${String(fit)}).`);
+    }
+}
+function validateOffset(value, label) {
+    if (!Number.isFinite(value)) {
+        throw new Error(`RepeatingSprite: ${label} must be a finite number (got ${value}).`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Shader-path tiling helpers
+// ---------------------------------------------------------------------------
+/**
+ * Compute the UV tiling scale for the standalone shader path.
+ *
+ * Returns how many times the source repeats across the destination span.
+ * - `stretch`: always 1.0
+ * - `repeat`/`mirror-repeat` + `round`: nearest integer count (≥ 1)
+ * - `repeat`/`mirror-repeat` + `clip`: exact fraction `destLen / srcLen`
+ * @internal
+ */
+function computeShaderTiling(srcLen, destLen, mode, fit) {
+    if (mode === 'stretch' || srcLen <= 0 || destLen <= 0) {
+        return 1;
+    }
+    if (fit === 'round') {
+        return Math.max(1, Math.round(destLen / srcLen));
+    }
+    return destLen / srcLen;
+}
+// ---------------------------------------------------------------------------
+// Geometry-path quad builder
+// ---------------------------------------------------------------------------
+const halfTexelInset = 0.5;
+/**
+ * Build the geometry quads for the atlas-region repeat path.
+ *
+ * Runs {@link planRepeat} independently on both X and Y axes with optional
+ * phase offsets, then generates the Cartesian-product quad list.  Each quad
+ * carries UV coordinates clamped inside the region's UV bounds, with
+ * extrusion-aware outer insets.
+ * @internal
+ */
+function buildRepeatingSpriteQuads(region, width, height, modeX, modeY, fitX, fitY, offsetX, offsetY) {
+    if (width === 0 || height === 0 || region.width <= 0 || region.height <= 0) {
+        return [];
+    }
+    const tw = region.texture.width;
+    const th = region.texture.height;
+    const ext = region.extrusion;
+    const outerInsetU = (ext.left > 0 || ext.right > 0) ? 0 : halfTexelInset / tw;
+    const outerInsetV = (ext.top > 0 || ext.bottom > 0) ? 0 : halfTexelInset / th;
+    const uMin = region.u0 + outerInsetU;
+    const uMax = region.u1 - outerInsetU;
+    const vMin = region.v0 + outerInsetV;
+    const vMax = region.v1 - outerInsetV;
+    const srcW = region.width;
+    const srcH = region.height;
+    const uRange = uMax - uMin;
+    const vRange = vMax - vMin;
+    const segsX = buildAxisSegmentsWithOffset(srcW, width, modeX, fitX, offsetX);
+    const segsY = buildAxisSegmentsWithOffset(srcH, height, modeY, fitY, offsetY);
+    const quads = [];
+    for (const sy of segsY) {
+        const qy0 = sy.destinationStart;
+        const qy1 = sy.destinationStart + sy.destinationLength;
+        const qv0 = vMin + sy.sourceStart * vRange;
+        const qv1 = vMin + sy.sourceEnd * vRange;
+        for (const sx of segsX) {
+            const qx0 = sx.destinationStart;
+            const qx1 = sx.destinationStart + sx.destinationLength;
+            const qu0 = uMin + sx.sourceStart * uRange;
+            const qu1 = uMin + sx.sourceEnd * uRange;
+            quads.push({ x0: qx0, y0: qy0, x1: qx1, y1: qy1, u0: qu0, v0: qv0, u1: qu1, v1: qv1 });
+        }
+    }
+    return quads;
+}
+/**
+ * Build repeat segments for one axis with an optional phase offset.
+ *
+ * The offset shifts the starting phase of the repeat in source-pixel units.
+ * For `stretch` mode the offset is silently ignored.
+ *
+ * Implementation: generates a plan for `(destLen + phase)`, shifts all
+ * segment destinations back by `phase`, and clips to `[0, destLen]`.  This
+ * is correct for `clip` fit; for `round` fit the extended-span count may
+ * differ slightly from the zero-offset count — atlas scrolling is
+ * discouraged by design.
+ * @internal
+ */
+function buildAxisSegmentsWithOffset(srcLen, destLen, mode, fit, offset) {
+    if (destLen === 0 || srcLen <= 0) {
+        return [];
+    }
+    if (mode === 'stretch') {
+        return [...planRepeat(srcLen, destLen, mode, fit).segments];
+    }
+    const phase = ((offset % srcLen) + srcLen) % srcLen;
+    if (phase === 0) {
+        return [...planRepeat(srcLen, destLen, mode, fit).segments];
+    }
+    const extendedPlan = planRepeat(srcLen, destLen + phase, mode, fit);
+    const result = [];
+    for (const seg of extendedPlan.segments) {
+        const dStart = seg.destinationStart - phase;
+        const dEnd = dStart + seg.destinationLength;
+        if (dEnd <= 0 || dStart >= destLen) {
+            continue;
+        }
+        const clippedStart = Math.max(0, dStart);
+        const clippedEnd = Math.min(destLen, dEnd);
+        const clippedLen = clippedEnd - clippedStart;
+        if (clippedLen <= 0) {
+            continue;
+        }
+        const t0 = (clippedStart - dStart) / seg.destinationLength;
+        const t1 = (clippedEnd - dStart) / seg.destinationLength;
+        const srcRange = seg.sourceEnd - seg.sourceStart;
+        result.push({
+            destinationStart: clippedStart,
+            destinationLength: clippedLen,
+            sourceStart: seg.sourceStart + t0 * srcRange,
+            sourceEnd: seg.sourceStart + t1 * srcRange,
+            mirrored: seg.mirrored,
+        });
+    }
+    return result;
+}
+
+/**
+ * A sprite that fills its destination by repeating, mirroring, or stretching
+ * a source texture or atlas region.
+ *
+ * Supports independent per-axis modes (`modeX`, `modeY`) and fit strategies
+ * (`fitX`, `fitY`).
+ *
+ * ## Internal rendering strategy (selected automatically)
+ *
+ * | Source type       | Internal path                                         |
+ * |-------------------|-------------------------------------------------------|
+ * | Bare `Texture`    | **Shader path** — one quad, GPU sampler repeat wrap.  |
+ * | `TextureRegion`   | **Geometry path** — Cartesian-product quads, clamped. |
+ *
+ * The public class identity and API do not change based on which path the
+ * renderer uses.
+ *
+ * @stable
+ */
+class RepeatingSprite extends Drawable {
+    _source;
+    _region;
+    _width;
+    _height;
+    _modeX;
+    _modeY;
+    _fitX;
+    _fitY;
+    _offsetX;
+    _offsetY;
+    _quads = [];
+    _geometryDirty = true;
+    _renderQuads = [];
+    constructor(source, options) {
+        super();
+        this._source = source;
+        this._region = source instanceof TextureRegion
+            ? source
+            : new TextureRegion(source, { x: 0, y: 0, width: source.width, height: source.height });
+        const region = this._region;
+        const opts = options ?? {};
+        const modeX = opts.modeX ?? 'repeat';
+        const modeY = opts.modeY ?? 'repeat';
+        validateMode(modeX, 'modeX');
+        validateMode(modeY, 'modeY');
+        this._modeX = modeX;
+        this._modeY = modeY;
+        const fitX = opts.fitX ?? 'round';
+        const fitY = opts.fitY ?? 'round';
+        validateFit(fitX, 'fitX');
+        validateFit(fitY, 'fitY');
+        this._fitX = fitX;
+        this._fitY = fitY;
+        const offsetX = opts.offsetX ?? 0;
+        const offsetY = opts.offsetY ?? 0;
+        validateOffset(offsetX, 'offsetX');
+        validateOffset(offsetY, 'offsetY');
+        this._offsetX = offsetX;
+        this._offsetY = offsetY;
+        const width = opts.width ?? region.width;
+        const height = opts.height ?? region.height;
+        validateSizeInput(width, height);
+        this._width = width;
+        this._height = height;
+    }
+    // -----------------------------------------------------------------------
+    // Accessors
+    // -----------------------------------------------------------------------
+    /** The original source passed to the constructor. */
+    get source() {
+        return this._source;
+    }
+    /** TextureRegion wrapping the source (bare Texture sources auto-wrapped). */
+    get region() {
+        return this._region;
+    }
+    /** Convenience accessor: the underlying Texture. */
+    get texture() {
+        return this._region.texture;
+    }
+    /** Destination width in local units. */
+    get width() {
+        return this._width;
+    }
+    set width(value) {
+        this.setSize(value, this._height);
+    }
+    /** Destination height in local units. */
+    get height() {
+        return this._height;
+    }
+    set height(value) {
+        this.setSize(this._width, value);
+    }
+    /** Horizontal repeat mode. */
+    get modeX() {
+        return this._modeX;
+    }
+    set modeX(value) {
+        validateMode(value, 'modeX');
+        if (this._modeX !== value) {
+            this._modeX = value;
+            this._geometryDirty = true;
+            this.invalidateCache();
+        }
+    }
+    /** Vertical repeat mode. */
+    get modeY() {
+        return this._modeY;
+    }
+    set modeY(value) {
+        validateMode(value, 'modeY');
+        if (this._modeY !== value) {
+            this._modeY = value;
+            this._geometryDirty = true;
+            this.invalidateCache();
+        }
+    }
+    /** Horizontal fit mode (how partial repeats are resolved). */
+    get fitX() {
+        return this._fitX;
+    }
+    set fitX(value) {
+        validateFit(value, 'fitX');
+        if (this._fitX !== value) {
+            this._fitX = value;
+            this._geometryDirty = true;
+            this.invalidateCache();
+        }
+    }
+    /** Vertical fit mode (how partial repeats are resolved). */
+    get fitY() {
+        return this._fitY;
+    }
+    set fitY(value) {
+        validateFit(value, 'fitY');
+        if (this._fitY !== value) {
+            this._fitY = value;
+            this._geometryDirty = true;
+            this.invalidateCache();
+        }
+    }
+    /**
+     * Horizontal scroll offset in source-pixel units.
+     *
+     * On the shader path (bare `Texture` source), changing the offset does
+     * **not** trigger a geometry rebuild — the value is forwarded as
+     * per-instance data at render time.  On the geometry path
+     * (`TextureRegion` source), offset changes mark quads dirty.
+     */
+    get offsetX() {
+        return this._offsetX;
+    }
+    set offsetX(value) {
+        this.setOffset(value, this._offsetY);
+    }
+    /** Vertical scroll offset in source-pixel units.  See {@link offsetX}. */
+    get offsetY() {
+        return this._offsetY;
+    }
+    set offsetY(value) {
+        this.setOffset(this._offsetX, value);
+    }
+    // -----------------------------------------------------------------------
+    // Fluent mutators
+    // -----------------------------------------------------------------------
+    /** Set destination size atomically. Preserves prior state on invalid input. */
+    setSize(width, height) {
+        validateSizeInput(width, height);
+        if (this._width !== width || this._height !== height) {
+            this._width = width;
+            this._height = height;
+            this._geometryDirty = true;
+            this.invalidateCache();
+        }
+        return this;
+    }
+    /**
+     * Set scroll offset atomically in source-pixel units.
+     * On the shader path this does not rebuild geometry.
+     * On the geometry path this marks geometry dirty.
+     */
+    setOffset(offsetX, offsetY) {
+        validateOffset(offsetX, 'offsetX');
+        validateOffset(offsetY, 'offsetY');
+        if (this._offsetX !== offsetX || this._offsetY !== offsetY) {
+            this._offsetX = offsetX;
+            this._offsetY = offsetY;
+            if (this.resolvedStrategy === 'geometry') {
+                this._geometryDirty = true;
+            }
+            this.invalidateCache();
+        }
+        return this;
+    }
+    // -----------------------------------------------------------------------
+    // Bounds
+    // -----------------------------------------------------------------------
+    getLocalBounds() {
+        const bounds = super.getLocalBounds();
+        bounds.set(0, 0, this._width, this._height);
+        return bounds;
+    }
+    // -----------------------------------------------------------------------
+    // Internal renderer interface
+    // -----------------------------------------------------------------------
+    /**
+     * Rendering strategy determined by the source type:
+     * - `'shader'` — bare `Texture`; renderer uses GPU sampler wrap.
+     * - `'geometry'` — `TextureRegion`; renderer builds repeat quads.
+     * @internal
+     */
+    get resolvedStrategy() {
+        return this._source instanceof TextureRegion ? 'geometry' : 'shader';
+    }
+    /**
+     * Lazily-built geometry quads for the geometry path.
+     * Returns an empty array on the shader path.
+     * @internal
+     */
+    get quads() {
+        if (this.resolvedStrategy === 'geometry' && this._geometryDirty) {
+            this._rebuildGeometry();
+        }
+        return this._quads;
+    }
+    /**
+     * Render-time quads for the **geometry strategy**, device-pixel-snapped in
+     * `'geometry'` pixel-snap mode (axis-aligned only). Like NineSlice, every
+     * shared repeat-segment boundary is snapped once by {@link snapQuadsInto}, so
+     * adjacent segments stay gap-free; the content cache ({@link quads}) is never
+     * rebuilt by snapping. Returns the unsnapped quads otherwise.
+     * @internal
+     */
+    getRenderQuads(view, targetPxWidth, targetPxHeight) {
+        const base = this.quads;
+        if (this.pixelSnapMode !== 'geometry' || base.length === 0) {
+            return base;
+        }
+        const ctx = buildPixelSnapContext(this.getGlobalTransform(), view, targetPxWidth, targetPxHeight);
+        if (!ctx.axisAligned) {
+            return base;
+        }
+        return snapQuadsInto(base, ctx, this._renderQuads);
+    }
+    /**
+     * Render-time destination bounds for the **shader strategy**, written into
+     * `out`. In `'geometry'` pixel-snap mode (axis-aligned only) the destination
+     * quad edges are snapped to the device grid; repetition stays shader-based, so
+     * only the outer rectangle moves. Returns the logical local bounds otherwise.
+     * @internal
+     */
+    getRenderBounds(view, targetPxWidth, targetPxHeight, out) {
+        const base = this.getLocalBounds();
+        if (this.pixelSnapMode !== 'geometry') {
+            return base;
+        }
+        const ctx = buildPixelSnapContext(this.getGlobalTransform(), view, targetPxWidth, targetPxHeight);
+        if (!ctx.axisAligned) {
+            return base;
+        }
+        return snapBoundsInto(base, ctx, out);
+    }
+    // -----------------------------------------------------------------------
+    // Private helpers
+    // -----------------------------------------------------------------------
+    _rebuildGeometry() {
+        this._quads = buildRepeatingSpriteQuads(this._region, this._width, this._height, this._modeX, this._modeY, this._fitX, this._fitY, this._offsetX, this._offsetY);
+        this._geometryDirty = false;
+    }
+}
+
 /**
  * Internal dirty-flag bitmask used by {@link Sprite} to lazily recompute
  * derived data (vertices, normals, texture coordinates, bounding boxes).
@@ -15501,6 +17025,28 @@ class Sprite extends Drawable {
         }
         return this._vertices;
     }
+    /**
+     * Local-space quad bounds for the active pass, written into `out`. In
+     * `'geometry'` pixel-snap mode (and only when the combined node+view transform
+     * is axis-aligned) the quad edges are snapped to the render target's
+     * device-pixel grid via the shared {@link snapLocalBoundary} helper — combined
+     * with the device-snapped origin from the transform seam, all four corners
+     * land on whole device pixels. The logical local bounds (used by collision /
+     * `getBounds`) are never changed. Returns the unsnapped local bounds for
+     * `'none'`/`'position'` or under a rotation/skew downgrade.
+     * @internal
+     */
+    getRenderBounds(view, targetPxWidth, targetPxHeight, out) {
+        const base = this.getLocalBounds();
+        if (this.pixelSnapMode !== 'geometry') {
+            return base;
+        }
+        const ctx = buildPixelSnapContext(this.getGlobalTransform(), view, targetPxWidth, targetPxHeight);
+        if (!ctx.axisAligned) {
+            return base;
+        }
+        return snapBoundsInto(base, ctx, out);
+    }
     /**
      * Packed UV coordinates for the four quad corners, encoded as two
      * 16-bit fixed-point values per element (low 16 bits = U, high 16 bits = V,
@@ -18308,16 +19854,16 @@ const initialIndexCapacity$2 = 192;
 const initialNodeIndexCapacity = 64;
 const defaultVertexColor = 0xffffffff; // white, full alpha
 const maxCustomTextureSlots$2 = 8;
-const transformTextureUnit$1 = 8;
+const transformTextureUnit$3 = 8;
 class WebGl2MeshRenderer extends AbstractWebGl2Renderer {
     _defaultShader = new Shader(vertexSource$3, fragmentSource$3);
     _customShaders = new Map();
     _compatibilityCache = new Map();
     _textureUnitScratch = new Int32Array([0]);
-    _transformUnitScratch = new Int32Array([transformTextureUnit$1]);
+    _transformUnitScratch = new Int32Array([transformTextureUnit$3]);
     // Pre-built texture-unit indices used for custom-shader sampler bindings;
     // pre-allocated so the per-frame uniform path stays allocation-free.
-    _slotScratches = Array.from({ length: Math.max(transformTextureUnit$1 + 1, maxCustomTextureSlots$2 + 1) }, (_, i) => new Int32Array([i]));
+    _slotScratches = Array.from({ length: Math.max(transformTextureUnit$3 + 1, maxCustomTextureSlots$2 + 1) }, (_, i) => new Int32Array([i]));
     _vertexCapacity = initialVertexCapacity$2;
     _indexCapacity = initialIndexCapacity$2;
     _nodeIndexCapacity = initialNodeIndexCapacity;
@@ -18544,7 +20090,7 @@ class WebGl2MeshRenderer extends AbstractWebGl2Renderer {
             shader.getUniform('u_projection').setValue(backend.view.getTransform().toArray(false));
         }
         if (shader.uniforms.has('u_transforms')) {
-            backend.bindTransformBufferTexture(transformTextureUnit$1, maxNodeIndex + 1);
+            backend.bindTransformBufferTexture(transformTextureUnit$3, maxNodeIndex + 1);
             shader.getUniform('u_transforms').setValue(this._transformUnitScratch);
         }
         if (shader.uniforms.has('u_texture')) {
@@ -18895,6 +20441,828 @@ class WebGl2MeshRenderer extends AbstractWebGl2Renderer {
     }
 }
 
+const nineSliceVertexSource = `#version 300 es
+precision lowp float;
+precision highp int;
+
+// Per-instance attributes (divisor = 1). One entry per nine-slice quad.
+// gl_VertexID 0..3 selects which corner of the quad this invocation computes.
+layout(location = 0) in vec4 a_quadBounds;   // x0, y0, x1, y1 (local space)
+layout(location = 1) in vec4 a_uvBounds;     // u0, v0, u1, v1 (normalised, flipY pre-applied)
+layout(location = 2) in vec4 a_color;        // RGBA tint
+layout(location = 3) in uint a_nodeIndex;    // row into the shared transform buffer
+
+uniform mat3 u_projection;
+uniform sampler2D u_transforms;              // shared per-frame transform buffer (3 texels/row)
+
+out vec2 v_texcoord;
+out vec4 v_color;
+
+void main(void) {
+    // gl_VertexID 0..3 -> corner: 0=TL, 1=TR, 2=BL, 3=BR (TRIANGLE_STRIP order)
+    int vid = gl_VertexID;
+    int cornerX = vid & 1;
+    int cornerY = (vid >> 1) & 1;
+
+    float localX = (cornerX == 0) ? a_quadBounds.x : a_quadBounds.z;
+    float localY = (cornerY == 0) ? a_quadBounds.y : a_quadBounds.w;
+
+    int row = int(a_nodeIndex);
+    vec4 m0 = texelFetch(u_transforms, ivec2(0, row), 0); // a, b, c, d
+    vec4 m1 = texelFetch(u_transforms, ivec2(1, row), 0); // tx, ty, 0, 0
+
+    float worldX = (m0.x * localX) + (m0.y * localY) + m1.x;
+    float worldY = (m0.z * localX) + (m0.w * localY) + m1.y;
+
+    gl_Position = vec4((u_projection * vec3(worldX, worldY, 1.0)).xy, 0.0, 1.0);
+
+    float u = (cornerX == 0) ? a_uvBounds.x : a_uvBounds.z;
+    float v = (cornerY == 0) ? a_uvBounds.y : a_uvBounds.w;
+    v_texcoord = vec2(u, v);
+
+    v_color = vec4(a_color.rgb * a_color.a, a_color.a);
+}`;
+const nineSliceFragmentSource = `#version 300 es
+precision lowp float;
+
+uniform sampler2D u_texture;
+
+in vec2 v_texcoord;
+in vec4 v_color;
+
+layout(location = 0) out vec4 fragColor;
+
+void main(void) {
+    vec4 sampleColor = texture(u_texture, v_texcoord);
+    fragColor = sampleColor * v_color;
+}`;
+const instanceStrideBytes$3 = 32;
+const wordsPerInstance$3 = instanceStrideBytes$3 / Uint32Array.BYTES_PER_ELEMENT;
+const transformTextureUnit$2 = 1;
+/** Instanced renderer for {@link NineSliceSprite} using WebGL2. */
+class WebGl2NineSliceSpriteRenderer extends AbstractWebGl2Renderer {
+    _shader;
+    _batchSize;
+    _instanceData;
+    _instanceFloat32;
+    _instanceUint32;
+    _transformUnitScratch = new Int32Array([transformTextureUnit$2]);
+    _quadIndex = 0;
+    _maxNodeIndex = 0;
+    _currentBlendMode = null;
+    _currentTexture = null;
+    _currentView = null;
+    _currentViewId = -1;
+    _instanceBuffer = null;
+    _vao = null;
+    _connection = null;
+    constructor(batchSize) {
+        super();
+        this._batchSize = batchSize;
+        this._shader = new Shader(nineSliceVertexSource, nineSliceFragmentSource);
+        this._instanceData = new ArrayBuffer(batchSize * instanceStrideBytes$3);
+        this._instanceFloat32 = new Float32Array(this._instanceData);
+        this._instanceUint32 = new Uint32Array(this._instanceData);
+    }
+    render(sprite) {
+        const backend = this.getBackend();
+        let quads = sprite.quads;
+        if (sprite.pixelSnapMode === 'geometry') {
+            const snap = backend._getSnapPixelSize();
+            quads = sprite.getRenderQuads(backend.view, snap.width, snap.height);
+        }
+        if (quads.length === 0) {
+            return;
+        }
+        const texture = sprite.texture;
+        const blendMode = sprite.blendMode;
+        const tintRgba = sprite.tint.toRgba();
+        const command = backend.activeDrawCommand;
+        const nodeIndex = command !== null ? command.nodeIndex : backend._pushTransform(sprite);
+        const textureChanged = this._currentTexture !== null && texture !== this._currentTexture;
+        const blendModeChanged = blendMode !== this._currentBlendMode;
+        // If the batch would overflow with current quads + new quads, flush first.
+        if (this._quadIndex > 0) {
+            if (blendModeChanged || textureChanged || this._quadIndex + quads.length > this._batchSize) {
+                this.flush();
+            }
+        }
+        // Establish blend and texture state (may have been cleared by flush).
+        if (this._currentBlendMode === null || this._currentBlendMode !== blendMode) {
+            this._currentBlendMode = blendMode;
+            backend.setBlendMode(blendMode);
+        }
+        if (this._currentTexture !== texture) {
+            this._currentTexture = texture;
+            backend.bindTexture(texture, 0);
+        }
+        // A single sprite may produce more quads than the fixed batch buffer can hold.
+        // Process in [start, end) chunks, flushing between each. Iterating by index
+        // range (rather than `quads.slice(...)`) keeps the overflow path allocation-free.
+        let offset = 0;
+        while (offset < quads.length) {
+            const chunkEnd = Math.min(offset + this._batchSize, quads.length);
+            this._writeQuadChunk(quads, offset, chunkEnd, texture, tintRgba, nodeIndex);
+            offset = chunkEnd;
+            if (offset < quads.length) {
+                this.flush();
+                // Re-establish state after flush
+                this._currentBlendMode = blendMode;
+                backend.setBlendMode(blendMode);
+                this._currentTexture = texture;
+                backend.bindTexture(texture, 0);
+            }
+        }
+    }
+    _writeQuadChunk(quads, start, end, texture, tintRgba, nodeIndex) {
+        const f32 = this._instanceFloat32;
+        const u32 = this._instanceUint32;
+        const flipY = texture.flipY;
+        for (let i = start; i < end; i++) {
+            const q = quads[i];
+            const idx = this._quadIndex * wordsPerInstance$3;
+            f32[idx + 0] = q.x0;
+            f32[idx + 1] = q.y0;
+            f32[idx + 2] = q.x1;
+            f32[idx + 3] = q.y1;
+            const uMin = (q.u0 * 0xffff) & 0xffff;
+            const uMax = (q.u1 * 0xffff) & 0xffff;
+            const v0Raw = (q.v0 * 0xffff) & 0xffff;
+            const v1Raw = (q.v1 * 0xffff) & 0xffff;
+            const vMin = flipY ? v1Raw : v0Raw;
+            const vMax = flipY ? v0Raw : v1Raw;
+            u32[idx + 4] = uMin | (vMin << 16);
+            u32[idx + 5] = uMax | (vMax << 16);
+            u32[idx + 6] = tintRgba;
+            u32[idx + 7] = nodeIndex >>> 0;
+            this._quadIndex++;
+            if (nodeIndex > this._maxNodeIndex) {
+                this._maxNodeIndex = nodeIndex;
+            }
+        }
+    }
+    flush() {
+        const backend = this.getBackendOrNull();
+        const instanceBuffer = this._instanceBuffer;
+        const vao = this._vao;
+        if (this._quadIndex === 0 || backend === null || instanceBuffer === null || vao === null) {
+            this._quadIndex = 0;
+            this._maxNodeIndex = 0;
+            return;
+        }
+        const view = backend.view;
+        if (this._currentView !== view || this._currentViewId !== view.updateId) {
+            this._currentView = view;
+            this._currentViewId = view.updateId;
+            this._shader.getUniform('u_projection').setValue(view.getTransform().toArray(false));
+        }
+        if (this._currentTexture !== null) {
+            this._shader.getUniform('u_texture').setValue(new Int32Array([0]));
+        }
+        backend.bindTransformBufferTexture(transformTextureUnit$2, this._maxNodeIndex + 1);
+        this._shader.getUniform('u_transforms').setValue(this._transformUnitScratch);
+        this._shader.sync();
+        backend.bindVertexArrayObject(vao);
+        instanceBuffer.upload(this._instanceFloat32.subarray(0, this._quadIndex * wordsPerInstance$3));
+        vao.drawInstanced(4, 0, this._quadIndex, RenderingPrimitives.TriangleStrip);
+        backend.stats.batches++;
+        backend.stats.drawCalls++;
+        this._quadIndex = 0;
+        this._maxNodeIndex = 0;
+    }
+    onConnect(backend) {
+        const gl = backend.context;
+        this._shader.connect(createWebGl2ShaderProgram(gl));
+        this._connection = this._createConnection(gl);
+        this._instanceBuffer = new WebGl2RenderBuffer(BufferTypes.ArrayBuffer, this._instanceData, BufferUsage.DynamicDraw).connect(this._createBufferRuntime(this._connection));
+        this._shader.sync();
+        this._vao = new WebGl2VertexArrayObject(RenderingPrimitives.TriangleStrip)
+            .addAttribute(this._instanceBuffer, this._shader.getAttribute('a_quadBounds'), gl.FLOAT, false, instanceStrideBytes$3, 0, false, 1)
+            .addAttribute(this._instanceBuffer, this._shader.getAttribute('a_uvBounds'), gl.UNSIGNED_SHORT, true, instanceStrideBytes$3, 16, false, 1)
+            .addAttribute(this._instanceBuffer, this._shader.getAttribute('a_color'), gl.UNSIGNED_BYTE, true, instanceStrideBytes$3, 24, false, 1)
+            .addAttribute(this._instanceBuffer, this._shader.getAttribute('a_nodeIndex'), gl.UNSIGNED_INT, false, instanceStrideBytes$3, 28, true, 1)
+            .connect(this._createVaoRuntime(this._connection));
+    }
+    onDisconnect() {
+        this._shader.disconnect();
+        this._instanceBuffer?.destroy();
+        this._instanceBuffer = null;
+        this._vao?.destroy();
+        this._vao = null;
+        this._connection = null;
+        this._currentBlendMode = null;
+        this._currentTexture = null;
+        this._currentView = null;
+        this._currentViewId = -1;
+        this._quadIndex = 0;
+        this._maxNodeIndex = 0;
+    }
+    destroy() {
+        this.disconnect();
+        this._shader.destroy();
+    }
+    _createConnection(gl) {
+        const vaoHandle = gl.createVertexArray();
+        if (vaoHandle === null) {
+            throw new Error('WebGl2NineSliceSpriteRenderer: could not create vertex array object.');
+        }
+        return { gl, buffers: new Map(), vaoHandle };
+    }
+    _createBufferRuntime(connection) {
+        const handle = connection.gl.createBuffer();
+        if (handle === null) {
+            throw new Error('WebGl2NineSliceSpriteRenderer: could not create render buffer.');
+        }
+        return {
+            bind: (buffer) => {
+                connection.gl.bindBuffer(buffer.type, handle);
+            },
+            upload: (buffer, offset) => {
+                const gl = connection.gl;
+                const data = buffer.data;
+                const state = connection.buffers.get(buffer);
+                gl.bindBuffer(buffer.type, handle);
+                if (state && state.dataByteLength >= data.byteLength) {
+                    gl.bufferSubData(buffer.type, offset, data);
+                    state.dataByteLength = data.byteLength;
+                }
+                else {
+                    gl.bufferData(buffer.type, data, buffer.usage);
+                    connection.buffers.set(buffer, { handle, dataByteLength: data.byteLength });
+                }
+            },
+            destroy: (buffer) => {
+                connection.gl.deleteBuffer(handle);
+                connection.buffers.delete(buffer);
+                buffer.disconnect();
+            },
+        };
+    }
+    _createVaoRuntime(connection) {
+        let appliedVersion = -1;
+        return {
+            bind: (vao) => {
+                const gl = connection.gl;
+                gl.bindVertexArray(connection.vaoHandle);
+                if (appliedVersion !== vao.version) {
+                    let lastBuffer = null;
+                    for (const attribute of vao.attributes) {
+                        if (lastBuffer !== attribute.buffer) {
+                            attribute.buffer.bind();
+                            lastBuffer = attribute.buffer;
+                        }
+                        if (attribute.integer) {
+                            gl.vertexAttribIPointer(attribute.location, attribute.size, attribute.type, attribute.stride, attribute.start);
+                        }
+                        else {
+                            gl.vertexAttribPointer(attribute.location, attribute.size, attribute.type, attribute.normalized, attribute.stride, attribute.start);
+                        }
+                        gl.enableVertexAttribArray(attribute.location);
+                        gl.vertexAttribDivisor(attribute.location, attribute.divisor);
+                    }
+                    appliedVersion = vao.version;
+                }
+            },
+            unbind: () => {
+                connection.gl.bindVertexArray(null);
+            },
+            draw: (_vao, size, start, type) => {
+                connection.gl.drawArrays(type, start, size);
+            },
+            drawInstanced: (_vao, count, start, instanceCount, type) => {
+                connection.gl.drawArraysInstanced(type, start, count, instanceCount);
+            },
+            destroy: (vao) => {
+                connection.gl.deleteVertexArray(connection.vaoHandle);
+                vao.disconnect();
+            },
+        };
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Shader path: one quad per sprite, UVs computed in vertex shader.
+// ---------------------------------------------------------------------------
+const shaderPathVertSource = `#version 300 es
+precision mediump float;
+precision highp int;
+
+layout(location = 0) in vec4 a_quadBounds;   // x0,y0,x1,y1 (local space)
+layout(location = 1) in vec4 a_uvParams;     // tilingX, tilingY, offsetU, offsetV
+layout(location = 2) in vec4 a_color;        // RGBA tint (normalised)
+layout(location = 3) in uint a_nodeIndex;    // transform row
+
+uniform mat3 u_projection;
+uniform sampler2D u_transforms;
+
+out vec2 v_texcoord;
+out vec4 v_color;
+
+void main(void) {
+    int vid = gl_VertexID;
+    int cx = vid & 1;
+    int cy = (vid >> 1) & 1;
+
+    float lx = (cx == 0) ? a_quadBounds.x : a_quadBounds.z;
+    float ly = (cy == 0) ? a_quadBounds.y : a_quadBounds.w;
+
+    float destW = a_quadBounds.z - a_quadBounds.x;
+    float destH = a_quadBounds.w - a_quadBounds.y;
+
+    int row = int(a_nodeIndex);
+    vec4 m0 = texelFetch(u_transforms, ivec2(0, row), 0);
+    vec4 m1 = texelFetch(u_transforms, ivec2(1, row), 0);
+
+    float wx = m0.x * lx + m0.y * ly + m1.x;
+    float wy = m0.z * lx + m0.w * ly + m1.y;
+    gl_Position = vec4((u_projection * vec3(wx, wy, 1.0)).xy, 0.0, 1.0);
+
+    float u = (destW > 0.0)
+        ? ((lx - a_quadBounds.x) / destW) * a_uvParams.x + a_uvParams.z
+        : a_uvParams.z;
+    float v = (destH > 0.0)
+        ? ((ly - a_quadBounds.y) / destH) * a_uvParams.y + a_uvParams.w
+        : a_uvParams.w;
+    v_texcoord = vec2(u, v);
+
+    v_color = vec4(a_color.rgb * a_color.a, a_color.a);
+}`;
+// ---------------------------------------------------------------------------
+// Geometry path: N quads per sprite, UVs pre-computed in CPU (like NineSlice).
+// ---------------------------------------------------------------------------
+const geoPathVertSource = `#version 300 es
+precision lowp float;
+precision highp int;
+
+layout(location = 0) in vec4 a_quadBounds;   // x0,y0,x1,y1 (local space)
+layout(location = 1) in vec4 a_uvBounds;     // u0,v0,u1,v1 (normalised, flipY pre-applied)
+layout(location = 2) in vec4 a_color;        // RGBA tint
+layout(location = 3) in uint a_nodeIndex;    // transform row
+
+uniform mat3 u_projection;
+uniform sampler2D u_transforms;
+
+out vec2 v_texcoord;
+out vec4 v_color;
+
+void main(void) {
+    int vid = gl_VertexID;
+    int cx = vid & 1;
+    int cy = (vid >> 1) & 1;
+
+    float lx = (cx == 0) ? a_quadBounds.x : a_quadBounds.z;
+    float ly = (cy == 0) ? a_quadBounds.y : a_quadBounds.w;
+
+    int row = int(a_nodeIndex);
+    vec4 m0 = texelFetch(u_transforms, ivec2(0, row), 0);
+    vec4 m1 = texelFetch(u_transforms, ivec2(1, row), 0);
+
+    float wx = m0.x * lx + m0.y * ly + m1.x;
+    float wy = m0.z * lx + m0.w * ly + m1.y;
+    gl_Position = vec4((u_projection * vec3(wx, wy, 1.0)).xy, 0.0, 1.0);
+
+    float u = (cx == 0) ? a_uvBounds.x : a_uvBounds.z;
+    float v = (cy == 0) ? a_uvBounds.y : a_uvBounds.w;
+    v_texcoord = vec2(u, v);
+
+    v_color = vec4(a_color.rgb * a_color.a, a_color.a);
+}`;
+const sharedFragSource = `#version 300 es
+precision lowp float;
+
+uniform sampler2D u_texture;
+
+in vec2 v_texcoord;
+in vec4 v_color;
+
+layout(location = 0) out vec4 fragColor;
+
+void main(void) {
+    fragColor = texture(u_texture, v_texcoord) * v_color;
+}`;
+// ---------------------------------------------------------------------------
+// Layout constants
+// ---------------------------------------------------------------------------
+const shaderStrideBytes$1 = 40; // 10 × float32
+const shaderWordsPerInstance = shaderStrideBytes$1 / Uint32Array.BYTES_PER_ELEMENT;
+const geoStrideBytes$1 = 32; // 8 × uint32 (matches NineSlice layout)
+const geoWordsPerInstance = geoStrideBytes$1 / Uint32Array.BYTES_PER_ELEMENT;
+const transformTextureUnit$1 = 1;
+// ---------------------------------------------------------------------------
+// Sampler cache helper
+// ---------------------------------------------------------------------------
+function repeatModeToWrap(mode) {
+    if (mode === 'repeat')
+        return WrapModes.Repeat;
+    if (mode === 'mirror-repeat')
+        return WrapModes.MirroredRepeat;
+    return WrapModes.ClampToEdge;
+}
+/** Instanced renderer for {@link RepeatingSprite} using WebGL2. Handles both shader and geometry paths internally. */
+class WebGl2RepeatingSpriteRenderer extends AbstractWebGl2Renderer {
+    _shaderPathShader;
+    _geoPathShader;
+    _batchSize;
+    // Shader-path buffers
+    _shaderData;
+    _shaderF32;
+    _shaderU32;
+    _shaderBuf = null;
+    _shaderVao = null;
+    _shaderQuadCount = 0;
+    // Geometry-path buffers
+    _geoData;
+    _geoF32;
+    _geoU32;
+    _geoBuf = null;
+    _geoVao = null;
+    _geoQuadCount = 0;
+    // Sampler cache keyed by "wrapS:wrapT:scaleMode"
+    _samplers = new Map();
+    // Shared batch state
+    _maxNodeIndex = 0;
+    _currentTexture = null;
+    _currentBlendMode = null;
+    _currentModeX = null;
+    _currentModeY = null;
+    _currentPath = null;
+    _connection = null;
+    _transformUnitScratch = new Int32Array([transformTextureUnit$1]);
+    _snapBounds = new Rectangle();
+    _currentView = null;
+    _currentViewId = -1;
+    constructor(batchSize) {
+        super();
+        this._batchSize = batchSize;
+        this._shaderPathShader = new Shader(shaderPathVertSource, sharedFragSource);
+        this._geoPathShader = new Shader(geoPathVertSource, sharedFragSource);
+        this._shaderData = new ArrayBuffer(batchSize * shaderStrideBytes$1);
+        this._shaderF32 = new Float32Array(this._shaderData);
+        this._shaderU32 = new Uint32Array(this._shaderData);
+        this._geoData = new ArrayBuffer(batchSize * geoStrideBytes$1);
+        this._geoF32 = new Float32Array(this._geoData);
+        this._geoU32 = new Uint32Array(this._geoData);
+    }
+    render(sprite) {
+        const strategy = sprite.resolvedStrategy;
+        const texture = sprite.texture;
+        const blendMode = sprite.blendMode;
+        const modeX = sprite.modeX;
+        const modeY = sprite.modeY;
+        const hasData = this._shaderQuadCount > 0 || this._geoQuadCount > 0;
+        if (hasData) {
+            const pathChanged = this._currentPath !== strategy;
+            const texChanged = this._currentTexture !== texture;
+            const blendChanged = this._currentBlendMode !== blendMode;
+            const modeChanged = strategy === 'shader'
+                && (this._currentModeX !== modeX || this._currentModeY !== modeY);
+            if (pathChanged || texChanged || blendChanged || modeChanged) {
+                this.flush();
+            }
+        }
+        const backend = this.getBackend();
+        if (this._currentTexture !== texture) {
+            this._currentTexture = texture;
+            backend.bindTexture(texture, 0);
+        }
+        if (this._currentBlendMode !== blendMode) {
+            this._currentBlendMode = blendMode;
+            backend.setBlendMode(blendMode);
+        }
+        this._currentPath = strategy;
+        const command = backend.activeDrawCommand;
+        const nodeIndex = command !== null ? command.nodeIndex : backend._pushTransform(sprite);
+        if (nodeIndex > this._maxNodeIndex) {
+            this._maxNodeIndex = nodeIndex;
+        }
+        if (strategy === 'shader') {
+            this._currentModeX = modeX;
+            this._currentModeY = modeY;
+            this._writeShaderInstance(sprite, nodeIndex);
+        }
+        else {
+            this._writeGeoQuads(sprite, nodeIndex);
+        }
+    }
+    _writeShaderInstance(sprite, nodeIndex) {
+        const texture = sprite.texture;
+        const srcW = sprite.region.width;
+        const srcH = sprite.region.height;
+        let destW = sprite.width;
+        let destH = sprite.height;
+        const flipY = texture instanceof Texture && texture.flipY;
+        // 'geometry' mode: snap the destination quad to the device grid. Repetition
+        // stays shader-based; only the outer rectangle (and the tiling derived from
+        // it) moves. Position/none leave the destination unchanged.
+        if (sprite.pixelSnapMode === 'geometry') {
+            const backend = this.getBackend();
+            const snap = backend._getSnapPixelSize();
+            const rb = sprite.getRenderBounds(backend.view, snap.width, snap.height, this._snapBounds);
+            destW = rb.width;
+            destH = rb.height;
+        }
+        const tilingX = computeShaderTiling(srcW, destW, sprite.modeX, sprite.fitX);
+        const tilingY = computeShaderTiling(srcH, destH, sprite.modeY, sprite.fitY);
+        const offsetU = sprite.offsetX / (srcW > 0 ? srcW : 1);
+        const offsetV = sprite.offsetY / (srcH > 0 ? srcH : 1);
+        // When flipY, negate tilingY and start from tilingY so V runs top→bottom.
+        const uvParamY = flipY ? -tilingY : tilingY;
+        const uvParamW = flipY ? tilingY + offsetV : offsetV;
+        if (this._shaderQuadCount >= this._batchSize) {
+            this.flush();
+        }
+        const idx = this._shaderQuadCount * shaderWordsPerInstance;
+        const f32 = this._shaderF32;
+        const u32 = this._shaderU32;
+        f32[idx + 0] = 0;
+        f32[idx + 1] = 0;
+        f32[idx + 2] = destW;
+        f32[idx + 3] = destH;
+        f32[idx + 4] = tilingX;
+        f32[idx + 5] = uvParamY;
+        f32[idx + 6] = offsetU;
+        f32[idx + 7] = uvParamW;
+        u32[idx + 8] = sprite.tint.toRgba();
+        u32[idx + 9] = nodeIndex >>> 0;
+        this._shaderQuadCount++;
+    }
+    _writeGeoQuads(sprite, nodeIndex) {
+        let quads = sprite.quads;
+        // 'geometry' mode: snap shared segment boundaries once (gap-free), like NineSlice.
+        if (sprite.pixelSnapMode === 'geometry') {
+            const backend = this.getBackend();
+            const snap = backend._getSnapPixelSize();
+            quads = sprite.getRenderQuads(backend.view, snap.width, snap.height);
+        }
+        const flipY = (sprite.texture instanceof Texture) && sprite.texture.flipY;
+        const tint = sprite.tint.toRgba();
+        let offset = 0;
+        while (offset < quads.length) {
+            const remaining = quads.length - offset;
+            const chunk = Math.min(remaining, this._batchSize - this._geoQuadCount);
+            if (chunk <= 0) {
+                this.flush();
+                // Re-establish texture/blend after flush
+                const backend = this.getBackend();
+                backend.bindTexture(sprite.texture, 0);
+                backend.setBlendMode(sprite.blendMode);
+                this._currentTexture = sprite.texture;
+                this._currentBlendMode = sprite.blendMode;
+                this._currentPath = 'geometry';
+                if (nodeIndex > this._maxNodeIndex) {
+                    this._maxNodeIndex = nodeIndex;
+                }
+                continue;
+            }
+            const f32 = this._geoF32;
+            const u32 = this._geoU32;
+            for (let i = 0; i < chunk; i++) {
+                const q = quads[offset + i];
+                const idx = (this._geoQuadCount + i) * geoWordsPerInstance;
+                f32[idx + 0] = q.x0;
+                f32[idx + 1] = q.y0;
+                f32[idx + 2] = q.x1;
+                f32[idx + 3] = q.y1;
+                const uMin = (q.u0 * 0xffff) & 0xffff;
+                const uMax = (q.u1 * 0xffff) & 0xffff;
+                const v0Raw = (q.v0 * 0xffff) & 0xffff;
+                const v1Raw = (q.v1 * 0xffff) & 0xffff;
+                const vMin = flipY ? v1Raw : v0Raw;
+                const vMax = flipY ? v0Raw : v1Raw;
+                u32[idx + 4] = uMin | (vMin << 16);
+                u32[idx + 5] = uMax | (vMax << 16);
+                u32[idx + 6] = tint;
+                u32[idx + 7] = nodeIndex >>> 0;
+            }
+            this._geoQuadCount += chunk;
+            offset += chunk;
+        }
+    }
+    flush() {
+        const backend = this.getBackendOrNull();
+        if (backend === null) {
+            this._resetBatchState();
+            return;
+        }
+        const view = backend.view;
+        if (this._currentView !== view || this._currentViewId !== view.updateId) {
+            this._currentView = view;
+            this._currentViewId = view.updateId;
+            const proj = view.getTransform().toArray(false);
+            this._shaderPathShader.getUniform('u_projection').setValue(proj);
+            this._geoPathShader.getUniform('u_projection').setValue(proj);
+        }
+        if (this._shaderQuadCount > 0) {
+            this._flushShaderBatch(backend);
+        }
+        if (this._geoQuadCount > 0) {
+            this._flushGeoBatch(backend);
+        }
+        this._resetBatchState();
+    }
+    _flushShaderBatch(backend) {
+        const conn = this._connection;
+        const buf = this._shaderBuf;
+        const vao = this._shaderVao;
+        if (!conn || !buf || !vao || this._shaderQuadCount === 0)
+            return;
+        const gl = conn.gl;
+        const texture = this._currentTexture;
+        const scaleMode = (texture instanceof Texture) ? texture.scaleMode : ScaleModes.Linear;
+        const wrapS = repeatModeToWrap(this._currentModeX ?? 'repeat');
+        const wrapT = repeatModeToWrap(this._currentModeY ?? 'repeat');
+        // Bind repeat sampler (overrides texture's own wrap params for this unit).
+        const samplerHandle = this._getOrCreateSampler(gl, wrapS, wrapT, scaleMode);
+        gl.bindSampler(0, samplerHandle);
+        backend.bindTransformBufferTexture(transformTextureUnit$1, this._maxNodeIndex + 1);
+        this._shaderPathShader.getUniform('u_texture').setValue(new Int32Array([0]));
+        this._shaderPathShader.getUniform('u_transforms').setValue(this._transformUnitScratch);
+        this._shaderPathShader.sync();
+        backend.bindVertexArrayObject(vao);
+        buf.upload(this._shaderF32.subarray(0, this._shaderQuadCount * shaderWordsPerInstance));
+        vao.drawInstanced(4, 0, this._shaderQuadCount, RenderingPrimitives.TriangleStrip);
+        backend.stats.batches++;
+        backend.stats.drawCalls++;
+        // Unbind sampler so subsequent draws use the texture's own wrap params.
+        gl.bindSampler(0, null);
+        this._shaderQuadCount = 0;
+    }
+    _flushGeoBatch(backend) {
+        const conn = this._connection;
+        const buf = this._geoBuf;
+        const vao = this._geoVao;
+        if (!conn || !buf || !vao || this._geoQuadCount === 0)
+            return;
+        backend.bindTransformBufferTexture(transformTextureUnit$1, this._maxNodeIndex + 1);
+        this._geoPathShader.getUniform('u_texture').setValue(new Int32Array([0]));
+        this._geoPathShader.getUniform('u_transforms').setValue(this._transformUnitScratch);
+        this._geoPathShader.sync();
+        backend.bindVertexArrayObject(vao);
+        buf.upload(this._geoF32.subarray(0, this._geoQuadCount * geoWordsPerInstance));
+        vao.drawInstanced(4, 0, this._geoQuadCount, RenderingPrimitives.TriangleStrip);
+        backend.stats.batches++;
+        backend.stats.drawCalls++;
+        this._geoQuadCount = 0;
+    }
+    _resetBatchState() {
+        this._shaderQuadCount = 0;
+        this._geoQuadCount = 0;
+        this._maxNodeIndex = 0;
+        this._currentTexture = null;
+        this._currentBlendMode = null;
+        this._currentModeX = null;
+        this._currentModeY = null;
+        this._currentPath = null;
+    }
+    _getOrCreateSampler(gl, wrapS, wrapT, scaleMode) {
+        const key = `${wrapS}:${wrapT}:${scaleMode}`;
+        const existing = this._samplers.get(key);
+        if (existing !== undefined)
+            return existing;
+        const sampler = gl.createSampler();
+        if (sampler === null)
+            throw new Error('WebGl2RepeatingSpriteRenderer: could not create sampler.');
+        gl.samplerParameteri(sampler, gl.TEXTURE_WRAP_S, wrapS);
+        gl.samplerParameteri(sampler, gl.TEXTURE_WRAP_T, wrapT);
+        gl.samplerParameteri(sampler, gl.TEXTURE_MAG_FILTER, scaleMode);
+        gl.samplerParameteri(sampler, gl.TEXTURE_MIN_FILTER, scaleMode);
+        this._samplers.set(key, sampler);
+        return sampler;
+    }
+    onConnect(backend) {
+        const gl = backend.context;
+        this._shaderPathShader.connect(createWebGl2ShaderProgram(gl));
+        this._geoPathShader.connect(createWebGl2ShaderProgram(gl));
+        // sync() triggers finalize() which compiles the shaders and populates the
+        // attributes/uniforms maps — must happen before any getAttribute() call.
+        this._shaderPathShader.sync();
+        this._geoPathShader.sync();
+        const conn = this._createConnection(gl);
+        this._connection = conn;
+        // Shader-path VAO (uses float4 uvParams, not packed unorm16)
+        this._shaderBuf = new WebGl2RenderBuffer(BufferTypes.ArrayBuffer, this._shaderData, BufferUsage.DynamicDraw)
+            .connect(this._createBufRuntime(conn, 'shader'));
+        this._shaderVao = new WebGl2VertexArrayObject(RenderingPrimitives.TriangleStrip)
+            .addAttribute(this._shaderBuf, this._shaderPathShader.getAttribute('a_quadBounds'), gl.FLOAT, false, shaderStrideBytes$1, 0, false, 1)
+            .addAttribute(this._shaderBuf, this._shaderPathShader.getAttribute('a_uvParams'), gl.FLOAT, false, shaderStrideBytes$1, 16, false, 1)
+            .addAttribute(this._shaderBuf, this._shaderPathShader.getAttribute('a_color'), gl.UNSIGNED_BYTE, true, shaderStrideBytes$1, 32, false, 1)
+            .addAttribute(this._shaderBuf, this._shaderPathShader.getAttribute('a_nodeIndex'), gl.UNSIGNED_INT, false, shaderStrideBytes$1, 36, true, 1)
+            .connect(this._createVaoRuntime(conn, 'shader'));
+        // Geometry-path VAO (packed unorm16 UVs, same layout as NineSlice)
+        this._geoBuf = new WebGl2RenderBuffer(BufferTypes.ArrayBuffer, this._geoData, BufferUsage.DynamicDraw)
+            .connect(this._createBufRuntime(conn, 'geo'));
+        this._geoVao = new WebGl2VertexArrayObject(RenderingPrimitives.TriangleStrip)
+            .addAttribute(this._geoBuf, this._geoPathShader.getAttribute('a_quadBounds'), gl.FLOAT, false, geoStrideBytes$1, 0, false, 1)
+            .addAttribute(this._geoBuf, this._geoPathShader.getAttribute('a_uvBounds'), gl.UNSIGNED_SHORT, true, geoStrideBytes$1, 16, false, 1)
+            .addAttribute(this._geoBuf, this._geoPathShader.getAttribute('a_color'), gl.UNSIGNED_BYTE, true, geoStrideBytes$1, 24, false, 1)
+            .addAttribute(this._geoBuf, this._geoPathShader.getAttribute('a_nodeIndex'), gl.UNSIGNED_INT, false, geoStrideBytes$1, 28, true, 1)
+            .connect(this._createVaoRuntime(conn, 'geo'));
+    }
+    onDisconnect() {
+        const gl = this._connection?.gl;
+        if (gl !== undefined) {
+            for (const sampler of this._samplers.values()) {
+                gl.deleteSampler(sampler);
+            }
+        }
+        this._samplers.clear();
+        this._shaderPathShader.disconnect();
+        this._geoPathShader.disconnect();
+        this._shaderBuf?.destroy();
+        this._shaderBuf = null;
+        this._shaderVao?.destroy();
+        this._shaderVao = null;
+        this._geoBuf?.destroy();
+        this._geoBuf = null;
+        this._geoVao?.destroy();
+        this._geoVao = null;
+        this._connection = null;
+        this._currentView = null;
+        this._currentViewId = -1;
+        this._resetBatchState();
+    }
+    destroy() {
+        this.disconnect();
+        this._shaderPathShader.destroy();
+        this._geoPathShader.destroy();
+    }
+    // -----------------------------------------------------------------------
+    // Private GL helpers
+    // -----------------------------------------------------------------------
+    _createConnection(gl) {
+        const shaderVaoHandle = gl.createVertexArray();
+        const geoVaoHandle = gl.createVertexArray();
+        if (shaderVaoHandle === null || geoVaoHandle === null) {
+            throw new Error('WebGl2RepeatingSpriteRenderer: could not create vertex array object.');
+        }
+        return { gl, buffers: new Map(), shaderVaoHandle, geoVaoHandle };
+    }
+    _createBufRuntime(conn, _kind) {
+        const handle = conn.gl.createBuffer();
+        if (handle === null)
+            throw new Error('WebGl2RepeatingSpriteRenderer: could not create render buffer.');
+        return {
+            bind: (buffer) => { conn.gl.bindBuffer(buffer.type, handle); },
+            upload: (buffer, offset) => {
+                const gl = conn.gl;
+                const data = buffer.data;
+                const state = conn.buffers.get(buffer);
+                gl.bindBuffer(buffer.type, handle);
+                if (state && state.dataByteLength >= data.byteLength) {
+                    gl.bufferSubData(buffer.type, offset, data);
+                    state.dataByteLength = data.byteLength;
+                }
+                else {
+                    gl.bufferData(buffer.type, data, buffer.usage);
+                    conn.buffers.set(buffer, { handle, dataByteLength: data.byteLength });
+                }
+            },
+            destroy: (buffer) => {
+                conn.gl.deleteBuffer(handle);
+                conn.buffers.delete(buffer);
+                buffer.disconnect();
+            },
+        };
+    }
+    _createVaoRuntime(conn, kind) {
+        const vaoHandle = kind === 'shader' ? conn.shaderVaoHandle : conn.geoVaoHandle;
+        let appliedVersion = -1;
+        return {
+            bind: (vao) => {
+                const gl = conn.gl;
+                gl.bindVertexArray(vaoHandle);
+                if (appliedVersion !== vao.version) {
+                    let lastBuffer = null;
+                    for (const attr of vao.attributes) {
+                        if (lastBuffer !== attr.buffer) {
+                            attr.buffer.bind();
+                            lastBuffer = attr.buffer;
+                        }
+                        if (attr.integer) {
+                            gl.vertexAttribIPointer(attr.location, attr.size, attr.type, attr.stride, attr.start);
+                        }
+                        else {
+                            gl.vertexAttribPointer(attr.location, attr.size, attr.type, attr.normalized, attr.stride, attr.start);
+                        }
+                        gl.enableVertexAttribArray(attr.location);
+                        gl.vertexAttribDivisor(attr.location, attr.divisor);
+                    }
+                    appliedVersion = vao.version;
+                }
+            },
+            unbind: () => { conn.gl.bindVertexArray(null); },
+            draw: (_vao, size, start, type) => { conn.gl.drawArrays(type, start, size); },
+            drawInstanced: (_vao, count, start, instanceCount, type) => {
+                conn.gl.drawArraysInstanced(type, start, count, instanceCount);
+            },
+            destroy: (vao) => {
+                conn.gl.deleteVertexArray(vaoHandle);
+                vao.disconnect();
+            },
+        };
+    }
+}
+
 /**
  * Canonical engine vertex stage for the custom {@link SpriteMaterial} path.
  *
@@ -19087,8 +21455,8 @@ const maxBatchTextures$1 = 8;
 // Sprite base textures occupy units 0..7; the shared transform buffer texture
 // binds on unit 8, matching the mesh renderer's convention.
 const transformTextureUnit = 8;
-const instanceStrideBytes$1 = 36;
-const wordsPerInstance$1 = instanceStrideBytes$1 / Uint32Array.BYTES_PER_ELEMENT;
+const instanceStrideBytes$2 = 36;
+const wordsPerInstance$2 = instanceStrideBytes$2 / Uint32Array.BYTES_PER_ELEMENT;
 class WebGl2SpriteRenderer extends AbstractWebGl2Renderer {
     _shader;
     _batchSize;
@@ -19108,6 +21476,10 @@ class WebGl2SpriteRenderer extends AbstractWebGl2Renderer {
     _transformUnitScratch = new Int32Array([transformTextureUnit]);
     _currentMaterial = null;
     _currentBaseTexture = null;
+    // Reusable scratch for device-snapped local bounds ('geometry' mode), and the
+    // bounds resolved for the sprite currently being packed (snapped or logical).
+    _snapBounds = new Rectangle();
+    _activeBounds = null;
     _instanceCount = 0;
     // Highest transform-buffer row referenced by the pending batch; drives the
     // minimum row count uploaded for the transform texture at flush time.
@@ -19122,7 +21494,7 @@ class WebGl2SpriteRenderer extends AbstractWebGl2Renderer {
         super();
         this._batchSize = batchSize;
         this._shader = new Shader(vertexSource$2, fragmentSource$2);
-        this._instanceData = new ArrayBuffer(batchSize * instanceStrideBytes$1);
+        this._instanceData = new ArrayBuffer(batchSize * instanceStrideBytes$2);
         this._instanceFloat32 = new Float32Array(this._instanceData);
         this._instanceUint32 = new Uint32Array(this._instanceData);
     }
@@ -19139,6 +21511,7 @@ class WebGl2SpriteRenderer extends AbstractWebGl2Renderer {
         // sprite's transform into the buffer and use the freshly-allocated slot.
         const command = backend.activeDrawCommand;
         const nodeIndex = command !== null ? command.nodeIndex : backend._pushTransform(sprite);
+        this._activeBounds = this._resolveBounds(sprite, backend);
         if (material === null) {
             this._renderDefault(sprite, texture, backend, nodeIndex);
         }
@@ -19147,6 +21520,19 @@ class WebGl2SpriteRenderer extends AbstractWebGl2Renderer {
         }
         return this;
     }
+    /**
+     * Local bounds to upload for `sprite` this draw: device-pixel-snapped in
+     * `'geometry'` pixel-snap mode (axis-aligned only), otherwise the sprite's
+     * logical local bounds. Reuses a scratch rectangle and never mutates logical
+     * state. Consumed synchronously by {@link _packInstance}.
+     */
+    _resolveBounds(sprite, backend) {
+        if (sprite.pixelSnapMode !== 'geometry') {
+            return sprite.getLocalBounds();
+        }
+        const snap = backend._getSnapPixelSize();
+        return sprite.getRenderBounds(backend.view, snap.width, snap.height, this._snapBounds);
+    }
     flush() {
         const backend = this.getBackendOrNull();
         const instanceBuffer = this._instanceBuffer;
@@ -19190,7 +21576,7 @@ class WebGl2SpriteRenderer extends AbstractWebGl2Renderer {
         }
         shader.sync();
         backend.bindVertexArrayObject(vao);
-        instanceBuffer.upload(this._instanceFloat32.subarray(0, this._instanceCount * wordsPerInstance$1));
+        instanceBuffer.upload(this._instanceFloat32.subarray(0, this._instanceCount * wordsPerInstance$2));
         vao.drawInstanced(4, 0, this._instanceCount, RenderingPrimitives.TriangleStrip);
         backend.stats.batches++;
         backend.stats.drawCalls++;
@@ -19205,11 +21591,11 @@ class WebGl2SpriteRenderer extends AbstractWebGl2Renderer {
         this._instanceBuffer = new WebGl2RenderBuffer(BufferTypes.ArrayBuffer, this._instanceData, BufferUsage.DynamicDraw).connect(this._createBufferRuntime(this._connection));
         this._shader.sync();
         this._vao = new WebGl2VertexArrayObject(RenderingPrimitives.TriangleStrip)
-            .addAttribute(this._instanceBuffer, this._shader.getAttribute('a_localBounds'), gl.FLOAT, false, instanceStrideBytes$1, 0, false, 1)
-            .addAttribute(this._instanceBuffer, this._shader.getAttribute('a_uvBounds'), gl.UNSIGNED_SHORT, true, instanceStrideBytes$1, 16, false, 1)
-            .addAttribute(this._instanceBuffer, this._shader.getAttribute('a_color'), gl.UNSIGNED_BYTE, true, instanceStrideBytes$1, 24, false, 1)
-            .addAttribute(this._instanceBuffer, this._shader.getAttribute('a_textureSlot'), gl.UNSIGNED_INT, false, instanceStrideBytes$1, 28, true, 1)
-            .addAttribute(this._instanceBuffer, this._shader.getAttribute('a_nodeIndex'), gl.UNSIGNED_INT, false, instanceStrideBytes$1, 32, true, 1)
+            .addAttribute(this._instanceBuffer, this._shader.getAttribute('a_localBounds'), gl.FLOAT, false, instanceStrideBytes$2, 0, false, 1)
+            .addAttribute(this._instanceBuffer, this._shader.getAttribute('a_uvBounds'), gl.UNSIGNED_SHORT, true, instanceStrideBytes$2, 16, false, 1)
+            .addAttribute(this._instanceBuffer, this._shader.getAttribute('a_color'), gl.UNSIGNED_BYTE, true, instanceStrideBytes$2, 24, false, 1)
+            .addAttribute(this._instanceBuffer, this._shader.getAttribute('a_textureSlot'), gl.UNSIGNED_INT, false, instanceStrideBytes$2, 28, true, 1)
+            .addAttribute(this._instanceBuffer, this._shader.getAttribute('a_nodeIndex'), gl.UNSIGNED_INT, false, instanceStrideBytes$2, 32, true, 1)
             .connect(this._createVaoRuntime(this._connection));
         // Pin the per-slot sampler uniforms to texture units 0..N-1.
         const samplerUnit = new Int32Array(1);
@@ -19290,11 +21676,12 @@ class WebGl2SpriteRenderer extends AbstractWebGl2Renderer {
         this._instanceCount++;
     }
     _packInstance(sprite, texture, slot, nodeIndex) {
-        const offset = this._instanceCount * wordsPerInstance$1;
+        const offset = this._instanceCount * wordsPerInstance$2;
         const f32 = this._instanceFloat32;
         const u32 = this._instanceUint32;
-        // localBounds: left, top, right, bottom (offset 0..3)
-        const bounds = sprite.getLocalBounds();
+        // localBounds: left, top, right, bottom (offset 0..3) — device-snapped in
+        // 'geometry' pixel-snap mode, otherwise the logical local bounds.
+        const bounds = this._activeBounds ?? sprite.getLocalBounds();
         f32[offset + 0] = bounds.left;
         f32[offset + 1] = bounds.top;
         f32[offset + 2] = bounds.right;
@@ -21814,6 +24201,902 @@ function collectTextureBindings$1(material) {
     return result;
 }
 
+/// <reference types="@webgpu/types" />
+const nineSliceShaderSource = `
+struct ProjectionUniforms {
+    matrix: mat4x4<f32>,
+};
+
+struct TransformSlot {
+    m0: vec4<f32>,
+    m1: vec4<f32>,
+    m2: vec4<f32>,
+};
+
+@group(0) @binding(0)
+var<uniform> projection: ProjectionUniforms;
+@group(0) @binding(1)
+var<storage, read> transforms: array<TransformSlot>;
+
+@group(1) @binding(0)
+var nineSliceTexture: texture_2d<f32>;
+@group(1) @binding(1)
+var nineSliceSampler: sampler;
+
+struct VertexInput {
+    @location(0) quadBounds: vec4<f32>,   // x0, y0, x1, y1
+    @location(1) uvBounds: vec4<f32>,     // u0, v0, u1, v1 (normalised, flipY pre-applied)
+    @location(2) color: vec4<f32>,        // RGBA tint
+    @location(3) nodeIndex: u32,          // transform buffer row
+};
+
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) texcoord: vec2<f32>,
+    @location(1) color: vec4<f32>,
+};
+
+@vertex
+fn vertexMain(input: VertexInput, @builtin(vertex_index) vid: u32) -> VertexOutput {
+    var output: VertexOutput;
+
+    // vid 0..3 → TL, TR, BR, BL (matches static index buffer [0,1,2,0,2,3])
+    let cornerX = ((vid + 1u) >> 1u) & 1u;
+    let cornerY = vid >> 1u;
+
+    let localX = select(input.quadBounds.x, input.quadBounds.z, cornerX == 1u);
+    let localY = select(input.quadBounds.y, input.quadBounds.w, cornerY == 1u);
+
+    let slot = transforms[input.nodeIndex];
+    let worldX = slot.m0.x * localX + slot.m0.y * localY + slot.m1.x;
+    let worldY = slot.m0.z * localX + slot.m0.w * localY + slot.m1.y;
+
+    output.position = projection.matrix * vec4<f32>(worldX, worldY, 0.0, 1.0);
+
+    let u = select(input.uvBounds.x, input.uvBounds.z, cornerX == 1u);
+    let v = select(input.uvBounds.y, input.uvBounds.w, cornerY == 1u);
+    output.texcoord = vec2<f32>(u, v);
+
+    output.color = vec4(input.color.rgb * input.color.a, input.color.a);
+
+    return output;
+}
+
+@fragment
+fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
+    let sample = textureSample(nineSliceTexture, nineSliceSampler, input.texcoord);
+    return sample * input.color;
+}
+`;
+const instanceStrideBytes$1 = 32;
+const wordsPerInstance$1 = instanceStrideBytes$1 / Uint32Array.BYTES_PER_ELEMENT; // = 8
+const projectionByteLength$2 = 64;
+const initialBatchCapacity$2 = 32;
+const indicesPerInstance$1 = 6;
+const quadIndices$3 = new Uint16Array([0, 1, 2, 0, 2, 3]);
+/** Instanced renderer for {@link NineSliceSprite} using WebGPU. */
+class WebGpuNineSliceSpriteRenderer extends AbstractWebGpuRenderer {
+    _projectionData = new Float32Array(projectionByteLength$2 / Float32Array.BYTES_PER_ELEMENT);
+    _device = null;
+    _shaderModule = null;
+    _uniformBindGroupLayout = null;
+    _textureBindGroupLayout = null;
+    _pipelineLayout = null;
+    _uniformBuffer = null;
+    _transformBindGroup = null;
+    _transformStorageBuffer = null;
+    _indexBuffer = null;
+    _instanceBuffer = null;
+    _instanceCapacity = 0;
+    _instanceData = new ArrayBuffer(0);
+    _instanceFloat32 = new Float32Array(this._instanceData);
+    _instanceUint32 = new Uint32Array(this._instanceData);
+    _pipelines = new Map();
+    _quadIndex = 0;
+    _maxNodeIndex = 0;
+    _currentBlendMode = null;
+    _currentTexture = null;
+    onConnect(backend) {
+        if (this._device) {
+            return;
+        }
+        this._device = backend.device;
+        this._shaderModule = this._device.createShaderModule({ code: nineSliceShaderSource });
+        this._uniformBindGroupLayout = this._device.createBindGroupLayout({
+            entries: [
+                { binding: 0, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform' } },
+                { binding: 1, visibility: GPUShaderStage.VERTEX, buffer: { type: 'read-only-storage' } },
+            ],
+        });
+        this._textureBindGroupLayout = this._device.createBindGroupLayout({
+            entries: [
+                { binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: 'float' } },
+                { binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' } },
+            ],
+        });
+        this._pipelineLayout = this._device.createPipelineLayout({
+            bindGroupLayouts: [this._uniformBindGroupLayout, this._textureBindGroupLayout],
+        });
+        this._uniformBuffer = this._device.createBuffer({
+            size: projectionByteLength$2,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        });
+        this._indexBuffer = this._device.createBuffer({
+            size: quadIndices$3.byteLength,
+            usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
+        });
+        this._device.queue.writeBuffer(this._indexBuffer, 0, quadIndices$3.buffer, quadIndices$3.byteOffset, quadIndices$3.byteLength);
+    }
+    onDisconnect() {
+        this._instanceBuffer?.destroy();
+        this._indexBuffer?.destroy();
+        this._uniformBuffer?.destroy();
+        this._pipelines.clear();
+        this._instanceBuffer = null;
+        this._indexBuffer = null;
+        this._transformBindGroup = null;
+        this._transformStorageBuffer = null;
+        this._uniformBuffer = null;
+        this._pipelineLayout = null;
+        this._textureBindGroupLayout = null;
+        this._uniformBindGroupLayout = null;
+        this._shaderModule = null;
+        this._device = null;
+        this._backend = null;
+        this._instanceCapacity = 0;
+        this._instanceData = new ArrayBuffer(0);
+        this._instanceFloat32 = new Float32Array(this._instanceData);
+        this._instanceUint32 = new Uint32Array(this._instanceData);
+        this._quadIndex = 0;
+        this._maxNodeIndex = 0;
+        this._currentBlendMode = null;
+        this._currentTexture = null;
+    }
+    render(sprite) {
+        const backend = this._backend;
+        if (backend === null) {
+            return;
+        }
+        let quads = sprite.quads;
+        if (sprite.pixelSnapMode === 'geometry') {
+            const snap = backend._getSnapPixelSize();
+            quads = sprite.getRenderQuads(backend.view, snap.width, snap.height);
+        }
+        if (quads.length === 0) {
+            return;
+        }
+        const texture = sprite.texture;
+        if (texture.width === 0 || texture.height === 0) {
+            return;
+        }
+        if (texture instanceof Texture && texture.source === null) {
+            return;
+        }
+        const blendMode = sprite.blendMode;
+        const command = backend.activeDrawCommand;
+        const nodeIndex = command !== null ? command.nodeIndex : backend._pushTransform(sprite);
+        const blendModeChanged = this._currentBlendMode !== null && blendMode !== this._currentBlendMode;
+        const textureChanged = this._currentTexture !== null && texture !== this._currentTexture;
+        const willExceed = this._quadIndex + quads.length > this._instanceCapacity && this._instanceCapacity > 0;
+        if ((blendModeChanged || textureChanged || willExceed) && this._quadIndex > 0) {
+            this.flush();
+        }
+        this._currentBlendMode = blendMode;
+        this._currentTexture = texture;
+        backend.setBlendMode(blendMode);
+        this._ensureInstanceCapacity(this._quadIndex + quads.length);
+        const f32 = this._instanceFloat32;
+        const u32 = this._instanceUint32;
+        const flipY = texture instanceof Texture && texture.flipY;
+        for (const q of quads) {
+            const offset = this._quadIndex * wordsPerInstance$1;
+            f32[offset + 0] = q.x0;
+            f32[offset + 1] = q.y0;
+            f32[offset + 2] = q.x1;
+            f32[offset + 3] = q.y1;
+            const uMin = (q.u0 * 0xffff) & 0xffff;
+            const uMax = (q.u1 * 0xffff) & 0xffff;
+            const v0Raw = (q.v0 * 0xffff) & 0xffff;
+            const v1Raw = (q.v1 * 0xffff) & 0xffff;
+            const vMin = flipY ? v1Raw : v0Raw;
+            const vMax = flipY ? v0Raw : v1Raw;
+            u32[offset + 4] = uMin | (vMin << 16);
+            u32[offset + 5] = uMax | (vMax << 16);
+            u32[offset + 6] = sprite.tint.toRgba();
+            u32[offset + 7] = nodeIndex >>> 0;
+            this._quadIndex++;
+            if (nodeIndex > this._maxNodeIndex) {
+                this._maxNodeIndex = nodeIndex;
+            }
+        }
+    }
+    flush() {
+        const backend = this._backend;
+        const device = this._device;
+        const uniformBuffer = this._uniformBuffer;
+        if (!backend || !device || !uniformBuffer) {
+            return;
+        }
+        if (this._quadIndex === 0 && !backend.clearRequested) {
+            return;
+        }
+        const viewMatrix = backend.view.getTransform();
+        this._projectionData.set([viewMatrix.a, viewMatrix.c, 0, 0, viewMatrix.b, viewMatrix.d, 0, 0, 0, 0, 1, 0, viewMatrix.x, viewMatrix.y, 0, viewMatrix.z]);
+        device.queue.writeBuffer(uniformBuffer, 0, this._projectionData.buffer, this._projectionData.byteOffset, this._projectionData.byteLength);
+        const scissor = backend.getScissorRect();
+        const maskClipsAll = scissor !== null && (scissor.width <= 0 || scissor.height <= 0);
+        const pass = backend._passCoordinator.acquirePass().pass;
+        if (this._quadIndex > 0 && !maskClipsAll && this._instanceBuffer !== null && this._indexBuffer !== null && this._currentBlendMode !== null && this._currentTexture !== null) {
+            device.queue.writeBuffer(this._instanceBuffer, 0, this._instanceData, 0, this._quadIndex * instanceStrideBytes$1);
+            const storage = backend.getTransformStorageBuffer(this._maxNodeIndex + 1);
+            const transformBindGroup = this._getOrCreateTransformBindGroup(device, uniformBuffer, storage.buffer);
+            const textureBindGroup = this._createTextureBindGroup(device, backend, this._currentTexture);
+            const stencil = backend._passCoordinator.stencilActive;
+            const pipeline = this._getPipeline(this._currentBlendMode, backend.renderTargetFormat, stencil);
+            pass.setPipeline(pipeline);
+            pass.setBindGroup(0, transformBindGroup);
+            pass.setBindGroup(1, textureBindGroup);
+            pass.setVertexBuffer(0, this._instanceBuffer);
+            pass.setIndexBuffer(this._indexBuffer, 'uint16');
+            pass.drawIndexed(indicesPerInstance$1, this._quadIndex, 0, 0, 0);
+            backend.stats.batches++;
+            backend.stats.drawCalls++;
+        }
+        backend._passCoordinator.endPass();
+        this._quadIndex = 0;
+        this._maxNodeIndex = 0;
+        this._currentBlendMode = null;
+        this._currentTexture = null;
+    }
+    destroy() {
+        this.disconnect();
+    }
+    _getOrCreateTransformBindGroup(device, uniformBuffer, storageBuffer) {
+        if (this._transformBindGroup !== null && this._transformStorageBuffer === storageBuffer) {
+            return this._transformBindGroup;
+        }
+        this._transformStorageBuffer = storageBuffer;
+        this._transformBindGroup = device.createBindGroup({
+            layout: this._uniformBindGroupLayout,
+            entries: [
+                { binding: 0, resource: { buffer: uniformBuffer } },
+                { binding: 1, resource: { buffer: storageBuffer } },
+            ],
+        });
+        return this._transformBindGroup;
+    }
+    _createTextureBindGroup(device, backend, texture) {
+        const binding = backend.getTextureBinding(texture);
+        return device.createBindGroup({
+            layout: this._textureBindGroupLayout,
+            entries: [
+                { binding: 0, resource: binding.view },
+                { binding: 1, resource: binding.sampler },
+            ],
+        });
+    }
+    _getPipeline(blendMode, format, stencil) {
+        const key = `${blendMode}:${format}:${stencil ? 's' : 'n'}`;
+        const existing = this._pipelines.get(key);
+        if (existing) {
+            return existing;
+        }
+        if (!this._device || !this._shaderModule || !this._pipelineLayout) {
+            throw new Error('WebGpuNineSliceSpriteRenderer: renderer must be connected first.');
+        }
+        const descriptor = {
+            layout: this._pipelineLayout,
+            vertex: {
+                module: this._shaderModule,
+                entryPoint: 'vertexMain',
+                buffers: [
+                    {
+                        arrayStride: instanceStrideBytes$1,
+                        stepMode: 'instance',
+                        attributes: [
+                            { shaderLocation: 0, offset: 0, format: 'float32x4' },
+                            { shaderLocation: 1, offset: 16, format: 'unorm16x4' },
+                            { shaderLocation: 2, offset: 24, format: 'unorm8x4' },
+                            { shaderLocation: 3, offset: 28, format: 'uint32' },
+                        ],
+                    },
+                ],
+            },
+            fragment: {
+                module: this._shaderModule,
+                entryPoint: 'fragmentMain',
+                targets: [
+                    {
+                        format,
+                        blend: getWebGpuBlendState(blendMode),
+                        writeMask: GPUColorWrite.ALL,
+                    },
+                ],
+            },
+            primitive: {
+                topology: 'triangle-list',
+            },
+        };
+        if (stencil) {
+            descriptor.depthStencil = stencilContentDepthStencilState();
+        }
+        const pipeline = this._device.createRenderPipeline(descriptor);
+        this._pipelines.set(key, pipeline);
+        return pipeline;
+    }
+    _ensureInstanceCapacity(instanceCount) {
+        if (!this._device || instanceCount <= this._instanceCapacity) {
+            return;
+        }
+        let nextCapacity = Math.max(this._instanceCapacity, initialBatchCapacity$2);
+        while (nextCapacity < instanceCount) {
+            nextCapacity *= 2;
+        }
+        const oldData = this._instanceData;
+        const carryBytes = Math.min(this._quadIndex * instanceStrideBytes$1, oldData.byteLength);
+        const instanceData = new ArrayBuffer(nextCapacity * instanceStrideBytes$1);
+        if (carryBytes > 0) {
+            new Uint8Array(instanceData).set(new Uint8Array(oldData, 0, carryBytes));
+        }
+        const instanceBuffer = this._device.createBuffer({
+            size: instanceData.byteLength,
+            usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+        });
+        this._instanceBuffer?.destroy();
+        this._instanceCapacity = nextCapacity;
+        this._instanceData = instanceData;
+        this._instanceFloat32 = new Float32Array(instanceData);
+        this._instanceUint32 = new Uint32Array(instanceData);
+        this._instanceBuffer = instanceBuffer;
+    }
+}
+
+/// <reference types="@webgpu/types" />
+// ---------------------------------------------------------------------------
+// Shared WGSL declarations — structs, bindings, and output struct used by
+// both the shader path and the geometry path entry points.
+// ---------------------------------------------------------------------------
+const commonWgsl = `
+struct ProjectionUniforms {
+    matrix: mat4x4<f32>,
+};
+struct TransformSlot {
+    m0: vec4<f32>,
+    m1: vec4<f32>,
+    m2: vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> projection: ProjectionUniforms;
+@group(0) @binding(1) var<storage, read> transforms: array<TransformSlot>;
+@group(1) @binding(0) var spriteTexture: texture_2d<f32>;
+@group(1) @binding(1) var spriteSampler: sampler;
+
+struct VOut {
+    @builtin(position) pos: vec4<f32>,
+    @location(0) uv:    vec2<f32>,
+    @location(1) color: vec4<f32>,
+};
+`;
+// ---------------------------------------------------------------------------
+// Shader path WGSL — one quad per sprite, UVs computed in vertex shader.
+// ---------------------------------------------------------------------------
+const shaderPathEntries = `
+struct ShaderVIn {
+    @location(0) quadBounds: vec4<f32>,  // x0,y0,x1,y1
+    @location(1) uvParams:   vec4<f32>,  // tilingX, tilingY, offsetU, offsetV
+    @location(2) color:      vec4<f32>,  // RGBA tint
+    @location(3) nodeIndex:  u32,
+};
+
+@vertex
+fn shaderVert(input: ShaderVIn, @builtin(vertex_index) vid: u32) -> VOut {
+    var out: VOut;
+    let cx = ((vid + 1u) >> 1u) & 1u;
+    let cy = vid >> 1u;
+    let lx = select(input.quadBounds.x, input.quadBounds.z, cx == 1u);
+    let ly = select(input.quadBounds.y, input.quadBounds.w, cy == 1u);
+
+    let destW = input.quadBounds.z - input.quadBounds.x;
+    let destH = input.quadBounds.w - input.quadBounds.y;
+
+    let slot = transforms[input.nodeIndex];
+    let wx = slot.m0.x * lx + slot.m0.y * ly + slot.m1.x;
+    let wy = slot.m0.z * lx + slot.m0.w * ly + slot.m1.y;
+    out.pos = projection.matrix * vec4<f32>(wx, wy, 0.0, 1.0);
+
+    let u = select(input.uvParams.z, ((lx - input.quadBounds.x) / destW) * input.uvParams.x + input.uvParams.z, destW > 0.0);
+    let v = select(input.uvParams.w, ((ly - input.quadBounds.y) / destH) * input.uvParams.y + input.uvParams.w, destH > 0.0);
+    out.uv    = vec2<f32>(u, v);
+    out.color = vec4<f32>(input.color.rgb * input.color.a, input.color.a);
+    return out;
+}
+
+@fragment
+fn shaderFrag(input: VOut) -> @location(0) vec4<f32> {
+    return textureSample(spriteTexture, spriteSampler, input.uv) * input.color;
+}
+`;
+// ---------------------------------------------------------------------------
+// Geometry path WGSL — N quads per sprite, UVs pre-computed in CPU.
+// ---------------------------------------------------------------------------
+const geoPathEntries = `
+struct GeoVIn {
+    @location(0) quadBounds: vec4<f32>,  // x0,y0,x1,y1
+    @location(1) uvBounds:   vec4<f32>,  // u0,v0,u1,v1 (normalised, flipY pre-applied)
+    @location(2) color:      vec4<f32>,  // RGBA tint
+    @location(3) nodeIndex:  u32,
+};
+
+@vertex
+fn geoVert(input: GeoVIn, @builtin(vertex_index) vid: u32) -> VOut {
+    var out: VOut;
+    let cx = ((vid + 1u) >> 1u) & 1u;
+    let cy = vid >> 1u;
+    let lx = select(input.quadBounds.x, input.quadBounds.z, cx == 1u);
+    let ly = select(input.quadBounds.y, input.quadBounds.w, cy == 1u);
+
+    let slot = transforms[input.nodeIndex];
+    let wx = slot.m0.x * lx + slot.m0.y * ly + slot.m1.x;
+    let wy = slot.m0.z * lx + slot.m0.w * ly + slot.m1.y;
+    out.pos = projection.matrix * vec4<f32>(wx, wy, 0.0, 1.0);
+
+    let u = select(input.uvBounds.x, input.uvBounds.z, cx == 1u);
+    let v = select(input.uvBounds.y, input.uvBounds.w, cy == 1u);
+    out.uv    = vec2<f32>(u, v);
+    out.color = vec4<f32>(input.color.rgb * input.color.a, input.color.a);
+    return out;
+}
+
+@fragment
+fn geoFrag(input: VOut) -> @location(0) vec4<f32> {
+    return textureSample(spriteTexture, spriteSampler, input.uv) * input.color;
+}
+`;
+// ---------------------------------------------------------------------------
+// Layout constants
+// ---------------------------------------------------------------------------
+const shaderStrideBytes = 40; // float32x4 bounds + float32x4 uvParams + unorm8x4 + uint32
+const geoStrideBytes = 32; // float32x4 bounds + unorm16x4 + unorm8x4 + uint32 (NineSlice layout)
+const projectionByteLength$1 = 64;
+const initialBatchCapacity$1 = 32;
+const indicesPerInstance = 6;
+const quadIndices$2 = new Uint16Array([0, 1, 2, 0, 2, 3]);
+// ---------------------------------------------------------------------------
+// Sampler address mode helper
+// ---------------------------------------------------------------------------
+function repeatModeToAddressMode(mode) {
+    if (mode === 'repeat')
+        return 'repeat';
+    if (mode === 'mirror-repeat')
+        return 'mirror-repeat';
+    return 'clamp-to-edge';
+}
+/** Instanced renderer for {@link RepeatingSprite} using WebGPU. */
+class WebGpuRepeatingSpriteRenderer extends AbstractWebGpuRenderer {
+    _projData = new Float32Array(projectionByteLength$1 / Float32Array.BYTES_PER_ELEMENT);
+    // Shared GPU objects
+    _device = null;
+    _uniformBindGroupLayout = null;
+    _textureBindGroupLayout = null;
+    _shaderModule = null;
+    _uniformBuffer = null;
+    _indexBuffer = null;
+    _transformBindGroup = null;
+    _transformStorageBuf = null;
+    _pipelines = new Map();
+    _samplers = new Map();
+    // Shader-path instance buffer
+    _shaderInstBuf = null;
+    _shaderInstCapacity = 0;
+    _shaderInstData = new ArrayBuffer(0);
+    _shaderInstF32 = new Float32Array(this._shaderInstData);
+    _shaderInstU32 = new Uint32Array(this._shaderInstData);
+    _shaderQuadCount = 0;
+    // Geometry-path instance buffer
+    _geoInstBuf = null;
+    _geoInstCapacity = 0;
+    _geoInstData = new ArrayBuffer(0);
+    _geoInstF32 = new Float32Array(this._geoInstData);
+    _geoInstU32 = new Uint32Array(this._geoInstData);
+    _geoQuadCount = 0;
+    // Shared batch state
+    _maxNodeIndex = 0;
+    _currentTexture = null;
+    _currentBlendMode = null;
+    _currentModeX = null;
+    _currentModeY = null;
+    _currentPath = null;
+    // Reusable scratch for device-snapped bounds ('geometry' mode).
+    _snapBounds = new Rectangle();
+    onConnect(backend) {
+        if (this._device)
+            return;
+        const device = backend.device;
+        this._device = device;
+        this._shaderModule = device.createShaderModule({ code: commonWgsl + shaderPathEntries + geoPathEntries });
+        this._uniformBindGroupLayout = device.createBindGroupLayout({
+            entries: [
+                { binding: 0, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform' } },
+                { binding: 1, visibility: GPUShaderStage.VERTEX, buffer: { type: 'read-only-storage' } },
+            ],
+        });
+        this._textureBindGroupLayout = device.createBindGroupLayout({
+            entries: [
+                { binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: 'float' } },
+                { binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' } },
+            ],
+        });
+        this._uniformBuffer = device.createBuffer({
+            size: projectionByteLength$1,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        });
+        this._indexBuffer = device.createBuffer({
+            size: quadIndices$2.byteLength,
+            usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
+        });
+        device.queue.writeBuffer(this._indexBuffer, 0, quadIndices$2.buffer, quadIndices$2.byteOffset, quadIndices$2.byteLength);
+    }
+    onDisconnect() {
+        this._shaderInstBuf?.destroy();
+        this._geoInstBuf?.destroy();
+        this._indexBuffer?.destroy();
+        this._uniformBuffer?.destroy();
+        this._pipelines.clear();
+        this._samplers.clear();
+        this._shaderInstBuf = null;
+        this._geoInstBuf = null;
+        this._indexBuffer = null;
+        this._uniformBuffer = null;
+        this._transformBindGroup = null;
+        this._transformStorageBuf = null;
+        this._textureBindGroupLayout = null;
+        this._uniformBindGroupLayout = null;
+        this._shaderModule = null;
+        this._device = null;
+        this._backend = null;
+        this._shaderInstCapacity = 0;
+        this._shaderInstData = new ArrayBuffer(0);
+        this._shaderInstF32 = new Float32Array(this._shaderInstData);
+        this._shaderInstU32 = new Uint32Array(this._shaderInstData);
+        this._geoInstCapacity = 0;
+        this._geoInstData = new ArrayBuffer(0);
+        this._geoInstF32 = new Float32Array(this._geoInstData);
+        this._geoInstU32 = new Uint32Array(this._geoInstData);
+        this._shaderQuadCount = 0;
+        this._geoQuadCount = 0;
+        this._maxNodeIndex = 0;
+        this._currentTexture = null;
+        this._currentBlendMode = null;
+        this._currentModeX = null;
+        this._currentModeY = null;
+        this._currentPath = null;
+    }
+    render(sprite) {
+        const backend = this._backend;
+        if (!backend)
+            return;
+        const texture = sprite.texture;
+        if (texture instanceof Texture && texture.source === null)
+            return;
+        if (texture.width === 0 || texture.height === 0)
+            return;
+        const strategy = sprite.resolvedStrategy;
+        const blendMode = sprite.blendMode;
+        const modeX = sprite.modeX;
+        const modeY = sprite.modeY;
+        const hasData = this._shaderQuadCount > 0 || this._geoQuadCount > 0;
+        if (hasData) {
+            const pathChanged = this._currentPath !== strategy;
+            const texChanged = this._currentTexture !== texture;
+            const blendChanged = this._currentBlendMode !== blendMode;
+            const modeChanged = strategy === 'shader'
+                && (this._currentModeX !== modeX || this._currentModeY !== modeY);
+            if (pathChanged || texChanged || blendChanged || modeChanged) {
+                this.flush();
+            }
+        }
+        this._currentTexture = texture;
+        this._currentBlendMode = blendMode;
+        this._currentPath = strategy;
+        backend.setBlendMode(blendMode);
+        const command = backend.activeDrawCommand;
+        const nodeIndex = command !== null ? command.nodeIndex : backend._pushTransform(sprite);
+        if (nodeIndex > this._maxNodeIndex)
+            this._maxNodeIndex = nodeIndex;
+        if (strategy === 'shader') {
+            this._currentModeX = modeX;
+            this._currentModeY = modeY;
+            this._writeShaderInstance(sprite, nodeIndex);
+        }
+        else {
+            this._writeGeoQuads(sprite, nodeIndex);
+        }
+    }
+    _writeShaderInstance(sprite, nodeIndex) {
+        const texture = sprite.texture;
+        const srcW = sprite.region.width;
+        const srcH = sprite.region.height;
+        let destW = sprite.width;
+        let destH = sprite.height;
+        const flipY = texture instanceof Texture && texture.flipY;
+        // 'geometry' mode: snap the destination quad to the device grid. Repetition
+        // stays shader-based; only the outer rectangle (and the tiling derived from
+        // it) moves. Position/none leave the destination unchanged.
+        if (sprite.pixelSnapMode === 'geometry') {
+            const backend = this.getBackend();
+            const snap = backend._getSnapPixelSize();
+            const rb = sprite.getRenderBounds(backend.view, snap.width, snap.height, this._snapBounds);
+            destW = rb.width;
+            destH = rb.height;
+        }
+        const tilingX = computeShaderTiling(srcW, destW, sprite.modeX, sprite.fitX);
+        const tilingY = computeShaderTiling(srcH, destH, sprite.modeY, sprite.fitY);
+        const offsetU = sprite.offsetX / (srcW > 0 ? srcW : 1);
+        const offsetV = sprite.offsetY / (srcH > 0 ? srcH : 1);
+        const uvParamY = flipY ? -tilingY : tilingY;
+        const uvParamW = flipY ? tilingY + offsetV : offsetV;
+        this._ensureShaderCapacity(this._shaderQuadCount + 1);
+        const words = shaderStrideBytes / 4;
+        const offset = this._shaderQuadCount * words;
+        const f32 = this._shaderInstF32;
+        const u32 = this._shaderInstU32;
+        f32[offset + 0] = 0;
+        f32[offset + 1] = 0;
+        f32[offset + 2] = destW;
+        f32[offset + 3] = destH;
+        f32[offset + 4] = tilingX;
+        f32[offset + 5] = uvParamY;
+        f32[offset + 6] = offsetU;
+        f32[offset + 7] = uvParamW;
+        u32[offset + 8] = sprite.tint.toRgba();
+        u32[offset + 9] = nodeIndex >>> 0;
+        this._shaderQuadCount++;
+    }
+    _writeGeoQuads(sprite, nodeIndex) {
+        let quads = sprite.quads;
+        // 'geometry' mode: snap shared segment boundaries once (gap-free), like NineSlice.
+        if (sprite.pixelSnapMode === 'geometry') {
+            const backend = this.getBackend();
+            const snap = backend._getSnapPixelSize();
+            quads = sprite.getRenderQuads(backend.view, snap.width, snap.height);
+        }
+        if (quads.length === 0)
+            return;
+        const flipY = (sprite.texture instanceof Texture) && sprite.texture.flipY;
+        const tint = sprite.tint.toRgba();
+        const words = geoStrideBytes / 4;
+        this._ensureGeoCapacity(this._geoQuadCount + quads.length);
+        const f32 = this._geoInstF32;
+        const u32 = this._geoInstU32;
+        for (let i = 0; i < quads.length; i++) {
+            const q = quads[i];
+            const offset = (this._geoQuadCount + i) * words;
+            f32[offset + 0] = q.x0;
+            f32[offset + 1] = q.y0;
+            f32[offset + 2] = q.x1;
+            f32[offset + 3] = q.y1;
+            const uMin = (q.u0 * 0xffff) & 0xffff;
+            const uMax = (q.u1 * 0xffff) & 0xffff;
+            const v0Raw = (q.v0 * 0xffff) & 0xffff;
+            const v1Raw = (q.v1 * 0xffff) & 0xffff;
+            const vMin = flipY ? v1Raw : v0Raw;
+            const vMax = flipY ? v0Raw : v1Raw;
+            u32[offset + 4] = uMin | (vMin << 16);
+            u32[offset + 5] = uMax | (vMax << 16);
+            u32[offset + 6] = tint;
+            u32[offset + 7] = nodeIndex >>> 0;
+        }
+        this._geoQuadCount += quads.length;
+    }
+    flush() {
+        const backend = this._backend;
+        const device = this._device;
+        const uniform = this._uniformBuffer;
+        if (!backend || !device || !uniform)
+            return;
+        if (this._shaderQuadCount === 0 && this._geoQuadCount === 0 && !backend.clearRequested) {
+            return;
+        }
+        const vm = backend.view.getTransform();
+        this._projData.set([vm.a, vm.c, 0, 0, vm.b, vm.d, 0, 0, 0, 0, 1, 0, vm.x, vm.y, 0, vm.z]);
+        device.queue.writeBuffer(uniform, 0, this._projData.buffer, this._projData.byteOffset, this._projData.byteLength);
+        const scissor = backend.getScissorRect();
+        const maskClipsAll = scissor !== null && (scissor.width <= 0 || scissor.height <= 0);
+        const pass = backend._passCoordinator.acquirePass().pass;
+        const stencil = backend._passCoordinator.stencilActive;
+        if (this._shaderQuadCount > 0 && !maskClipsAll) {
+            this._drawShaderBatch(device, backend, pass, stencil);
+        }
+        if (this._geoQuadCount > 0 && !maskClipsAll) {
+            this._drawGeoBatch(device, backend, pass, stencil);
+        }
+        backend._passCoordinator.endPass();
+        this._shaderQuadCount = 0;
+        this._geoQuadCount = 0;
+        this._maxNodeIndex = 0;
+        this._currentTexture = null;
+        this._currentBlendMode = null;
+        this._currentModeX = null;
+        this._currentModeY = null;
+        this._currentPath = null;
+    }
+    _drawShaderBatch(device, backend, pass, stencil) {
+        if (!this._shaderInstBuf || !this._indexBuffer || this._currentBlendMode === null || this._currentTexture === null)
+            return;
+        device.queue.writeBuffer(this._shaderInstBuf, 0, this._shaderInstData, 0, this._shaderQuadCount * shaderStrideBytes);
+        const storage = backend.getTransformStorageBuffer(this._maxNodeIndex + 1);
+        const uniformBindGroup = this._getOrCreateTransformBindGroup(device, this._uniformBuffer, storage.buffer);
+        const modeX = this._currentModeX ?? 'repeat';
+        const modeY = this._currentModeY ?? 'repeat';
+        const sampler = this._getOrCreateSampler(device, modeX, modeY);
+        const texView = backend.getTextureBinding(this._currentTexture).view;
+        const textureBindGroup = device.createBindGroup({
+            layout: this._textureBindGroupLayout,
+            entries: [{ binding: 0, resource: texView }, { binding: 1, resource: sampler }],
+        });
+        const pipeline = this._getPipeline('shader', this._currentBlendMode, backend.renderTargetFormat, stencil);
+        pass.setPipeline(pipeline);
+        pass.setBindGroup(0, uniformBindGroup);
+        pass.setBindGroup(1, textureBindGroup);
+        pass.setVertexBuffer(0, this._shaderInstBuf);
+        pass.setIndexBuffer(this._indexBuffer, 'uint16');
+        pass.drawIndexed(indicesPerInstance, this._shaderQuadCount, 0, 0, 0);
+        backend.stats.batches++;
+        backend.stats.drawCalls++;
+    }
+    _drawGeoBatch(device, backend, pass, stencil) {
+        if (!this._geoInstBuf || !this._indexBuffer || this._currentBlendMode === null || this._currentTexture === null)
+            return;
+        device.queue.writeBuffer(this._geoInstBuf, 0, this._geoInstData, 0, this._geoQuadCount * geoStrideBytes);
+        const storage = backend.getTransformStorageBuffer(this._maxNodeIndex + 1);
+        const uniformBindGroup = this._getOrCreateTransformBindGroup(device, this._uniformBuffer, storage.buffer);
+        // Geometry path: use backend's default (clamp) sampler.
+        const binding = backend.getTextureBinding(this._currentTexture);
+        const textureBindGroup = device.createBindGroup({
+            layout: this._textureBindGroupLayout,
+            entries: [{ binding: 0, resource: binding.view }, { binding: 1, resource: binding.sampler }],
+        });
+        const pipeline = this._getPipeline('geo', this._currentBlendMode, backend.renderTargetFormat, stencil);
+        pass.setPipeline(pipeline);
+        pass.setBindGroup(0, uniformBindGroup);
+        pass.setBindGroup(1, textureBindGroup);
+        pass.setVertexBuffer(0, this._geoInstBuf);
+        pass.setIndexBuffer(this._indexBuffer, 'uint16');
+        pass.drawIndexed(indicesPerInstance, this._geoQuadCount, 0, 0, 0);
+        backend.stats.batches++;
+        backend.stats.drawCalls++;
+    }
+    destroy() {
+        this.disconnect();
+    }
+    // -----------------------------------------------------------------------
+    // Private helpers
+    // -----------------------------------------------------------------------
+    _getOrCreateSampler(device, modeX, modeY) {
+        const key = `${modeX}:${modeY}`;
+        const existing = this._samplers.get(key);
+        if (existing)
+            return existing;
+        const sampler = device.createSampler({
+            addressModeU: repeatModeToAddressMode(modeX),
+            addressModeV: repeatModeToAddressMode(modeY),
+            magFilter: 'linear',
+            minFilter: 'linear',
+        });
+        this._samplers.set(key, sampler);
+        return sampler;
+    }
+    _getOrCreateTransformBindGroup(device, uniformBuf, storageBuf) {
+        if (this._transformBindGroup !== null && this._transformStorageBuf === storageBuf) {
+            return this._transformBindGroup;
+        }
+        this._transformStorageBuf = storageBuf;
+        this._transformBindGroup = device.createBindGroup({
+            layout: this._uniformBindGroupLayout,
+            entries: [
+                { binding: 0, resource: { buffer: uniformBuf } },
+                { binding: 1, resource: { buffer: storageBuf } },
+            ],
+        });
+        return this._transformBindGroup;
+    }
+    _getPipeline(kind, blend, format, stencil) {
+        const key = `${kind}:${blend}:${format}:${stencil ? 's' : 'n'}`;
+        const existing = this._pipelines.get(key);
+        if (existing)
+            return existing;
+        if (!this._device || !this._shaderModule || !this._uniformBindGroupLayout || !this._textureBindGroupLayout) {
+            throw new Error('WebGpuRepeatingSpriteRenderer: not connected.');
+        }
+        const layout = this._device.createPipelineLayout({
+            bindGroupLayouts: [this._uniformBindGroupLayout, this._textureBindGroupLayout],
+        });
+        const isShader = kind === 'shader';
+        const strideBytes = isShader ? shaderStrideBytes : geoStrideBytes;
+        const buffers = isShader
+            ? [{
+                    arrayStride: strideBytes,
+                    stepMode: 'instance',
+                    attributes: [
+                        { shaderLocation: 0, offset: 0, format: 'float32x4' },
+                        { shaderLocation: 1, offset: 16, format: 'float32x4' },
+                        { shaderLocation: 2, offset: 32, format: 'unorm8x4' },
+                        { shaderLocation: 3, offset: 36, format: 'uint32' },
+                    ],
+                }]
+            : [{
+                    arrayStride: strideBytes,
+                    stepMode: 'instance',
+                    attributes: [
+                        { shaderLocation: 0, offset: 0, format: 'float32x4' },
+                        { shaderLocation: 1, offset: 16, format: 'unorm16x4' },
+                        { shaderLocation: 2, offset: 24, format: 'unorm8x4' },
+                        { shaderLocation: 3, offset: 28, format: 'uint32' },
+                    ],
+                }];
+        const desc = {
+            layout,
+            vertex: {
+                module: this._shaderModule,
+                entryPoint: isShader ? 'shaderVert' : 'geoVert',
+                buffers,
+            },
+            fragment: {
+                module: this._shaderModule,
+                entryPoint: isShader ? 'shaderFrag' : 'geoFrag',
+                targets: [{ format, blend: getWebGpuBlendState(blend), writeMask: GPUColorWrite.ALL }],
+            },
+            primitive: { topology: 'triangle-list' },
+        };
+        if (stencil) {
+            desc.depthStencil = stencilContentDepthStencilState();
+        }
+        const pipeline = this._device.createRenderPipeline(desc);
+        this._pipelines.set(key, pipeline);
+        return pipeline;
+    }
+    _ensureShaderCapacity(needed) {
+        if (!this._device || needed <= this._shaderInstCapacity)
+            return;
+        this._shaderInstCapacity = this._growCapacity(this._shaderInstCapacity, needed);
+        const oldData = this._shaderInstData;
+        const carry = this._shaderQuadCount * shaderStrideBytes;
+        this._shaderInstData = new ArrayBuffer(this._shaderInstCapacity * shaderStrideBytes);
+        if (carry > 0)
+            new Uint8Array(this._shaderInstData).set(new Uint8Array(oldData, 0, carry));
+        this._shaderInstF32 = new Float32Array(this._shaderInstData);
+        this._shaderInstU32 = new Uint32Array(this._shaderInstData);
+        this._shaderInstBuf?.destroy();
+        this._shaderInstBuf = this._device.createBuffer({
+            size: this._shaderInstData.byteLength,
+            usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+        });
+    }
+    _ensureGeoCapacity(needed) {
+        if (!this._device || needed <= this._geoInstCapacity)
+            return;
+        this._geoInstCapacity = this._growCapacity(this._geoInstCapacity, needed);
+        const oldData = this._geoInstData;
+        const carry = this._geoQuadCount * geoStrideBytes;
+        this._geoInstData = new ArrayBuffer(this._geoInstCapacity * geoStrideBytes);
+        if (carry > 0)
+            new Uint8Array(this._geoInstData).set(new Uint8Array(oldData, 0, carry));
+        this._geoInstF32 = new Float32Array(this._geoInstData);
+        this._geoInstU32 = new Uint32Array(this._geoInstData);
+        this._geoInstBuf?.destroy();
+        this._geoInstBuf = this._device.createBuffer({
+            size: this._geoInstData.byteLength,
+            usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+        });
+    }
+    _growCapacity(current, needed) {
+        let cap = Math.max(current, initialBatchCapacity$1);
+        while (cap < needed)
+            cap *= 2;
+        return cap;
+    }
+}
+
 /// <reference types="@webgpu/types" />
 const spriteShaderSource = `
 struct ProjectionUniforms {
@@ -22006,6 +25289,10 @@ class WebGpuSpriteRenderer extends AbstractWebGpuRenderer {
     _customBaseTextureLayout = null;
     _currentMaterial = null;
     _currentBaseTexture = null;
+    // Reusable scratch for device-snapped local bounds ('geometry' mode), and the
+    // bounds resolved for the sprite currently being packed (snapped or logical).
+    _snapBounds = new Rectangle();
+    _activeBounds = null;
     onConnect(backend) {
         if (this._device) {
             return;
@@ -22126,6 +25413,7 @@ class WebGpuSpriteRenderer extends AbstractWebGpuRenderer {
         // sprite's transform into the buffer and use the freshly-allocated slot.
         const command = backend.activeDrawCommand;
         const nodeIndex = command !== null ? command.nodeIndex : backend._pushTransform(sprite);
+        this._activeBounds = this._resolveBounds(sprite, backend);
         if (material === null) {
             this._renderDefault(sprite, texture, backend, nodeIndex);
         }
@@ -22133,6 +25421,19 @@ class WebGpuSpriteRenderer extends AbstractWebGpuRenderer {
             this._renderCustom(sprite, texture, material, backend, nodeIndex);
         }
     }
+    /**
+     * Local bounds to upload for `sprite` this draw: device-pixel-snapped in
+     * `'geometry'` pixel-snap mode (axis-aligned only), otherwise the sprite's
+     * logical local bounds. Reuses a scratch rectangle and never mutates logical
+     * state. Consumed synchronously by {@link _packInstance}.
+     */
+    _resolveBounds(sprite, backend) {
+        if (sprite.pixelSnapMode !== 'geometry') {
+            return sprite.getLocalBounds();
+        }
+        const snap = backend._getSnapPixelSize();
+        return sprite.getRenderBounds(backend.view, snap.width, snap.height, this._snapBounds);
+    }
     /** Default multi-texture path: rotate the base texture through 8 slots. */
     _renderDefault(sprite, texture, backend, nodeIndex) {
         const blendMode = sprite.blendMode;
@@ -22311,8 +25612,9 @@ class WebGpuSpriteRenderer extends AbstractWebGpuRenderer {
         const offset = this._instanceCount * wordsPerInstance;
         const f32 = this._instanceFloat32;
         const u32 = this._instanceUint32;
-        // localBounds: left, top, right, bottom (words 0..3, offset 0)
-        const bounds = sprite.getLocalBounds();
+        // localBounds: left, top, right, bottom (words 0..3, offset 0) — device-snapped in
+        // 'geometry' pixel-snap mode, otherwise the logical local bounds.
+        const bounds = this._activeBounds ?? sprite.getLocalBounds();
         f32[offset + 0] = bounds.left;
         f32[offset + 1] = bounds.top;
         f32[offset + 2] = bounds.right;
@@ -23507,6 +26809,14 @@ function buildCoreRendererBindings(options) {
         [RenderBackendType.WebGl2]: () => new WebGl2TextRenderer(),
         [RenderBackendType.WebGpu]: () => new WebGpuTextRenderer(),
     };
+    const nineSliceRenderers = {
+        [RenderBackendType.WebGl2]: () => new WebGl2NineSliceSpriteRenderer(spriteRendererBatchSize),
+        [RenderBackendType.WebGpu]: () => new WebGpuNineSliceSpriteRenderer(),
+    };
+    const repeatingSpriteRenderers = {
+        [RenderBackendType.WebGl2]: () => new WebGl2RepeatingSpriteRenderer(spriteRendererBatchSize),
+        [RenderBackendType.WebGpu]: () => new WebGpuRepeatingSpriteRenderer(),
+    };
     return [
         {
             targets: [Sprite],
@@ -23521,6 +26831,14 @@ function buildCoreRendererBindings(options) {
             targets: [Text, BitmapText],
             create: backend => textRenderers[backend.backendType]?.(),
         },
+        {
+            targets: [NineSliceSprite],
+            create: backend => nineSliceRenderers[backend.backendType]?.(),
+        },
+        {
+            targets: [RepeatingSprite],
+            create: backend => repeatingSpriteRenderers[backend.backendType]?.(),
+        },
     ];
 }
 
@@ -24551,6 +27869,7 @@ class WebGl2Backend {
     _canvas;
     _contextLost;
     _renderTarget;
+    _snapTransform = new Matrix();
     _renderer = null;
     _shader = null;
     _blendMode = null;
@@ -24680,7 +27999,34 @@ class WebGl2Backend {
      */
     _writeTransformCommand(command) {
         const drawable = command.drawable;
-        this._transformBuffer.write(command.nodeIndex, drawable.getGlobalTransform(), drawable.tint);
+        this._transformBuffer.write(command.nodeIndex, this._resolveSnapTransform(drawable), drawable.tint);
+    }
+    /**
+     * Resolve the world transform to upload for `drawable`, applying render-only
+     * pixel snapping against the active render target's device-pixel grid when the
+     * drawable opts in. Returns the live (unsnapped) global transform for the
+     * `'none'` default; never mutates logical state.
+     * @internal
+     */
+    _resolveSnapTransform(drawable) {
+        const target = this._renderTarget;
+        const width = target.root ? this._canvas.width : target.width;
+        const height = target.root ? this._canvas.height : target.height;
+        return resolveUploadTransform(drawable, target.view, width, height, this._snapTransform);
+    }
+    /**
+     * Device-pixel dimensions of the active render target — `canvas.width/height`
+     * (css × pixelRatio) for the root, or the target's own size for an offscreen
+     * {@link RenderTexture}. Used by batched renderers to snap shared geometry
+     * boundaries to the same device grid the transform seam snaps the origin to.
+     * @internal
+     */
+    _getSnapPixelSize() {
+        const target = this._renderTarget;
+        return {
+            width: target.root ? this._canvas.width : target.width,
+            height: target.root ? this._canvas.height : target.height,
+        };
     }
     /**
      * Append a drawable's world transform (+ tint) to the shared transform buffer
@@ -24693,7 +28039,7 @@ class WebGl2Backend {
      * @internal
      */
     _pushTransform(drawable) {
-        return this._transformBuffer.push(drawable.getGlobalTransform(), drawable.tint);
+        return this._transformBuffer.push(this._resolveSnapTransform(drawable), drawable.tint);
     }
     /** @internal */
     _endDrawPlan() {
@@ -26033,9 +29379,9 @@ class WebGpuTransformStorage {
     begin(nodeCount) {
         this._buffer.begin(nodeCount);
     }
-    writeCommand(command) {
+    writeCommand(command, transform) {
         const drawable = command.drawable;
-        this._buffer.write(command.nodeIndex, drawable.getGlobalTransform(), drawable.tint);
+        this._buffer.write(command.nodeIndex, transform ?? drawable.getGlobalTransform(), drawable.tint);
     }
     /**
      * Record that a draw command's transform write was skipped because its
@@ -26051,8 +29397,8 @@ class WebGpuTransformStorage {
      * `nodeIndex` — a direct `backend.draw(drawable)` outside the plan player —
      * so a batch of synthetic draws does not collide on a single row.
      */
-    push(drawable) {
-        return this._buffer.push(drawable.getGlobalTransform(), drawable.tint);
+    push(drawable, transform) {
+        return this._buffer.push(transform ?? drawable.getGlobalTransform(), drawable.tint);
     }
     /**
      * Pre-allocate (or grow) the GPU storage buffer to hold at least
@@ -26170,6 +29516,7 @@ class WebGpuBackend {
     _format = null;
     _initializePromise = null;
     _renderTarget;
+    _snapTransform = new Matrix();
     _renderer = null;
     _texture = null;
     _clearRequested = false;
@@ -26291,7 +29638,7 @@ class WebGpuBackend {
         for (let i = 0; i < instructions.length; i++) {
             const command = instructions[i];
             if (drawCommandUsesSharedTransform(command, this)) {
-                storage.writeCommand(command);
+                storage.writeCommand(command, this._resolveSnapTransform(command.drawable));
             }
             else {
                 storage.recordSkippedWrite();
@@ -26626,7 +29973,31 @@ class WebGpuBackend {
      * @internal
      */
     _pushTransform(drawable) {
-        return this._getTransformStorage().push(drawable);
+        return this._getTransformStorage().push(drawable, this._resolveSnapTransform(drawable));
+    }
+    /**
+     * Resolve the world transform to upload for `drawable`, applying render-only
+     * pixel snapping against the active render target's device-pixel grid when the
+     * drawable opts in. Returns the live (unsnapped) global transform for the
+     * `'none'` default; never mutates logical state.
+     * @internal
+     */
+    _resolveSnapTransform(drawable) {
+        const target = this._renderTarget;
+        const root = target === this._rootRenderTarget;
+        const width = root ? this._canvas.width : target.width;
+        const height = root ? this._canvas.height : target.height;
+        return resolveUploadTransform(drawable, target.view, width, height, this._snapTransform);
+    }
+    /**
+     * Device-pixel dimensions of the active render target — `canvas.width/height`
+     * (css × pixelRatio) for the root, or the target's own size for an offscreen
+     * {@link RenderTexture}. Used by batched renderers to snap shared geometry
+     * boundaries to the same device grid the transform seam snaps the origin to.
+     * @internal
+     */
+    _getSnapPixelSize() {
+        return this._getAttachmentPixelSize(this._renderTarget);
     }
     _setActiveRenderer(renderer) {
         if (this._renderer !== renderer) {
@@ -29736,6 +33107,10 @@ class Loader {
      * Atomically bind all keys for one AssetBinding to a pre-created handler.
      * Validates all keys BEFORE mutating any map. Any already-registered key
      * throws before any mutation (no override in 0.12).
+     *
+     * `Result` and `Options` are inferred from the binding's `AssetBinding<Result, Options>`
+     * contract. A declarative handler's optional `getIdentityKey` is forwarded into
+     * the internal {@link HandlerEntry} so it participates in in-flight deduplication.
      * @internal
      */
     bindAsset(keys, handler) {
@@ -29768,17 +33143,30 @@ class Loader {
             }
         }
         // All validation passed — install atomically.
-        // Internally the loader builds a flat config `{ source, ...fields }` (the
-        // shape the advanced `registerAssetType` handler form receives). Extension
-        // AssetHandlers are typed against the public `AssetLoadRequest`
-        // (`{ source, options? }`), so reshape the flat config here: pull `source`
-        // out and nest the remaining per-load fields under `options`.
+        //
+        // Localized type-erasure boundary: the internal Loader uses a flat config
+        // `{ source, ...fields }`. The public AssetHandler<Result, Options> interface
+        // uses `AssetLoadRequest<Options> = { source, options? }`. This single `toRequest`
+        // helper is the only place where the erased flat config is cast to the typed
+        // request — justified by the `AssetBinding<Result, Options>` contract that
+        // associates this handler's Options with the registered constructor.
+        //
+        // `options` is intentionally omitted (not set to `undefined`) when the flat
+        // config carries no extra fields, keeping the object compatible with a future
+        // `exactOptionalPropertyTypes` migration.
+        const toRequest = (config) => {
+            const { source, ...rest } = config;
+            if (Object.keys(rest).length === 0) {
+                return { source };
+            }
+            return { source, options: rest };
+        };
+        const boundIdentityKey = handler.getIdentityKey?.bind(handler);
         this._handlerFunctions.set(keys.type, {
-            load: (config, ctx) => {
-                const { source, ...rest } = config;
-                const options = Object.keys(rest).length > 0 ? rest : undefined;
-                return handler.load({ source, options }, ctx);
-            },
+            load: (config, ctx) => handler.load(toRequest(config), ctx),
+            getIdentityKey: boundIdentityKey
+                ? (config) => boundIdentityKey(toRequest(config))
+                : undefined,
         });
         for (const name of resolvedNames) {
             this._assetTypeMap.set(name, keys.type);
@@ -29786,7 +33174,9 @@ class Loader {
         for (const ext of normalizedExts) {
             this._extensionMap.set(ext, keys.type);
         }
-        // Own this handler for lifecycle management
+        // Own this handler for lifecycle management.
+        // Cast to the erased AssetHandler for storage; destroy() is the only method
+        // called on entries in this array.
         this._boundHandlers.push(handler);
     }
     /**
@@ -31642,8 +35032,8 @@ class Application {
 }
 
 const buildInfo = Object.freeze({
-    version: "0.12.0",
-    revision: "599bc56",
+    version: "0.13.0",
+    revision: "735089b",
     development: false,
 });
 
@@ -37552,5 +40942,5 @@ class TextFactory extends AbstractAssetFactory {
     }
 }
 
-export { AbstractAssetFactory, AbstractMedia, AbstractText, AbstractWebGl2BatchedRenderer, AbstractWebGl2Renderer, AbstractWebGpuRenderer, AnimatedSprite, Application, ApplicationStatus, ArcadeStickGamepadMapping, Asset, AssetImpl, Assets, AssetsImpl, AtlasPage, AudioAnalyser, AudioBus, AudioFilter, AudioListener, AudioManager, BeatDetector, BinaryAsset, BinaryFactory, BitmapText, BlendModes, BlurFilter, BmFont, BmFontAdapter, BmFontLoaderFactory, Bounds, BufferTypes, BufferUsage, BundleLoadError, CacheFirstStrategy, CallbackRenderPass, Camera, Capabilities, ChannelOffset, ChannelSize, ChorusFilter, Circle, Clock, CollisionType, Color, ColorFilter, CompressorFilter, Container, CsvAsset, CsvFactory, DataTexture, DelayFilter, Drawable, DuckingFilter, Ease, Ellipse, Envelope, EqualizerFilter, FactoryRegistry, Filter, Flags, FontAsset, FontFactory, GameCubeGamepadMapping, Gamepad, GamepadAxis, GamepadButton, GamepadMapping, GamepadMappingFamily, GamepadPromptLayouts, GenericDualAnalogGamepadMapping, Geometry, GlyphAtlas, GlyphAtlasPool, Gradient, GranularFilter, Graphics, HTMLText, HighpassFilter, ImageAsset, ImageFactory, IndexedDbDatabase, IndexedDbStore, InputBinding, InputManager, InteractionEvent, InteractionManager, Interval, JoyConLeftGamepadMapping, JoyConRightGamepadMapping, Json, JsonFactory, JsonStore, Keyboard, Line, LinearGradient, Loader, LoadingQueue, LowpassFilter, LutFilter, Material, Matrix, Mesh, MeshMaterial, Music, MusicFactory, NetworkOnlyStrategy, ObservableSize, ObservableVector, OscillatorSound, PitchShiftFilter, PlayStationGamepadMapping, Pointer, PointerState, PointerStateFlag, PolarVector, Polygon, Quadtree, RadialGradient, Random, Rectangle, RenderBackendType, RenderNode, RenderNodePass, RenderPass, RenderPipeline, RenderTarget, RenderTexture, RendererRegistry, RenderingContext, RenderingPrimitives, ReverbFilter, SDF_RADIUS, Sampler, ScaleModes, Scene, SceneManager, SceneNode, Segment, Shader, ShaderAttribute, ShaderPrimitives, ShaderSource, ShaderUniform, Signal, Size, Sound, SoundFactory, SoundPoolStrategy, Sprite, SpriteFlags, SpriteMaterial, Spritesheet, SteamControllerGamepadMapping, SteamDeckGamepadMapping, SubtitleAsset, SubtitleFactory, SvgAsset, SvgFactory, SwitchProGamepadMapping, Text, TextAsset, TextFactory, TextStyle, Texture, TextureFactory, Time, Timer, Tween, TweenManager, TweenState, Vector, Video, VideoFactory, View, ViewFlags, VocoderFilter, VoronoiRegion, WasmAsset, WasmFactory, WebGl2Backend, WebGl2MeshRenderer, WebGl2RenderBuffer, WebGl2ShaderBlock, WebGl2ShaderFilter, WebGl2SpriteRenderer, WebGl2TextRenderer, WebGl2VertexArrayObject, WebGpuBackend, WebGpuComputePipeline, WebGpuMeshRenderer, WebGpuShaderFilter, WebGpuSpriteRenderer, WebGpuStorageBuffer, WebGpuTextRenderer, WorkletFilter, WrapModes, XboxGamepadMapping, XmlAsset, XmlFactory, bezierCurveTo, buildCircle, buildEllipse, buildInfo, buildLine, buildPath, buildPolygon, buildRectangle, buildStar, buildTextPageQuads, builtInGamepadDefinitions, canvasSourceToDataUrl, clamp, createRenderStats, createWebGl2ShaderProgram, crossFade, decodeAudioData, defineAssetManifest, degreesPerRadian, degreesToRadians, determineMimeType, disposeAudioManager, emptyArrayBuffer, getAudioContext, getAudioManager, getCanvasSourceSize, getCollisionCircleCircle, getCollisionCircleRectangle, getCollisionEllipseCircle, getCollisionEllipseEllipse, getCollisionEllipseRectangle, getCollisionPolygonCircle, getCollisionRectangleRectangle, getCollisionSat, getDefaultGlyphAtlasPool, getDistance, getOfflineAudioContext, getPreciseTime, getTextureSourceSize, getVoronoiRegion$1 as getVoronoiRegion, getWebGpuBlendState, hours, inRange, intersectionCircleCircle, intersectionCircleEllipse, intersectionCirclePoly, intersectionEllipseEllipse, intersectionEllipsePoly, intersectionLineCircle, intersectionLineEllipse, intersectionLineLine, intersectionLinePoly, intersectionLineRect, intersectionPointCircle, intersectionPointEllipse, intersectionPointLine, intersectionPointPoint, intersectionPointPoly, intersectionPointRect, intersectionPolyPoly, intersectionRectCircle, intersectionRectEllipse, intersectionRectPoly, intersectionRectRect, intersectionSat, isAudioContextReady, isPowerOfTwo, layoutText, lerp, matchesIds, maxPointers, measureText, milliseconds, minutes, noop$1 as noop, onAudioContextReady, parseBmFontText, parseGamepadDescriptor, perfClearMarks, perfClearMeasures, perfMark, perfMeasure, pointerSlotSize, quadraticCurveTo, radiansPerDegree, radiansToDegrees, rand, registerAudioWorkletProcessor, removeArrayItems, resetDefaultGlyphAtlasPool, resetRenderStats, resolveDefinition, resolveGamepadDefinition, seconds, sign, stopEvent, substepSweep, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio, sweepCircleAgainst, sweepCircleVsCircle, sweepCircleVsRectangle, sweepRectangle, sweepRectangleAgainst, tau, trimRotation, upgradeFragmentShaderToGl300, vibrate, webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl2PrimitiveTypeNames };
+export { AbstractAssetFactory, AbstractMedia, AbstractText, AbstractWebGl2BatchedRenderer, AbstractWebGl2Renderer, AbstractWebGpuRenderer, AnimatedSprite, Application, ApplicationStatus, ArcadeStickGamepadMapping, Asset, AssetImpl, Assets, AssetsImpl, AtlasPage, AudioAnalyser, AudioBus, AudioFilter, AudioListener, AudioManager, BeatDetector, BinaryAsset, BinaryFactory, BitmapText, BlendModes, BlurFilter, BmFont, BmFontAdapter, BmFontLoaderFactory, Bounds, BufferTypes, BufferUsage, BundleLoadError, CacheFirstStrategy, CallbackRenderPass, Camera, Capabilities, ChannelOffset, ChannelSize, ChorusFilter, Circle, Clock, CollisionType, Color, ColorFilter, CompressorFilter, Container, CsvAsset, CsvFactory, DataTexture, DelayFilter, Drawable, DuckingFilter, Ease, Ellipse, Envelope, EqualizerFilter, FactoryRegistry, Filter, Flags, FontAsset, FontFactory, GameCubeGamepadMapping, Gamepad, GamepadAxis, GamepadButton, GamepadMapping, GamepadMappingFamily, GamepadPromptLayouts, GenericDualAnalogGamepadMapping, Geometry, GlyphAtlas, GlyphAtlasPool, Gradient, GranularFilter, Graphics, HTMLText, HighpassFilter, ImageAsset, ImageFactory, IndexedDbDatabase, IndexedDbStore, InputBinding, InputManager, InteractionEvent, InteractionManager, Interval, JoyConLeftGamepadMapping, JoyConRightGamepadMapping, Json, JsonFactory, JsonStore, Keyboard, Line, LinearGradient, Loader, LoadingQueue, LowpassFilter, LutFilter, Material, Matrix, Mesh, MeshMaterial, Music, MusicFactory, NetworkOnlyStrategy, NineSliceSprite, ObservableSize, ObservableVector, OscillatorSound, PitchShiftFilter, PlayStationGamepadMapping, Pointer, PointerState, PointerStateFlag, PolarVector, Polygon, Quadtree, RadialGradient, Random, Rectangle, RenderBackendType, RenderNode, RenderNodePass, RenderPass, RenderPipeline, RenderTarget, RenderTexture, RendererRegistry, RenderingContext, RenderingPrimitives, RepeatingSprite, ReverbFilter, SDF_RADIUS, Sampler, ScaleModes, Scene, SceneManager, SceneNode, Segment, Shader, ShaderAttribute, ShaderPrimitives, ShaderSource, ShaderUniform, Signal, Size, Sound, SoundFactory, SoundPoolStrategy, Sprite, SpriteFlags, SpriteMaterial, Spritesheet, SteamControllerGamepadMapping, SteamDeckGamepadMapping, SubtitleAsset, SubtitleFactory, SvgAsset, SvgFactory, SwitchProGamepadMapping, Text, TextAsset, TextFactory, TextStyle, Texture, TextureFactory, TextureRegion, Time, Timer, Tween, TweenManager, TweenState, Vector, Video, VideoFactory, View, ViewFlags, VocoderFilter, VoronoiRegion, WasmAsset, WasmFactory, WebGl2Backend, WebGl2MeshRenderer, WebGl2NineSliceSpriteRenderer, WebGl2RenderBuffer, WebGl2RepeatingSpriteRenderer, WebGl2ShaderBlock, WebGl2ShaderFilter, WebGl2SpriteRenderer, WebGl2TextRenderer, WebGl2VertexArrayObject, WebGpuBackend, WebGpuComputePipeline, WebGpuMeshRenderer, WebGpuNineSliceSpriteRenderer, WebGpuRepeatingSpriteRenderer, WebGpuShaderFilter, WebGpuSpriteRenderer, WebGpuStorageBuffer, WebGpuTextRenderer, WorkletFilter, WrapModes, XboxGamepadMapping, XmlAsset, XmlFactory, bezierCurveTo, buildCircle, buildEllipse, buildInfo, buildLine, buildPath, buildPolygon, buildRectangle, buildStar, buildTextPageQuads, builtInGamepadDefinitions, canvasSourceToDataUrl, clamp, createRenderStats, createWebGl2ShaderProgram, crossFade, decodeAudioData, defineAssetManifest, degreesPerRadian, degreesToRadians, determineMimeType, disposeAudioManager, emptyArrayBuffer, getAudioContext, getAudioManager, getCanvasSourceSize, getCollisionCircleCircle, getCollisionCircleRectangle, getCollisionEllipseCircle, getCollisionEllipseEllipse, getCollisionEllipseRectangle, getCollisionPolygonCircle, getCollisionRectangleRectangle, getCollisionSat, getDefaultGlyphAtlasPool, getDistance, getOfflineAudioContext, getPreciseTime, getTextureSourceSize, getVoronoiRegion$1 as getVoronoiRegion, getWebGpuBlendState, hours, inRange, intersectionCircleCircle, intersectionCircleEllipse, intersectionCirclePoly, intersectionEllipseEllipse, intersectionEllipsePoly, intersectionLineCircle, intersectionLineEllipse, intersectionLineLine, intersectionLinePoly, intersectionLineRect, intersectionPointCircle, intersectionPointEllipse, intersectionPointLine, intersectionPointPoint, intersectionPointPoly, intersectionPointRect, intersectionPolyPoly, intersectionRectCircle, intersectionRectEllipse, intersectionRectPoly, intersectionRectRect, intersectionSat, isAudioContextReady, isPowerOfTwo, layoutText, lerp, matchesIds, maxPointers, measureText, milliseconds, minutes, noop$1 as noop, onAudioContextReady, parseBmFontText, parseGamepadDescriptor, perfClearMarks, perfClearMeasures, perfMark, perfMeasure, planRepeat, pointerSlotSize, quadraticCurveTo, radiansPerDegree, radiansToDegrees, rand, registerAudioWorkletProcessor, removeArrayItems, resetDefaultGlyphAtlasPool, resetRenderStats, resolveDefinition, resolveGamepadDefinition, seconds, sign, stopEvent, substepSweep, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio, sweepCircleAgainst, sweepCircleVsCircle, sweepCircleVsRectangle, sweepRectangle, sweepRectangleAgainst, tau, trimRotation, upgradeFragmentShaderToGl300, vibrate, webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl2PrimitiveTypeNames };
 //# sourceMappingURL=exo.esm.js.map