@expofp/renderer 3.35.0 → 3.35.1

package/dist/core/SquareDataTexture.d.ts

@@ -91,8 +91,8 @@ export declare function getSquareTextureInfo(arrayType: TypedArrayConstructor, c
  * 2. **The index varying is always `float`**, so `getUniformsGLSL` no longer takes an index type.
  *    It follows from the first: GLSL ES 3.00 requires integer varyings to be `flat`, so an index
  *    that is not float could not have the qualifier removed. **Callers must therefore hand it a float
- *    index** — `BatchedMeshExt` does, from three's own `getIndirectIndex( gl_DrawID )`, and
- *    `InstancedMeshExt` does, from the float index texture that replaced upstream's `uint` attribute.
+ *    index** — `BatchedMeshImpl` does, from three's own `getIndirectIndex( gl_DrawID )`, and
+ *    `InstancedMeshImpl` does, from the float index texture that replaced upstream's `uint` attribute.
  * 3. **`clone` and `copy` produce an independent texture.** See each method.
  */
 export declare class SquareDataTexture extends DataTexture {

package/dist/core/SquareDataTexture.js

@@ -68,8 +68,8 @@ export function getSquareTextureInfo(arrayType, channels, pixelsPerInstance, cap
  * 2. **The index varying is always `float`**, so `getUniformsGLSL` no longer takes an index type.
  *    It follows from the first: GLSL ES 3.00 requires integer varyings to be `flat`, so an index
  *    that is not float could not have the qualifier removed. **Callers must therefore hand it a float
- *    index** — `BatchedMeshExt` does, from three's own `getIndirectIndex( gl_DrawID )`, and
- *    `InstancedMeshExt` does, from the float index texture that replaced upstream's `uint` attribute.
+ *    index** — `BatchedMeshImpl` does, from three's own `getIndirectIndex( gl_DrawID )`, and
+ *    `InstancedMeshImpl` does, from the float index texture that replaced upstream's `uint` attribute.
  * 3. **`clone` and `copy` produce an independent texture.** See each method.
  */
 export class SquareDataTexture extends DataTexture {

package/dist/core/batch/BatchedMesh.d.ts

@@ -19,8 +19,8 @@ import { type UniformValue, type UniformValueObj } from '../SquareDataTexture';
  * - **Bounds invalidate themselves.** Every mutation that can move the mesh's extents nulls the
  *   cached bounds, so callers cannot forget; three's frustum test recomputes a null one on demand.
  */
-export declare class BatchedMeshExt extends BatchedMeshBase {
-    /** Per-instance uniform store, shared with {@link InstancedMeshExt}. */
+export declare class BatchedMeshImpl extends BatchedMeshBase {
+    /** Per-instance uniform store, shared with {@link InstancedMeshImpl}. */
     private readonly uniforms;
     /** The material whose `onBeforeCompile` is already wrapped, so it is wrapped exactly once. */
     private patchedMaterial;
@@ -70,5 +70,5 @@ export declare class BatchedMeshExt extends BatchedMeshBase {
  * Registers the class as an R3F element, by value so the generated key cannot collide with the
  * `BatchedMesh` three already puts in the catalog when the canvas mounts.
  */
-export declare const BatchedMesh: import("react").ExoticComponent<import("@react-three/fiber/dist/declarations/src/core/utils").Mutable<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<Partial<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<BatchedMeshExt, import("@react-three/fiber").MathProps<BatchedMeshExt> & import("@react-three/fiber").ReactProps<BatchedMeshExt> & Partial<import("@react-three/fiber").EventHandlers>>>, Omit<import("@react-three/fiber").InstanceProps<BatchedMeshExt, typeof BatchedMeshExt>, "object">>>>;
+export declare const BatchedMesh: import("react").ExoticComponent<import("@react-three/fiber/dist/declarations/src/core/utils").Mutable<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<Partial<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<BatchedMeshImpl, import("@react-three/fiber").MathProps<BatchedMeshImpl> & import("@react-three/fiber").ReactProps<BatchedMeshImpl> & Partial<import("@react-three/fiber").EventHandlers>>>, Omit<import("@react-three/fiber").InstanceProps<BatchedMeshImpl, typeof BatchedMeshImpl>, "object">>>>;
 //# sourceMappingURL=BatchedMesh.d.ts.map

package/dist/core/batch/BatchedMesh.js

@@ -20,8 +20,8 @@ import { openMain } from '../shader-source';
  * - **Bounds invalidate themselves.** Every mutation that can move the mesh's extents nulls the
  *   cached bounds, so callers cannot forget; three's frustum test recomputes a null one on demand.
  */
-export class BatchedMeshExt extends BatchedMeshBase {
-    /** Per-instance uniform store, shared with {@link InstancedMeshExt}. */
+export class BatchedMeshImpl extends BatchedMeshBase {
+    /** Per-instance uniform store, shared with {@link InstancedMeshImpl}. */
     uniforms = new InstanceUniforms();
     /** The material whose `onBeforeCompile` is already wrapped, so it is wrapped exactly once. */
     patchedMaterial = null;
@@ -146,4 +146,4 @@ export class BatchedMeshExt extends BatchedMeshBase {
  * Registers the class as an R3F element, by value so the generated key cannot collide with the
  * `BatchedMesh` three already puts in the catalog when the canvas mounts.
  */
-export const BatchedMesh = extend(BatchedMeshExt);
+export const BatchedMesh = extend(BatchedMeshImpl);

package/dist/core/instanced/InstancedMesh.d.ts

@@ -3,8 +3,8 @@ import { type UniformSchemaShader } from '../InstanceUniforms';
 import { type UniformValue, type UniformValueObj } from '../SquareDataTexture';
 import { FrustumCulling } from './FrustumCulling';
 import { Raycasting } from './Raycasting';
-/** Constructor options for {@link InstancedMeshExt}. */
-export interface InstancedMeshExtParams {
+/** Constructor options for {@link InstancedMeshImpl}. */
+export interface InstancedMeshImplParams {
     /** Initial instance capacity; the buffers grow past it on demand. */
     capacity?: number;
 }
@@ -34,10 +34,10 @@ export type CustomSortFn = (list: InstancedRenderItem[]) => void;
  * - **Batched-style texture handling.** The data textures bind as ordinary shader uniforms and
  *   flush through {@link SquareDataTexture.update}, so there is no manual texture-unit binding,
  *   `updateTextures`/`bindTextures` split, or `PropertiesOverride` — the vendored texture already
- *   works this way for `BatchedMeshExt`.
+ *   works this way for `BatchedMeshImpl`.
  * - **The draw list is a texture, not a vertex attribute.** Upstream stamps a `uint` index attribute
  *   onto whatever geometry it is handed; this fetches the instance id by `gl_InstanceID` from a texture of
- *   its own, the way `BatchedMeshExt` resolves `gl_DrawID`. So the mesh never writes to a geometry it
+ *   its own, the way `BatchedMeshImpl` resolves `gl_DrawID`. So the mesh never writes to a geometry it
  *   does not own — several may draw one cached geometry — and the cull list flushes through
  *   {@link SquareDataTexture.update} in `onBeforeRender` like every other per-instance buffer, rather
  *   than needing an attribute that owns its GL buffer to beat three's upload in `projectObject`. It
@@ -53,7 +53,7 @@ export type CustomSortFn = (list: InstancedRenderItem[]) => void;
  *
  * Render it with {@link InstancedMesh}.
  */
-export declare class InstancedMeshExt extends Mesh<BufferGeometry, Material | Material[], Object3DEventMap & {
+export declare class InstancedMeshImpl extends Mesh<BufferGeometry, Material | Material[], Object3DEventMap & {
     dispose: object;
 }> {
     /**
@@ -110,7 +110,7 @@ export declare class InstancedMeshExt extends Mesh<BufferGeometry, Material | Ma
     private drawList;
     /** Puts back what {@link patchInstancedMaterial} wrapped; null between draws. */
     private _unpatchMaterial;
-    constructor(params?: InstancedMeshExtParams);
+    constructor(params?: InstancedMeshImplParams);
     /**
      * The instance capacity the textures currently hold.
      */
@@ -298,5 +298,5 @@ export declare class InstancedMeshExt extends Mesh<BufferGeometry, Material | Ma
  * Registers the class as an R3F element, by value so the generated key cannot collide with the
  * `InstancedMesh` three already puts in the catalog when the canvas mounts.
  */
-export declare const InstancedMesh: import("react").ExoticComponent<import("@react-three/fiber/dist/declarations/src/core/utils").Mutable<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<Partial<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<InstancedMeshExt, import("@react-three/fiber").MathProps<InstancedMeshExt> & import("@react-three/fiber").ReactProps<InstancedMeshExt> & Partial<import("@react-three/fiber").EventHandlers>>>, Omit<import("@react-three/fiber").InstanceProps<InstancedMeshExt, typeof InstancedMeshExt>, "object">>>>;
+export declare const InstancedMesh: import("react").ExoticComponent<import("@react-three/fiber/dist/declarations/src/core/utils").Mutable<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<Partial<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<InstancedMeshImpl, import("@react-three/fiber").MathProps<InstancedMeshImpl> & import("@react-three/fiber").ReactProps<InstancedMeshImpl> & Partial<import("@react-three/fiber").EventHandlers>>>, Omit<import("@react-three/fiber").InstanceProps<InstancedMeshImpl, typeof InstancedMeshImpl>, "object">>>>;
 //# sourceMappingURL=InstancedMesh.d.ts.map

package/dist/core/instanced/InstancedMesh.js

@@ -26,10 +26,10 @@ patchInstancedShaderChunks();
  * - **Batched-style texture handling.** The data textures bind as ordinary shader uniforms and
  *   flush through {@link SquareDataTexture.update}, so there is no manual texture-unit binding,
  *   `updateTextures`/`bindTextures` split, or `PropertiesOverride` — the vendored texture already
- *   works this way for `BatchedMeshExt`.
+ *   works this way for `BatchedMeshImpl`.
  * - **The draw list is a texture, not a vertex attribute.** Upstream stamps a `uint` index attribute
  *   onto whatever geometry it is handed; this fetches the instance id by `gl_InstanceID` from a texture of
- *   its own, the way `BatchedMeshExt` resolves `gl_DrawID`. So the mesh never writes to a geometry it
+ *   its own, the way `BatchedMeshImpl` resolves `gl_DrawID`. So the mesh never writes to a geometry it
  *   does not own — several may draw one cached geometry — and the cull list flushes through
  *   {@link SquareDataTexture.update} in `onBeforeRender` like every other per-instance buffer, rather
  *   than needing an attribute that owns its GL buffer to beat three's upload in `projectObject`. It
@@ -45,7 +45,7 @@ patchInstancedShaderChunks();
  *
  * Render it with {@link InstancedMesh}.
  */
-export class InstancedMeshExt extends Mesh {
+export class InstancedMeshImpl extends Mesh {
     /**
      * The number of instances rendered in the last frame.
      * @default 0
@@ -489,7 +489,7 @@ export class InstancedMeshExt extends Mesh {
  * Registers the class as an R3F element, by value so the generated key cannot collide with the
  * `InstancedMesh` three already puts in the catalog when the canvas mounts.
  */
-export const InstancedMesh = extend(InstancedMeshExt);
+export const InstancedMesh = extend(InstancedMeshImpl);
 const DEFAULT_CAPACITY = 1000;
 const _matrix = new Matrix4();
 const _color = new Color();

package/dist/core/instanced/instanced-material.js

@@ -55,7 +55,7 @@ const INSTANCED_DECLARATIONS = /* glsl */ `
  * The matrix is declared here rather than where the transform chunks use it, so it lands in `main`
  * whether or not the material includes those chunks. It shadows the `attribute mat4 instanceMatrix`
  * three declares for any `isInstancedMesh` object — which is what the placeholder attribute on
- * `InstancedMeshExt` exists to satisfy — and a material doing its own transform simply never reads
+ * `InstancedMeshImpl` exists to satisfy — and a material doing its own transform simply never reads
  * it.
  */
 const INSTANCED_RESOLVE = /* glsl */ `

package/dist/core/lines/BatchedLines.d.ts

@@ -1,7 +1,7 @@
 import { type Box3, type BufferGeometry, type Camera, type Group, type Material, type Scene, type Sphere, Vector3, type Vector3Like, type WebGLRenderer } from 'three';
 import { LineMaterial } from 'three/addons/lines/LineMaterial.js';
 import { LineSegmentsGeometry } from 'three/addons/lines/LineSegmentsGeometry.js';
-import { InstancedMeshExt, type InstancedMeshExtParams } from '../instanced/InstancedMesh';
+import { InstancedMeshImpl, type InstancedMeshImplParams } from '../instanced/InstancedMesh';
 import { FrustumCulling } from './FrustumCulling';
 import { Raycasting } from './Raycasting';
 /**
@@ -31,7 +31,7 @@ import { Raycasting } from './Raycasting';
  *
  * Render it with {@link BatchedLines}.
  */
-export declare class BatchedLinesExt extends InstancedMeshExt {
+export declare class BatchedLinesImpl extends InstancedMeshImpl {
     /**
      * The segment template every member is drawn from, and the whole of what the geometry carries: the
      * per-instance data three would put in instanced attributes is in the uniforms instead.
@@ -58,7 +58,7 @@ export declare class BatchedLinesExt extends InstancedMeshExt {
     /**
      * @param params - Instance capacity; the buffers grow past it on demand.
      */
-    constructor(params?: InstancedMeshExtParams);
+    constructor(params?: InstancedMeshImplParams);
     /**
      * Reads a member's endpoints.
      * @param id - The member to read.
@@ -131,5 +131,5 @@ export declare class BatchedLinesExt extends InstancedMeshExt {
  * Registers the class as an R3F element, by value so the generated key cannot collide with anything
  * three puts in the catalog when the canvas mounts.
  */
-export declare const BatchedLines: import("react").ExoticComponent<import("@react-three/fiber/dist/declarations/src/core/utils").Mutable<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<Partial<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<BatchedLinesExt, import("@react-three/fiber").MathProps<BatchedLinesExt> & import("@react-three/fiber").ReactProps<BatchedLinesExt> & Partial<import("@react-three/fiber").EventHandlers>>>, Omit<import("@react-three/fiber").InstanceProps<BatchedLinesExt, typeof BatchedLinesExt>, "object">>>>;
+export declare const BatchedLines: import("react").ExoticComponent<import("@react-three/fiber/dist/declarations/src/core/utils").Mutable<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<Partial<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<BatchedLinesImpl, import("@react-three/fiber").MathProps<BatchedLinesImpl> & import("@react-three/fiber").ReactProps<BatchedLinesImpl> & Partial<import("@react-three/fiber").EventHandlers>>>, Omit<import("@react-three/fiber").InstanceProps<BatchedLinesImpl, typeof BatchedLinesImpl>, "object">>>>;
 //# sourceMappingURL=BatchedLines.d.ts.map

package/dist/core/lines/BatchedLines.js

@@ -2,7 +2,7 @@ import { extend } from '@react-three/fiber';
 import { Vector3, Vector4, } from 'three';
 import { LineMaterial } from 'three/addons/lines/LineMaterial.js';
 import { LineSegmentsGeometry } from 'three/addons/lines/LineSegmentsGeometry.js';
-import { InstancedMeshExt } from '../instanced/InstancedMesh';
+import { InstancedMeshImpl } from '../instanced/InstancedMesh';
 import { FrustumCulling } from './FrustumCulling';
 import { END_UNIFORM, patchLineMaterial, START_UNIFORM, WIDTH_UNIFORM } from './lines-material';
 import { Raycasting } from './Raycasting';
@@ -33,7 +33,7 @@ import { Raycasting } from './Raycasting';
  *
  * Render it with {@link BatchedLines}.
  */
-export class BatchedLinesExt extends InstancedMeshExt {
+export class BatchedLinesImpl extends InstancedMeshImpl {
     /**
      * The segment template every member is drawn from, and the whole of what the geometry carries: the
      * per-instance data three would put in instanced attributes is in the uniforms instead.
@@ -188,7 +188,7 @@ export class BatchedLinesExt extends InstancedMeshExt {
  * Registers the class as an R3F element, by value so the generated key cannot collide with anything
  * three puts in the catalog when the canvas mounts.
  */
-export const BatchedLines = extend(BatchedLinesExt);
+export const BatchedLines = extend(BatchedLinesImpl);
 /**
  * Whether a material is one three's line shader compiles from.
  * @param material - The material three is about to draw with.
@@ -199,7 +199,7 @@ function isLineMaterial(material) {
 }
 /**
  * The width a member starts at: negative, which is how "none of its own" is marked, so it draws at
- * the material's. See {@link BatchedLinesExt.setWidthAt} for why the marker is a negative value and
+ * the material's. See {@link BatchedLinesImpl.setWidthAt} for why the marker is a negative value and
  * not zero.
  */
 const MATERIAL_WIDTH = -1;

package/dist/core/text/BatchedText.d.ts

@@ -2,7 +2,7 @@ import { type BufferGeometry, type Camera, type Intersection, type Material, typ
 import { BatchedText as TroikaBatchedText, type TextMaterial } from 'troika-three-text';
 import { type UniformSchemaShader } from '../InstanceUniforms';
 import { type UniformValue, type UniformValueObj } from '../SquareDataTexture';
-import { type TextExt } from './Text';
+import { type TextImpl } from './Text';
 /**
  * troika's `BatchedText` with stable member ids, explicit paint order, and per-instance uniforms.
  *
@@ -24,7 +24,7 @@ import { type TextExt } from './Text';
  * Other departures from upstream:
  *
  * - **Sync is flag-driven, not scanned.** Members report property writes through
- *   `TextExt._batchParent`, so an idle frame costs nothing instead of walking every member.
+ *   `TextImpl._batchParent`, so an idle frame costs nothing instead of walking every member.
  * - **Per-member frustum culling and visibility**, by zeroing a hidden member's matrix so its glyphs
  *   collapse to a degenerate triangle. See {@link MemberTexture}.
  * - **Bounds are cached**, recomputed only when {@link invalidateBounds} says they moved, where
@@ -34,7 +34,7 @@ import { type TextExt } from './Text';
  * - **The derived material inherits the base's `transparent`**, rather than troika forcing it true.
  *   See {@link configureDerivedMaterial}.
  *
- * **Not built on {@link InstancedMeshExt}'s machinery**, despite the family resemblance. That mesh
+ * **Not built on {@link InstancedMeshImpl}'s machinery**, despite the family resemblance. That mesh
  * draws one shared geometry through a per-frame list of instance ids, so it culls and sorts by
  * rewriting the list; here draw order *is* the order glyph runs sit in the attributes, so a reorder
  * costs a repack and culling collapses a matrix row instead. Its members are real objects carrying
@@ -42,14 +42,14 @@ import { type TextExt } from './Text';
  * per member rather than in bulk by count, and visibility rides on the member's own `visible`. What
  * the two genuinely share is {@link InstanceUniforms}.
  *
- * Members must be {@link TextExt}, and are assumed to agree on `orientation` and `sdfGlyphSize`:
+ * Members must be {@link TextImpl}, and are assumed to agree on `orientation` and `sdfGlyphSize`:
  * both feed uniforms that are batch-wide rather than per-member, so mixing them across a batch
  * leaves whichever member was written last in charge.
  *
  * Render it with {@link BatchedText}.
  */
-export declare class BatchedTextExt extends TroikaBatchedText {
-    /** Per-instance uniform store, shared with {@link BatchedMeshExt} and {@link InstancedMeshExt}. */
+export declare class BatchedTextImpl extends TroikaBatchedText {
+    /** Per-instance uniform store, shared with {@link BatchedMeshImpl} and {@link InstancedMeshImpl}. */
     private readonly uniforms;
     /** The per-member transform and style rows the batch's shader draws from. */
     private readonly memberTexture;
@@ -76,7 +76,7 @@ export declare class BatchedTextExt extends TroikaBatchedText {
      * hole.
      *
      * **A pure high-water mark: removing a member never pulls it back in**, unlike `Instances`, the
-     * equivalent for {@link InstancedMeshExt}, which shrinks past trailing dead ids. Converting either
+     * equivalent for {@link InstancedMeshImpl}, which shrinks past trailing dead ids. Converting either
      * to the other buys nothing. A dead row costs the sweeps here one array read and a `continue`; and
      * this same number also sizes both textures, where `Instances` has a separate `capacity` for that
      * — so shrinking it would reallocate the matrix and uniform textures every time the last member
@@ -85,10 +85,10 @@ export declare class BatchedTextExt extends TroikaBatchedText {
     get addedMembersCount(): number;
     /** The material whose `onBeforeCompile` is already wrapped, so it is wrapped exactly once. */
     private patchedMaterial;
-    /** Marks the batch as needing a sync pass. Members call this through `TextExt._batchParent`. */
+    /** Marks the batch as needing a sync pass. Members call this through `TextImpl._batchParent`. */
     requestSync(): void;
     /**
-     * Marks the batch's bounds as stale. Members call this through `TextExt._batchParent` whenever
+     * Marks the batch's bounds as stale. Members call this through `TextImpl._batchParent` whenever
      * their transform changes, so no caller has to remember to.
      */
     invalidateBounds(): void;
@@ -97,7 +97,7 @@ export declare class BatchedTextExt extends TroikaBatchedText {
      * @param memberId - The member to read.
      * @returns The member, or `undefined` when the id holds none.
      */
-    getText(memberId: number): TextExt | undefined;
+    getText(memberId: number): TextImpl | undefined;
     /**
      * Shows or hides a member. A hidden member keeps its id and its glyphs; it is collapsed at draw
      * time rather than repacked out, so hiding costs no repack.
@@ -119,7 +119,7 @@ export declare class BatchedTextExt extends TroikaBatchedText {
      * @param texts - Every member, in paint order. Members missing from it are not drawn, and anything
      *   that is not a member is dropped.
      */
-    setOrder(texts: readonly TextExt[]): void;
+    setOrder(texts: readonly TextImpl[]): void;
     /**
      * Declares per-instance uniforms, merging with any already declared and rebuilding the backing
      * texture (existing values carried across). See {@link InstanceUniforms.add}.
@@ -147,8 +147,8 @@ export declare class BatchedTextExt extends TroikaBatchedText {
      * @returns The member’s id — stable for as long as it stays in the batch, and the index every
      *   other method here takes.
      */
-    addText(text: TextExt): number;
-    removeText(text: TextExt): void;
+    addText(text: TextImpl): number;
+    removeText(text: TextImpl): void;
     /**
      * Copies the text-level properties, and deliberately not the membership.
      *
@@ -223,5 +223,5 @@ export declare class BatchedTextExt extends TroikaBatchedText {
  * Registers the class as an R3F element, by value so the generated key cannot collide with anything
  * three puts in the catalog when the canvas mounts.
  */
-export declare const BatchedText: import("react").ExoticComponent<import("@react-three/fiber/dist/declarations/src/core/utils").Mutable<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<Partial<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<BatchedTextExt, import("@react-three/fiber").MathProps<BatchedTextExt> & import("@react-three/fiber").ReactProps<BatchedTextExt> & Partial<import("@react-three/fiber").EventHandlers>>>, Omit<import("@react-three/fiber").InstanceProps<BatchedTextExt, typeof BatchedTextExt>, "object">>>>;
+export declare const BatchedText: import("react").ExoticComponent<import("@react-three/fiber/dist/declarations/src/core/utils").Mutable<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<Partial<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<BatchedTextImpl, import("@react-three/fiber").MathProps<BatchedTextImpl> & import("@react-three/fiber").ReactProps<BatchedTextImpl> & Partial<import("@react-three/fiber").EventHandlers>>>, Omit<import("@react-three/fiber").InstanceProps<BatchedTextImpl, typeof BatchedTextImpl>, "object">>>>;
 //# sourceMappingURL=BatchedText.d.ts.map

package/dist/core/text/BatchedText.js

@@ -26,7 +26,7 @@ import { MemberTexture } from './MemberTexture';
  * Other departures from upstream:
  *
  * - **Sync is flag-driven, not scanned.** Members report property writes through
- *   `TextExt._batchParent`, so an idle frame costs nothing instead of walking every member.
+ *   `TextImpl._batchParent`, so an idle frame costs nothing instead of walking every member.
  * - **Per-member frustum culling and visibility**, by zeroing a hidden member's matrix so its glyphs
  *   collapse to a degenerate triangle. See {@link MemberTexture}.
  * - **Bounds are cached**, recomputed only when {@link invalidateBounds} says they moved, where
@@ -36,7 +36,7 @@ import { MemberTexture } from './MemberTexture';
  * - **The derived material inherits the base's `transparent`**, rather than troika forcing it true.
  *   See {@link configureDerivedMaterial}.
  *
- * **Not built on {@link InstancedMeshExt}'s machinery**, despite the family resemblance. That mesh
+ * **Not built on {@link InstancedMeshImpl}'s machinery**, despite the family resemblance. That mesh
  * draws one shared geometry through a per-frame list of instance ids, so it culls and sorts by
  * rewriting the list; here draw order *is* the order glyph runs sit in the attributes, so a reorder
  * costs a repack and culling collapses a matrix row instead. Its members are real objects carrying
@@ -44,14 +44,14 @@ import { MemberTexture } from './MemberTexture';
  * per member rather than in bulk by count, and visibility rides on the member's own `visible`. What
  * the two genuinely share is {@link InstanceUniforms}.
  *
- * Members must be {@link TextExt}, and are assumed to agree on `orientation` and `sdfGlyphSize`:
+ * Members must be {@link TextImpl}, and are assumed to agree on `orientation` and `sdfGlyphSize`:
  * both feed uniforms that are batch-wide rather than per-member, so mixing them across a batch
  * leaves whichever member was written last in charge.
  *
  * Render it with {@link BatchedText}.
  */
-export class BatchedTextExt extends TroikaBatchedText {
-    /** Per-instance uniform store, shared with {@link BatchedMeshExt} and {@link InstancedMeshExt}. */
+export class BatchedTextImpl extends TroikaBatchedText {
+    /** Per-instance uniform store, shared with {@link BatchedMeshImpl} and {@link InstancedMeshImpl}. */
     uniforms = new InstanceUniforms();
     /** The per-member transform and style rows the batch's shader draws from. */
     memberTexture = new MemberTexture();
@@ -85,7 +85,7 @@ export class BatchedTextExt extends TroikaBatchedText {
      * hole.
      *
      * **A pure high-water mark: removing a member never pulls it back in**, unlike `Instances`, the
-     * equivalent for {@link InstancedMeshExt}, which shrinks past trailing dead ids. Converting either
+     * equivalent for {@link InstancedMeshImpl}, which shrinks past trailing dead ids. Converting either
      * to the other buys nothing. A dead row costs the sweeps here one array read and a `continue`; and
      * this same number also sizes both textures, where `Instances` has a separate `capacity` for that
      * — so shrinking it would reallocate the matrix and uniform textures every time the last member
@@ -96,12 +96,12 @@ export class BatchedTextExt extends TroikaBatchedText {
     }
     /** The material whose `onBeforeCompile` is already wrapped, so it is wrapped exactly once. */
     patchedMaterial = null;
-    /** Marks the batch as needing a sync pass. Members call this through `TextExt._batchParent`. */
+    /** Marks the batch as needing a sync pass. Members call this through `TextImpl._batchParent`. */
     requestSync() {
         this.batchNeedsSync = true;
     }
     /**
-     * Marks the batch's bounds as stale. Members call this through `TextExt._batchParent` whenever
+     * Marks the batch's bounds as stale. Members call this through `TextImpl._batchParent` whenever
      * their transform changes, so no caller has to remember to.
      */
     invalidateBounds() {
@@ -456,7 +456,7 @@ export class BatchedTextExt extends TroikaBatchedText {
  * Registers the class as an R3F element, by value so the generated key cannot collide with anything
  * three puts in the catalog when the canvas mounts.
  */
-export const BatchedText = extend(BatchedTextExt);
+export const BatchedText = extend(BatchedTextImpl);
 // Reused rather than built per dispatch: three's `dispatchEvent` stamps `target` on the object it
 // is handed, so these are one allocation for the batch's lifetime instead of one per event.
 const syncStartEvent = { type: 'syncstart' };

package/dist/core/text/MemberTexture.d.ts

@@ -1,6 +1,6 @@
 import { type Camera, type ColorRepresentation, Matrix4 } from 'three';
 import { type BatchTextMaterial } from 'troika-three-text';
-import { type TextExt } from './Text';
+import { type TextImpl } from './Text';
 /** What {@link MemberTexture} reads off the batch it fills for. */
 export interface MemberTextureHost {
     /**
@@ -18,7 +18,7 @@ export interface MemberTextureHost {
      * @param memberId - The member to read.
      * @returns The member, or `undefined` when the id holds none.
      */
-    getText(memberId: number): TextExt | undefined;
+    getText(memberId: number): TextImpl | undefined;
 }
 /**
  * The data texture a batch's shader reads each member's transform and style from: one 32-float row

package/dist/core/text/Text.d.ts

@@ -1,6 +1,6 @@
 import { Matrix4 } from 'three';
 import { Text as TroikaText, type TextMaterial } from 'troika-three-text';
-import { type BatchedTextExt } from './BatchedText';
+import { type BatchedTextImpl } from './BatchedText';
 /**
  * troika's `Text` with the deviations a batched, 2D-painter renderer needs.
  *
@@ -30,13 +30,13 @@ import { type BatchedTextExt } from './BatchedText';
  *
  * Render it with {@link Text}.
  */
-export declare class TextExt extends TroikaText {
+export declare class TextImpl extends TroikaText {
     /**
-     * The batch this text belongs to, set by {@link BatchedTextExt.addText}. It is how a member
+     * The batch this text belongs to, set by {@link BatchedTextImpl.addText}. It is how a member
      * reaches its batch without the batch scanning for changes: property writes invalidate the sync
      * through it, and transform writes invalidate the bounds.
      */
-    _batchParent: BatchedTextExt | undefined;
+    _batchParent: BatchedTextImpl | undefined;
     /**
      * Backing store for the `_needsSync` accessor installed on the prototype below.
      *
@@ -69,5 +69,5 @@ export declare class TextExt extends TroikaText {
  * Registers the class as an R3F element, by value so the generated key cannot collide with anything
  * three puts in the catalog when the canvas mounts.
  */
-export declare const Text: import("react").ExoticComponent<import("@react-three/fiber/dist/declarations/src/core/utils").Mutable<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<Partial<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<TextExt, import("@react-three/fiber").MathProps<TextExt> & import("@react-three/fiber").ReactProps<TextExt> & Partial<import("@react-three/fiber").EventHandlers>>>, Omit<import("@react-three/fiber").InstanceProps<TextExt, typeof TextExt>, "object">>>>;
+export declare const Text: import("react").ExoticComponent<import("@react-three/fiber/dist/declarations/src/core/utils").Mutable<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<Partial<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<TextImpl, import("@react-three/fiber").MathProps<TextImpl> & import("@react-three/fiber").ReactProps<TextImpl> & Partial<import("@react-three/fiber").EventHandlers>>>, Omit<import("@react-three/fiber").InstanceProps<TextImpl, typeof TextImpl>, "object">>>>;
 //# sourceMappingURL=Text.d.ts.map

package/dist/core/text/Text.js

@@ -30,9 +30,9 @@ import { Text as TroikaText } from 'troika-three-text';
  *
  * Render it with {@link Text}.
  */
-export class TextExt extends TroikaText {
+export class TextImpl extends TroikaText {
     /**
-     * The batch this text belongs to, set by {@link BatchedTextExt.addText}. It is how a member
+     * The batch this text belongs to, set by {@link BatchedTextImpl.addText}. It is how a member
      * reaches its batch without the batch scanning for changes: property writes invalidate the sync
      * through it, and transform writes invalidate the bounds.
      */
@@ -189,7 +189,7 @@ export class TextExt extends TroikaText {
  * Runs during `super()` — the base constructor seeds the syncable properties — at which point the
  * `_batchParent` field initializer has not run yet, so the optional call is doing real work.
  */
-Object.defineProperty(TextExt.prototype, '_needsSync', {
+Object.defineProperty(TextImpl.prototype, '_needsSync', {
     configurable: true,
     get() {
         return this._syncFlag;
@@ -206,7 +206,7 @@ Object.defineProperty(TextExt.prototype, '_needsSync', {
  * Registers the class as an R3F element, by value so the generated key cannot collide with anything
  * three puts in the catalog when the canvas mounts.
  */
-export const Text = extend(TextExt);
+export const Text = extend(TextImpl);
 // Scratch reused across calls, each filled and consumed within a single synchronous block.
 const _matrix = new Matrix4();
 const _horizontal = new Vector3();

package/dist/core/text/glyph-packing.d.ts

@@ -1,5 +1,5 @@
 import { type GlyphsGeometry, type TextRenderInfo } from 'troika-three-text';
-import { type TextExt } from './Text';
+import { type TextImpl } from './Text';
 /**
  * Rewrites a batch's glyph attributes from its members' render info.
  *
@@ -13,5 +13,5 @@ import { type TextExt } from './Text';
  * @returns The render info the batch should adopt as its own — any member's will do, since a batch
  *   shares one SDF atlas — or `undefined` when no member has synced.
  */
-export declare function packGlyphs(geometry: GlyphsGeometry, ordered: readonly number[], textAt: (memberId: number) => TextExt | undefined): TextRenderInfo | undefined;
+export declare function packGlyphs(geometry: GlyphsGeometry, ordered: readonly number[], textAt: (memberId: number) => TextImpl | undefined): TextRenderInfo | undefined;
 //# sourceMappingURL=glyph-packing.d.ts.map

package/dist/events/layout-targets.d.ts

@@ -57,9 +57,13 @@ export interface LayoutTargets {
      * Two passes, in the legacy `UpdatesSystem`'s shape: the stale defs first, except that a hidden
      * def or one the frustum rejects is *deferred* rather than laid out; then the deferred ones, with
      * whatever budget is left. Priority is all deferral buys — every def is still laid out before the
-     * sweep ends, because whether a def draws can be exactly what its rule decides. The budget is
-     * checked before each def, so even a blown budget lays at least one out and a sweep can never
-     * stall.
+     * sweep ends, because whether a def draws can be exactly what its rule decides.
+     *
+     * **A drain always takes at least one def**, across the two passes together, however little
+     * budget is left — including none, which is what a worker descheduled before the first check
+     * leaves. That is what makes a sweep unable to stall: each drain shortens the backlog, so the
+     * frames the driver keeps asking for eventually end it. Without the guarantee a drain can dequeue
+     * nothing, return "more to do", and be asked again on the next frame with the same result.
      * @param frustum - The camera's frustum in plan space, when the caller has one; without it only
      *   hidden defs are deferred.
      * @param budgetMs - How much of the frame a call may spend. Non-positive means no limit.

package/dist/events/layout-targets.js

@@ -208,14 +208,25 @@ export function createLayoutTargets(invalidate, pixelSize, roll = 0) {
             if (pending.size === 0 && deferred.size === 0)
                 return false;
             const start = performance.now();
-            const overBudget = () => budgetMs > 0 && performance.now() - start >= budgetMs;
             let wrote = 0;
+            /**
+             * Defs this drain has taken off a queue, laid out or deferred.
+             *
+             * It gates the budget so that the **first** def of a drain is always taken. Without that, a
+             * budget already spent before the loop began — the worker descheduled between `start` and the
+             * check, which a loaded machine does routinely — dequeues nothing at all, and a drain that
+             * dequeues nothing is the stall this budget exists to prevent. Shared across both passes, so
+             * the guarantee is one def per drain rather than one per pass.
+             */
+            let processed = 0;
+            const overBudget = () => processed > 0 && budgetMs > 0 && performance.now() - start >= budgetMs;
             // Sets iterate in insertion order and tolerate deletion mid-walk, which is what makes the two
             // passes below plain loops: the order moves arrived is the priority within a pass, and a
             // processed def leaves its set before its rules run.
             for (const def of pending) {
                 if (overBudget())
                     break;
+                processed++;
                 pending.delete(def);
                 // Deferral is priority, never a skip: a hidden def, or one the camera cannot see, joins the
                 // second pass rather than being laid out now. `def.hidden` needs no frustum — hidden is not
@@ -230,6 +241,7 @@ export function createLayoutTargets(invalidate, pixelSize, roll = 0) {
             for (const def of deferred) {
                 if (overBudget())
                     break;
+                processed++;
                 deferred.delete(def);
                 if (layOutStale(def))
                     wrote++;

package/dist/objects/containers/SlotContainer.d.ts

@@ -5,8 +5,8 @@ import { type RenderableDef } from '../../types/defs';
 /**
  * What a container needs from the mesh it writes into.
  *
- * A capability rather than a union of our mesh classes: `BatchedMeshExt`, `InstancedMeshExt`,
- * `BatchedLinesExt` and `BatchedTextExt` share no base below `Object3D`, yet every one of them
+ * A capability rather than a union of our mesh classes: `BatchedMeshImpl`, `InstancedMeshImpl`,
+ * `BatchedLinesImpl` and `BatchedTextImpl` share no base below `Object3D`, yet every one of them
  * declares per-instance uniforms and hides an instance the same way — which is all a container
  * touches generically. Everything else it reaches through its own mesh type, which the subclass
  * names.
@@ -148,6 +148,8 @@ export declare abstract class SlotContainer<R, M extends SlotMesh = SlotMesh, T
     private readonly sortDirection;
     /** Set by {@link bind}, which runs before any effect can claim a slot. */
     private boundMesh;
+    /** What to run when a member turns out to belong in a sibling container; see {@link reportKindMismatch}. */
+    private kindMismatchHandler;
     /**
      * @param options - How this container differs from the default.
      */
@@ -201,6 +203,29 @@ export declare abstract class SlotContainer<R, M extends SlotMesh = SlotMesh, T
      * @returns The def, or `undefined` when the hit cannot be traced to one.
      */
     defFromHit(hit: Intersection): RenderableDef | undefined;
+    /**
+     * Registers what to do when a member turns out to belong in a sibling container; `undefined`
+     * clears it.
+     *
+     * Here rather than on each subclass because the situation is one situation: a layer is split
+     * across several containers by some property of the def, and that property can move after the def
+     * was placed. What splits them differs — a shape's color crossing alpha 1, a model's `opacity`,
+     * an image's orientation — but what a container does about it does not, and the component that
+     * owns the split is always the one that can repair it.
+     *
+     * A method rather than an assignable field because the container is held in `useState`, and the
+     * React Compiler rejects writing to a property of a state value ("This value cannot be modified").
+     * Calling a method is fine, which is how {@link reserve} already mutates.
+     * @param handler - The re-split to run, or `undefined` to clear it.
+     */
+    setKindMismatchHandler(handler: (() => void) | undefined): void;
+    /**
+     * Reports that a member no longer belongs in this container, so it is drawing from the wrong mesh.
+     * Runs the registered handler, if any; a container mounted without one — in a spec, or bare —
+     * drops the report rather than failing, since nothing it could do would be more correct than
+     * carrying on.
+     */
+    reportKindMismatch(): void;
     /**
      * Shows or hides one instance. Every def type carries `hidden`, so `useDefSync` drives this for
      * all of them.

package/dist/objects/containers/SlotContainer.js

@@ -79,6 +79,8 @@ export class SlotContainer {
     sortDirection;
     /** Set by {@link bind}, which runs before any effect can claim a slot. */
     boundMesh;
+    /** What to run when a member turns out to belong in a sibling container; see {@link reportKindMismatch}. */
+    kindMismatchHandler;
     /**
      * @param options - How this container differs from the default.
      */
@@ -175,6 +177,33 @@ export class SlotContainer {
     defFromHit(hit) {
         return this.defAt(hit.instanceId);
     }
+    /**
+     * Registers what to do when a member turns out to belong in a sibling container; `undefined`
+     * clears it.
+     *
+     * Here rather than on each subclass because the situation is one situation: a layer is split
+     * across several containers by some property of the def, and that property can move after the def
+     * was placed. What splits them differs — a shape's color crossing alpha 1, a model's `opacity`,
+     * an image's orientation — but what a container does about it does not, and the component that
+     * owns the split is always the one that can repair it.
+     *
+     * A method rather than an assignable field because the container is held in `useState`, and the
+     * React Compiler rejects writing to a property of a state value ("This value cannot be modified").
+     * Calling a method is fine, which is how {@link reserve} already mutates.
+     * @param handler - The re-split to run, or `undefined` to clear it.
+     */
+    setKindMismatchHandler(handler) {
+        this.kindMismatchHandler = handler;
+    }
+    /**
+     * Reports that a member no longer belongs in this container, so it is drawing from the wrong mesh.
+     * Runs the registered handler, if any; a container mounted without one — in a spec, or bare —
+     * drops the report rather than failing, since nothing it could do would be more correct than
+     * carrying on.
+     */
+    reportKindMismatch() {
+        this.kindMismatchHandler?.();
+    }
     /**
      * Shows or hides one instance. Every def type carries `hidden`, so `useDefSync` drives this for
      * all of them.

package/dist/objects/containers/mesh-writes.d.ts

@@ -6,7 +6,7 @@ import { type Logger } from '../../utils/logging';
  * A mesh whose instances carry a transform.
  *
  * Named as a capability rather than listed as a union of our mesh classes, because not every batch
- * has one: `BatchedLinesExt` places its members by their endpoints and has no per-instance matrix
+ * has one: `BatchedLinesImpl` places its members by their endpoints and has no per-instance matrix
  * at all, yet still writes colors through the helper below. A class that satisfies only one of
  * these two interfaces is the point — the alternative was no-op matrix methods on a class that has
  * no transforms, which would read as a capability it does not have.

package/dist/objects/images/Images.js

@@ -99,7 +99,7 @@ function ImageAtlas(props) {
     // rejecting its render reads.
     // The quad and the material are children so R3F creates, attaches, and disposes both — the args
     // pair are placeholders the constructor demands (see `ImageMeshArgs`). The material has to be per
-    // mesh: `InstancedMeshExt` wraps whatever it draws with in a closure over its own textures, and two
+    // mesh: `InstancedMeshImpl` wraps whatever it draws with in a closure over its own textures, and two
     // instanced meshes on one material would both render against the first one's.
     return (_jsxs(_Fragment, { children: [_jsxs(InstancedMesh, { args: container.args, ref: (mesh) => container.bind(mesh), sortObjects: true, customSort: container.customSort, perObjectFrustumCulled: true, children: [_jsx("planeGeometry", {}), _jsx(TextureMaterial, { map: texture, uvOffset: UV_OFFSET_UNIFORM })] }), atlas.images.slice(0, mounted).map((packed) => (_jsx(ImageInstance, { def: packed.def, packed: packed, container: container }, `${defKey(packed.def)}:${packed.uv.u0}:${packed.uv.v0}`)))] }));
 }

package/dist/objects/images/image-container.d.ts

@@ -1,4 +1,4 @@
-import { type InstancedMeshExt, type InstancedMeshExtParams } from '../../core/instanced/InstancedMesh';
+import { type InstancedMeshImpl, type InstancedMeshImplParams } from '../../core/instanced/InstancedMesh';
 import { type ImageDef } from '../../types/defs';
 import { SlotContainer } from '../containers';
 import { type Atlas, type PackedImage } from './atlas-packer';
@@ -15,16 +15,16 @@ export declare const UV_OFFSET_UNIFORM = "uvOffset";
  * R3F diffs `args` element-wise and rebuilds the object when any element changes, so this is
  * snapshotted once and never mutated.
  *
- * Only the options: `InstancedMeshExt` takes no geometry or material, seeding throwaways that the
+ * Only the options: `InstancedMeshImpl` takes no geometry or material, seeding throwaways that the
  * element's `<planeGeometry>` and `<TextureMaterial>` children replace (R3F creates, attaches, and
  * disposes those).
  */
-export type ImageMeshArgs = [params: InstancedMeshExtParams];
+export type ImageMeshArgs = [params: InstancedMeshImplParams];
 /**
  * One atlas's mesh bookkeeping.
  *
  * Simpler than a shape container, and deliberately so: an atlas draws one shared quad, so there is
- * no geometry cache and no geometry-id juggling, and `InstancedMeshExt` grows its own buffers, so
+ * no geometry cache and no geometry-id juggling, and `InstancedMeshImpl` grows its own buffers, so
  * there is no capacity pre-scan — the mesh is merely sized to the atlas's packed-image count and
  * left to resize itself if a claim ever overflows it. What remains is a slot per packed image and
  * the uv region each one samples, written once at claim since a def's source never changes.
@@ -34,7 +34,7 @@ export type ImageMeshArgs = [params: InstancedMeshExtParams];
  * change to the *set* of images is the harder case and still repacks into a fresh container —
  * packing has no incremental path for that — but a pure reorder does not.
  */
-export declare class ImageContainer extends SlotContainer<PackedImage, InstancedMeshExt, ImageDef> {
+export declare class ImageContainer extends SlotContainer<PackedImage, InstancedMeshImpl, ImageDef> {
     /** The constructor args R3F builds the mesh from; a frozen snapshot, never mutated. */
     readonly args: ImageMeshArgs;
     /**

package/dist/objects/images/image-container.js

@@ -13,7 +13,7 @@ export const UV_OFFSET_UNIFORM = 'uvOffset';
  * One atlas's mesh bookkeeping.
  *
  * Simpler than a shape container, and deliberately so: an atlas draws one shared quad, so there is
- * no geometry cache and no geometry-id juggling, and `InstancedMeshExt` grows its own buffers, so
+ * no geometry cache and no geometry-id juggling, and `InstancedMeshImpl` grows its own buffers, so
  * there is no capacity pre-scan — the mesh is merely sized to the atlas's packed-image count and
  * left to resize itself if a claim ever overflows it. What remains is a slot per packed image and
  * the uv region each one samples, written once at claim since a def's source never changes.

package/dist/objects/lines/line-container.d.ts

@@ -1,5 +1,5 @@
-import { type InstancedMeshExtParams } from '../../core/instanced/InstancedMesh';
-import { type BatchedLinesExt } from '../../core/lines/BatchedLines';
+import { type InstancedMeshImplParams } from '../../core/instanced/InstancedMesh';
+import { type BatchedLinesImpl } from '../../core/lines/BatchedLines';
 import { type LineDef } from '../../types/defs';
 import { SlotContainer } from '../containers';
 /**
@@ -10,7 +10,7 @@ import { SlotContainer } from '../containers';
  * Only the options: the batch builds its own segment template and takes its material from the
  * `<LineMaterial>` child R3F mounts under it.
  */
-export type LineMeshArgs = [params: InstancedMeshExtParams];
+export type LineMeshArgs = [params: InstancedMeshImplParams];
 /**
  * One line layer's bookkeeping.
  *
@@ -19,7 +19,7 @@ export type LineMeshArgs = [params: InstancedMeshExtParams];
  * endpoints. That is why the resource type is `null` here: nothing about a `LineDef` can force a
  * re-claim, so a def keeps its slot for as long as it is mounted, `points` included.
  */
-export declare class LineContainer extends SlotContainer<null, BatchedLinesExt, LineDef> {
+export declare class LineContainer extends SlotContainer<null, BatchedLinesImpl, LineDef> {
     /** The constructor args R3F builds the batch from; a frozen snapshot, never mutated. */
     readonly args: LineMeshArgs;
     /**

package/dist/objects/materials/LineMaterial.d.ts

@@ -4,7 +4,7 @@ export interface LineMaterialProps {
     /** Base color. Defaults to white, which is what a per-instance tint multiplies against. */
     color?: ColorRepresentation;
     /**
-     * Width every member without one of its own draws at, in screen-space pixels — `BatchedLinesExt`
+     * Width every member without one of its own draws at, in screen-space pixels — `BatchedLinesImpl`
      * resolves an unset per-member width to this. Defaults to 1.
      */
     width?: number;

package/dist/objects/materials/effects/color-dim.d.ts

@@ -32,7 +32,7 @@ export declare function useDimPatch(): DimPatch;
  * is the exception: troika calls the base material's handler first and then rebuilds `main` around
  * it — renaming the original `troikaOrigMain` and calling it from a new one — so a patch installed
  * there would land in a scope the prologue's local never reaches. With this guard that early call
- * simply does nothing, and `BatchedTextExt` runs the same patch again once its prologue is in.
+ * simply does nothing, and `BatchedTextImpl` runs the same patch again once its prologue is in.
  * @param parameters - The shader being compiled.
  * @param uniform - The layer's dim amount.
  * @returns Whether the shader was patched.

package/dist/objects/materials/effects/color-dim.js

@@ -42,7 +42,7 @@ export function useDimPatch() {
  * is the exception: troika calls the base material's handler first and then rebuilds `main` around
  * it — renaming the original `troikaOrigMain` and calling it from a new one — so a patch installed
  * there would land in a scope the prologue's local never reaches. With this guard that early call
- * simply does nothing, and `BatchedTextExt` runs the same patch again once its prologue is in.
+ * simply does nothing, and `BatchedTextImpl` runs the same patch again once its prologue is in.
  * @param parameters - The shader being compiled.
  * @param uniform - The layer's dim amount.
  * @returns Whether the shader was patched.

package/dist/objects/models/Models.js

@@ -136,7 +136,7 @@ function ModelPartMesh(props) {
     // Only the instances are staged; the container is sized and ordered from every member.
     const mounted = props.mounted ?? defs.length;
     // Ordering is a no-op for models — their container declares it so, and the mesh depth-sorts itself
-    // instead — but the hit resolution is not: `InstancedMeshExt.raycast` walks the live slots,
+    // instead — but the hit resolution is not: `InstancedMeshImpl.raycast` walks the live slots,
     // skipping deleted and hidden ones, and raycasts the real merged geometry, so a hit names the
     // model's actual triangles and the slot that drew them.
     const container = useContainer(() => new ModelContainer(asset.extents, defs.length, kind), defs);
@@ -150,7 +150,7 @@ function ModelPartMesh(props) {
     }, [container, onKindMismatch]);
     // The geometry belongs to the module-level cache and may be drawing in another layer, so it is
     // mounted as a `primitive` with `dispose={null}` — R3F must not free it on unmount. Sharing it is
-    // safe because `InstancedMeshExt` never writes to the geometry it is handed: its draw list lives in
+    // safe because `InstancedMeshImpl` never writes to the geometry it is handed: its draw list lives in
     // a texture of its own, addressed by `gl_InstanceID`. The material cannot be shared the same way —
     // the mesh wraps it in a closure over its own textures — so `ModelMaterial` clones it per mesh.
     //

package/dist/objects/models/model-container.d.ts

@@ -1,6 +1,6 @@
 import { type Rect } from '@expofp/geometry';
 import { type Box3, Matrix4 } from 'three';
-import { type InstancedMeshExt, type InstancedMeshExtParams } from '../../core/instanced/InstancedMesh';
+import { type InstancedMeshImpl, type InstancedMeshImplParams } from '../../core/instanced/InstancedMesh';
 import { type ModelDef } from '../../types/defs';
 import { SlotContainer } from '../containers';
 /**
@@ -10,7 +10,7 @@ import { SlotContainer } from '../containers';
  */
 export declare const OPACITY_UNIFORM = "instanceOpacity";
 /** The constructor tuple R3F builds one model mesh from. Frozen, so R3F never rebuilds the mesh. */
-export type ModelMeshArgs = [params: InstancedMeshExtParams];
+export type ModelMeshArgs = [params: InstancedMeshImplParams];
 /**
  * Every kind of model batch, **in the order they draw within a layer** — which is what `Models`
  * numbers them by.
@@ -34,11 +34,11 @@ export declare function modelKindOf(def: ModelDef): ModelKind;
  * twenty copies of a chair are one draw call rather than twenty.
  *
  * Much simpler than a shape container. The geometry is the part's — shared, never per instance — so
- * there is no geometry cache and no capacity pre-scan, and `InstancedMeshExt` grows its own buffers,
+ * there is no geometry cache and no capacity pre-scan, and `InstancedMeshImpl` grows its own buffers,
  * so nothing here has to size anything. What is left is a slot per def and the transform each one
  * draws with.
  */
-export declare class ModelContainer extends SlotContainer<null, InstancedMeshExt, ModelDef> {
+export declare class ModelContainer extends SlotContainer<null, InstancedMeshImpl, ModelDef> {
     /** The constructor args R3F builds the mesh from; a frozen snapshot, never mutated. */
     readonly args: ModelMeshArgs;
     /** Which kind of member this container holds, and so which render list its mesh draws from. */
@@ -50,7 +50,6 @@ export declare class ModelContainer extends SlotContainer<null, InstancedMeshExt
     readonly meshMatrix: Matrix4;
     /** The model's bounds in plan units; every instance is fitted against them. */
     private readonly extents;
-    private kindMismatchHandler;
     /**
      * Builds the bookkeeping for one model part.
      * @param extents - The model's own bounds, y-up, as `bakeGltf` left them.
@@ -74,21 +73,6 @@ export declare class ModelContainer extends SlotContainer<null, InstancedMeshExt
      * quietly appear to order this one.
      */
     setPaintOrder(): void;
-    /**
-     * Registers what to do when a member turns out to be the wrong kind. `Models` supplies a re-split;
-     * `undefined` clears it.
-     *
-     * A method rather than an assignable field because the container is held in `useState`, and the
-     * React Compiler rejects writing to a property of a state value.
-     * @param handler - The re-split to run, or `undefined` to clear it.
-     */
-    setKindMismatchHandler(handler: (() => void) | undefined): void;
-    /**
-     * Reports that a member no longer matches {@link kind} — its `opacity` crossed 1 — so it is
-     * drawing from a mesh whose material describes the wrong render list. Runs the registered handler,
-     * if any; a container mounted outside `Models` has none and the report is simply dropped.
-     */
-    reportKindMismatch(): void;
     /**
      * Writes a def's placement into its slot: the model's extents fitted into `bounds`.
      *

package/dist/objects/models/model-container.js

@@ -30,7 +30,7 @@ export function modelKindOf(def) {
  * twenty copies of a chair are one draw call rather than twenty.
  *
  * Much simpler than a shape container. The geometry is the part's — shared, never per instance — so
- * there is no geometry cache and no capacity pre-scan, and `InstancedMeshExt` grows its own buffers,
+ * there is no geometry cache and no capacity pre-scan, and `InstancedMeshImpl` grows its own buffers,
  * so nothing here has to size anything. What is left is a slot per def and the transform each one
  * draws with.
  */
@@ -46,7 +46,6 @@ export class ModelContainer extends SlotContainer {
     meshMatrix = PLAN_FROM_GLTF;
     /** The model's bounds in plan units; every instance is fitted against them. */
     extents;
-    kindMismatchHandler;
     /**
      * Builds the bookkeeping for one model part.
      * @param extents - The model's own bounds, y-up, as `bakeGltf` left them.
@@ -78,25 +77,6 @@ export class ModelContainer extends SlotContainer {
     setPaintOrder() {
         // Nothing: the depth buffer orders models, and a layer's parts are separate meshes regardless.
     }
-    /**
-     * Registers what to do when a member turns out to be the wrong kind. `Models` supplies a re-split;
-     * `undefined` clears it.
-     *
-     * A method rather than an assignable field because the container is held in `useState`, and the
-     * React Compiler rejects writing to a property of a state value.
-     * @param handler - The re-split to run, or `undefined` to clear it.
-     */
-    setKindMismatchHandler(handler) {
-        this.kindMismatchHandler = handler;
-    }
-    /**
-     * Reports that a member no longer matches {@link kind} — its `opacity` crossed 1 — so it is
-     * drawing from a mesh whose material describes the wrong render list. Runs the registered handler,
-     * if any; a container mounted outside `Models` has none and the report is simply dropped.
-     */
-    reportKindMismatch() {
-        this.kindMismatchHandler?.();
-    }
     /**
      * Writes a def's placement into its slot: the model's extents fitted into `bounds`.
      *

package/dist/objects/shapes/shape-container.d.ts

@@ -1,6 +1,6 @@
 import { type Shape } from '@expofp/geometry';
 import { type BufferGeometry, type Intersection } from 'three';
-import { type BatchedMeshExt } from '../../core/batch/BatchedMesh';
+import { type BatchedMeshImpl } from '../../core/batch/BatchedMesh';
 import { type RenderableDef, type ShapeDef } from '../../types/defs';
 import { SlotContainer } from '../containers';
 /**
@@ -21,7 +21,7 @@ export declare const SHAPE_KINDS: readonly ['planar', 'solid', 'translucent'];
  * One value rather than the `solid`/`translucent` pair it replaces. The pair could express a
  * translucent-but-flat batch, which nothing partitions for and no material describes, and it split
  * one fact across a field each reader needed and a field none did. This is also the "kind" that
- * {@link ShapeContainer.reportKindMismatch} and its handler have always named.
+ * {@link SlotContainer.reportKindMismatch} and its handler have always named.
  *
  * Derived from {@link SHAPE_KINDS} rather than listed again, so the two cannot drift.
  */
@@ -67,7 +67,7 @@ export declare function shapeKindOf(def: ShapeDef): ShapeKind;
  * which of its geometry ids each template was given. Building the templates is not its work either;
  * they come from {@link shapeGeometry}, which caches them across every container.
  */
-export declare class ShapeContainer extends SlotContainer<BufferGeometry, BatchedMeshExt, ShapeDef> {
+export declare class ShapeContainer extends SlotContainer<BufferGeometry, BatchedMeshImpl, ShapeDef> {
     /**
      * The mesh's constructor args, sized to hold the defs the container was created with exactly.
      * Passed as `<batchedMesh args={container.capacity}>`; R3F diffs `args` element-wise and a change
@@ -96,7 +96,6 @@ export declare class ShapeContainer extends SlotContainer<BufferGeometry, Batche
      * going to do anyway.
      */
     private readonly target;
-    private kindMismatchHandler;
     /**
      * Builds a shape layer's container, sized to hold `defs` exactly so a layer that mounts full never
      * reallocates. The mesh itself is R3F's: the component renders `<batchedMesh>` from
@@ -130,22 +129,6 @@ export declare class ShapeContainer extends SlotContainer<BufferGeometry, Batche
      * @param defs - The shapes this container is about to hold.
      */
     reserve(defs: readonly ShapeDef[]): void;
-    /**
-     * Registers what to do when a member turns out to be the wrong kind. `Shapes` supplies a re-split;
-     * `undefined` clears it.
-     *
-     * A method rather than an assignable field because the container is held in `useState`, and the
-     * React Compiler rejects writing to a property of a state value ("This value cannot be modified").
-     * Calling a method is fine, which is how {@link reserve} already mutates.
-     * @param handler - The re-split to run, or `undefined` to clear it.
-     */
-    setKindMismatchHandler(handler: (() => void) | undefined): void;
-    /**
-     * Reports that a member no longer matches {@link kind} — its color crossed alpha 1, or its shape
-     * was replaced with one of another kind — so it is drawing from the wrong batch. Runs the registered handler, if any;
-     * a container mounted outside `Shapes` has none and the report is simply dropped.
-     */
-    reportKindMismatch(): void;
     /**
      * A batched mesh reports the instance it hit as `batchId`, which is the slot this container
      * allocated.

package/dist/objects/shapes/shape-container.js

@@ -84,7 +84,6 @@ export class ShapeContainer extends SlotContainer {
      * going to do anyway.
      */
     target;
-    kindMismatchHandler;
     /**
      * Builds a shape layer's container, sized to hold `defs` exactly so a layer that mounts full never
      * reallocates. The mesh itself is R3F's: the component renders `<batchedMesh>` from
@@ -152,26 +151,6 @@ export class ShapeContainer extends SlotContainer {
         this.target.vertices = vertices;
         this.target.indices = indices;
     }
-    /**
-     * Registers what to do when a member turns out to be the wrong kind. `Shapes` supplies a re-split;
-     * `undefined` clears it.
-     *
-     * A method rather than an assignable field because the container is held in `useState`, and the
-     * React Compiler rejects writing to a property of a state value ("This value cannot be modified").
-     * Calling a method is fine, which is how {@link reserve} already mutates.
-     * @param handler - The re-split to run, or `undefined` to clear it.
-     */
-    setKindMismatchHandler(handler) {
-        this.kindMismatchHandler = handler;
-    }
-    /**
-     * Reports that a member no longer matches {@link kind} — its color crossed alpha 1, or its shape
-     * was replaced with one of another kind — so it is drawing from the wrong batch. Runs the registered handler, if any;
-     * a container mounted outside `Shapes` has none and the report is simply dropped.
-     */
-    reportKindMismatch() {
-        this.kindMismatchHandler?.();
-    }
     /**
      * A batched mesh reports the instance it hit as `batchId`, which is the slot this container
      * allocated.

package/dist/objects/text/text-container.d.ts

@@ -1,12 +1,12 @@
 import { type Intersection } from 'three';
-import { type BatchedTextExt } from '../../core/text/BatchedText';
-import { TextExt } from '../../core/text/Text';
+import { type BatchedTextImpl } from '../../core/text/BatchedText';
+import { TextImpl } from '../../core/text/Text';
 import { type RenderableDef, type TextDef } from '../../types/defs';
 import { SlotContainer } from '../containers';
-/** One def's members: a `TextExt` per line, and the batch slot each of them occupies. */
+/** One def's members: a `TextImpl` per line, and the batch slot each of them occupies. */
 export interface LineGroup {
     /** The members, in the def's line order. */
-    readonly texts: readonly TextExt[];
+    readonly texts: readonly TextImpl[];
     /** Each member's batch slot, index-parallel to {@link texts}. */
     readonly slots: readonly number[];
 }
@@ -14,7 +14,7 @@ export interface LineGroup {
  * One text layer's bookkeeping: a group of members per def, and the paint order across them.
  *
  * The slot a def claims here is a **group**, not a batch member — a `TextDef` holds an array of
- * lines and each line is its own `TextExt`. That is the one place this differs from the shape and
+ * lines and each line is its own `TextImpl`. That is the one place this differs from the shape and
  * image containers, and it falls out of the def type rather than being a choice: the lines of one
  * def are laid out together (a centered block needs every line's height before it can place the
  * first), so they cannot be independent instances.
@@ -27,7 +27,7 @@ export interface LineGroup {
  * draw list, so {@link applyOrder} hands the batch a rebuilt member list instead of labeling slots,
  * and the inherited `customSort` goes unused.
  */
-export declare class TextContainer extends SlotContainer<number, BatchedTextExt, TextDef> {
+export declare class TextContainer extends SlotContainer<number, BatchedTextImpl, TextDef> {
     /** Groups by slot, with holes for released ones. */
     private readonly groups;
     private readonly freeGroups;

package/dist/objects/text/text-container.js

@@ -1,4 +1,4 @@
-import { TextExt } from '../../core/text/Text';
+import { TextImpl } from '../../core/text/Text';
 import { sameSequence } from '../../utils/arrays';
 import { SlotContainer } from '../containers';
 import { dimOrdered, isDimmed } from '../materials/effects/color-dim';
@@ -7,7 +7,7 @@ import { LAYOUT_FONT_SIZE, LINE_HEIGHT } from './text-layout';
  * One text layer's bookkeeping: a group of members per def, and the paint order across them.
  *
  * The slot a def claims here is a **group**, not a batch member — a `TextDef` holds an array of
- * lines and each line is its own `TextExt`. That is the one place this differs from the shape and
+ * lines and each line is its own `TextImpl`. That is the one place this differs from the shape and
  * image containers, and it falls out of the def type rather than being a choice: the lines of one
  * def are laid out together (a centered block needs every line's height before it can place the
  * first), so they cannot be independent instances.
@@ -194,7 +194,7 @@ export class TextContainer extends SlotContainer {
  * @returns The member.
  */
 function makeMember() {
-    const text = new TextExt();
+    const text = new TextImpl();
     text.fontSize = LAYOUT_FONT_SIZE;
     text.lineHeight = LINE_HEIGHT;
     // Wrapping is the floorplan's job: it measures and breaks lines itself, then hands over the

package/dist/objects/text/text-layout.d.ts

@@ -1,5 +1,5 @@
 import { type Rect } from '@expofp/geometry';
-import { type TextExt } from '../../core/text/Text';
+import { type TextImpl } from '../../core/text/Text';
 import { type TextDef, type TextLineDef } from '../../types/defs';
 /**
  * The em size every member lays out at, fixed for its lifetime.
@@ -70,7 +70,7 @@ export declare function layoutText(def: TextDef): LaidOutLine[];
  * @param line - The line's local placement.
  * @param bounds - The def's bounds, supplying the rotation, center and elevation.
  */
-export declare function applyPlacement(text: TextExt, line: LaidOutLine, bounds: Rect): void;
+export declare function applyPlacement(text: TextImpl, line: LaidOutLine, bounds: Rect): void;
 /**
  * The height one line's box occupies.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expofp/renderer",
-  "version": "3.35.0",
+  "version": "3.35.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/expofp/efp-app.git",
@@ -42,7 +42,7 @@
     "troika-three-text": "^0.52.5",
     "tslib": "^2.3.0",
     "webgl-memory": "^1.1.3",
-    "@expofp/geometry": "3.35.0"
+    "@expofp/geometry": "3.35.1"
   },
   "devDependencies": {
     "@react-three/test-renderer": "^9.1.0",