@waica/engine 0.19.0 → 0.19.2

package/dist/animation/sheet.js

@@ -11,11 +11,13 @@ export function sheetFrameCount(sheet) {
  */
 export function locateFrame(sheets, frame) {
     let rest = Math.max(0, Math.floor(frame));
-    for (let i = 0; i < sheets.length; i++) {
-        const count = sheetFrameCount(sheets[i]);
+    let i = 0;
+    for (const sheet of sheets) {
+        const count = sheetFrameCount(sheet);
         if (rest < count || i === sheets.length - 1)
             return { sheet: i, frame: Math.min(rest, count - 1) };
         rest -= count;
+        i++;
     }
     return { sheet: 0, frame: 0 };
 }
@@ -28,7 +30,11 @@ const positive = (value) => typeof value === 'number' && Number.isFinite(value)
 export function sheetCell(imageWidth, imageHeight, cols, rows, frame, params = {}) {
     if (params.cells?.length) {
         const index = Math.min(Math.max(0, Math.floor(frame)), params.cells.length - 1);
-        return params.cells[index];
+        const cell = params.cells[index];
+        // Invariant: the index is clamped into a non-empty cells array.
+        if (!cell)
+            throw new Error(`sheetCell: missing cell at clamped index ${index}`);
+        return cell;
     }
     const c = Math.max(1, Math.floor(cols));
     const r = Math.max(1, Math.floor(rows));

package/dist/assets/asset-loader.js

@@ -1,5 +1,6 @@
 import * as THREE from 'three';
 import { ThreeTextureBackend } from './texture-backend.js';
+import { reportRejection } from '../report-rejection.js';
 /**
  * Not `base.clone()`: `Texture.copy` sets `needsUpdate`, which bumps the
  * shared Source's version — a GPU re-upload of the same image for every
@@ -52,10 +53,10 @@ export class AssetLoader {
         if (entry.outcome === null) {
             // Chained here, before the consumer chains its own continuation on
             // `settled`, so the clone is uploadable by the time that one runs.
-            void entry.settled.then((outcome) => {
+            reportRejection(entry.settled.then((outcome) => {
                 if (outcome === 'loaded')
                     texture.version = entry.base.version;
-            });
+            }), 'texture upload');
         }
         return { texture, settled: entry.settled };
     }

package/dist/audio/web-audio-backend.js

@@ -1,3 +1,4 @@
+import { reportRejection } from '../report-rejection.js';
 /**
  * The real WebAudio implementation (ADR 0013's default). Builds a small
  * mixing graph — one GainNode per sound feeding a StereoPannerNode, feeding
@@ -90,13 +91,19 @@ export class WebAudioBackend {
             this.masterGain.gain.value = volume;
     }
     suspend() {
-        void this.context?.suspend();
+        const suspending = this.context?.suspend();
+        if (suspending)
+            reportRejection(suspending, 'audio suspend');
     }
     resume() {
-        void this.ensureContext()?.resume();
+        const resuming = this.ensureContext()?.resume();
+        if (resuming)
+            reportRejection(resuming, 'audio resume');
     }
     close() {
-        void this.context?.close();
+        const closing = this.context?.close();
+        if (closing)
+            reportRejection(closing, 'audio close');
         this.context = null;
         this.masterGain = null;
         this.channelGains.clear();
@@ -120,11 +127,13 @@ export class WebAudioBackend {
         const existing = this.channelGains.get(channel);
         if (existing)
             return existing;
-        // Safe: only called once ensureContext() has already produced a context.
-        const context = this.context;
+        const { context, masterGain } = this;
+        // Invariant: only called once ensureContext() has produced the context and master gain.
+        if (!context || !masterGain)
+            throw new Error('ensureChannelGain called before ensureContext');
         const gain = context.createGain();
         gain.gain.value = this.effectiveChannelGain(channel);
-        gain.connect(this.masterGain);
+        gain.connect(masterGain);
         this.channelGains.set(channel, gain);
         return gain;
     }

package/dist/authoring-defaults.js

@@ -5,11 +5,11 @@ function isSerializable(value) {
     const kind = typeof value;
     if (kind === 'string' || kind === 'number' || kind === 'boolean')
         return true;
-    if (kind !== 'object')
+    if (typeof value !== 'object')
         return false;
     if (Array.isArray(value))
         return true;
-    const proto = Object.getPrototypeOf(value);
+    const proto = Reflect.getPrototypeOf(value);
     return proto === Object.prototype || proto === null;
 }
 /**
@@ -32,7 +32,7 @@ export function authoringDefaults(Class, onError) {
     }
     const transient = new Set(Class.transient ?? []);
     const keys = new Set(Object.keys(instance));
-    for (let proto = Object.getPrototypeOf(instance); proto && proto !== Object.prototype; proto = Object.getPrototypeOf(proto)) {
+    for (let proto = Reflect.getPrototypeOf(instance); proto && proto !== Object.prototype; proto = Reflect.getPrototypeOf(proto)) {
         for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(proto))) {
             if (descriptor.set)
                 keys.add(key);
@@ -42,7 +42,7 @@ export function authoringDefaults(Class, onError) {
     for (const key of keys) {
         if (EXCLUDED_KEYS.has(key) || key.startsWith('_') || transient.has(key))
             continue;
-        const value = instance[key];
+        const value = Reflect.get(instance, key);
         if (value === undefined || !isSerializable(value))
             continue;
         result[key] = value;

package/dist/camera-effects.js

@@ -1,6 +1,9 @@
 import { SIMULATION_STEP, SIMULATION_TIME_EPSILON } from './fixed-step.js';
 import { resolveEasing } from './game-time.js';
-const COLORS = { black: '#000000', white: '#ffffff' };
+const COLORS = new Map([
+    ['black', '#000000'],
+    ['white', '#ffffff'],
+]);
 /** Above the UI overlay (`ui.ts`, z-index 9000): a Fade covers the HUD too. */
 const FADE_Z = 9001;
 const FLASH_Z = 9002;
@@ -9,8 +12,9 @@ const LAYOUT = Symbol('waica.cameraEffects.layout');
 function normalizeColor(value) {
     if (typeof value !== 'string')
         return null;
-    if (Object.prototype.hasOwnProperty.call(COLORS, value))
-        return COLORS[value];
+    const named = COLORS.get(value);
+    if (named !== undefined)
+        return named;
     return /^#[0-9a-fA-F]{6}$/.test(value) ? value.toLowerCase() : null;
 }
 function validSeconds(value) {

package/dist/collision-shape.js

@@ -74,34 +74,57 @@ export function collisionOverlap(a, b) {
     }
     const verticesA = collisionVertices(a);
     const verticesB = collisionVertices(b);
-    for (let ai = 0; ai < verticesA.length; ai++) {
-        const a1 = verticesA[ai];
-        const a2 = verticesA[(ai + 1) % verticesA.length];
-        for (let bi = 0; bi < verticesB.length; bi++) {
-            const b1 = verticesB[bi];
-            const b2 = verticesB[(bi + 1) % verticesB.length];
-            if (segmentsCross(a1, a2, b1, b2))
-                return true;
-        }
-    }
+    if (polygonEdgesCross(verticesA, verticesB))
+        return true;
     return hasInteriorPoint(verticesA, verticesB) || hasInteriorPoint(verticesB, verticesA);
 }
-function hasInteriorPoint(points, polygon) {
-    for (let index = 0; index < points.length; index++) {
-        const point = points[index];
-        if (pointInPolygon(point, polygon))
+/** Whether any closed-polygon edge of `polygonA` properly crosses one of `polygonB`. */
+function polygonEdgesCross(polygonA, polygonB) {
+    let a1 = polygonA.at(-1);
+    if (a1 === undefined)
+        return false;
+    for (const a2 of polygonA) {
+        if (edgeCrossesPolygon(a1, a2, polygonB))
             return true;
-        const next = points[(index + 1) % points.length];
-        if (pointInPolygon([(point[0] + next[0]) / 2, (point[1] + next[1]) / 2], polygon)) {
+        a1 = a2;
+    }
+    return false;
+}
+function edgeCrossesPolygon(a1, a2, polygon) {
+    let b1 = polygon.at(-1);
+    if (b1 === undefined)
+        return false;
+    for (const b2 of polygon) {
+        if (segmentsCross(a1, a2, b1, b2))
             return true;
-        }
+        b1 = b2;
     }
+    return false;
+}
+function hasInteriorPoint(points, polygon) {
+    if (hasVertexOrMidpointInside(points, polygon))
+        return true;
     const center = [
         points.reduce((sum, [x]) => sum + x, 0) / points.length,
         points.reduce((sum, [, y]) => sum + y, 0) / points.length,
     ];
     return pointInPolygon(center, polygon);
 }
+/** Whether any vertex of `points`, or the midpoint of any of its closed-polygon edges, lies inside `polygon`. */
+function hasVertexOrMidpointInside(points, polygon) {
+    let previous = points.at(-1);
+    if (previous === undefined)
+        return false;
+    for (const point of points) {
+        if (pointInPolygon(point, polygon))
+            return true;
+        if (pointInPolygon([(previous[0] + point[0]) / 2, (previous[1] + point[1]) / 2], polygon)) {
+            return true;
+        }
+        previous = point;
+    }
+    return false;
+}
 function segmentsCross(a1, a2, b1, b2) {
     const ab1 = cross(a1, a2, b1);
     const ab2 = cross(a1, a2, b2);
@@ -114,15 +137,17 @@ function cross(a, b, point) {
 }
 function pointInPolygon(point, polygon) {
     let inside = false;
-    for (let index = 0, previous = polygon.length - 1; index < polygon.length; previous = index++) {
-        const a = polygon[index];
-        const b = polygon[previous];
+    let b = polygon.at(-1);
+    if (b === undefined)
+        return inside;
+    for (const a of polygon) {
         if (pointOnSegment(point, a, b))
             return false;
         const crosses = (a[1] > point[1]) !== (b[1] > point[1]) &&
             point[0] < ((b[0] - a[0]) * (point[1] - a[1])) / (b[1] - a[1]) + a[0];
         if (crosses)
             inside = !inside;
+        b = a;
     }
     return inside;
 }

package/dist/component-registry.d.ts

@@ -1,7 +1,17 @@
-import { type ComponentClass } from './component.js';
+import { Component, type ComponentClass } from './component.js';
 import type { SceneRegistry } from './scene.js';
 /** The namespace returned by importing one project code module. */
 export type ComponentModule = Readonly<Record<string, unknown>>;
+/** Whether `value` is a class that extends Component (the abstract base itself is not). */
+export declare function isComponentClass(value: unknown): value is ComponentClass;
+/**
+ * The class a live component was constructed from. TypeScript types
+ * `constructor` as Function; this narrows it for real instead of asserting.
+ * It checks the shape (a constructor with a static componentName), not
+ * `instanceof Component`, so a project that resolves a second copy of
+ * @waica/engine keeps working. Internal: not re-exported from the package entry.
+ */
+export declare function componentClassOf(component: Component): ComponentClass;
 /**
  * Finds exported Component subclasses in project modules. Classes are keyed by
  * their stable componentName, not by the export name, so minification and

package/dist/component-registry.js

@@ -1,4 +1,29 @@
 import { Component } from './component.js';
+/** Whether `value` is a class that extends Component (the abstract base itself is not). */
+export function isComponentClass(value) {
+    if (typeof value !== 'function')
+        return false;
+    const prototype = Reflect.get(value, 'prototype');
+    return prototype instanceof Component;
+}
+/**
+ * The class a live component was constructed from. TypeScript types
+ * `constructor` as Function; this narrows it for real instead of asserting.
+ * It checks the shape (a constructor with a static componentName), not
+ * `instanceof Component`, so a project that resolves a second copy of
+ * @waica/engine keeps working. Internal: not re-exported from the package entry.
+ */
+export function componentClassOf(component) {
+    const Class = component.constructor;
+    if (!hasComponentName(Class)) {
+        throw new TypeError('a component was not constructed from a Component class');
+    }
+    return Class;
+}
+/** A constructor carrying the static componentName every Component class declares. */
+function hasComponentName(value) {
+    return typeof value === 'function' && typeof Reflect.get(value, 'componentName') === 'string';
+}
 /**
  * Finds exported Component subclasses in project modules. Classes are keyed by
  * their stable componentName, not by the export name, so minification and
@@ -8,11 +33,9 @@ export function collectModuleComponents(modules, warn = console.warn) {
     const components = {};
     for (const module of modules) {
         for (const value of Object.values(module)) {
-            if (typeof value !== 'function')
+            if (!isComponentClass(value))
                 continue;
             const Class = value;
-            if (!(Class.prototype instanceof Component))
-                continue;
             // Without its own componentName a class inherits the base's, so nothing
             // could reference it from scene JSON. Silently skipping it looks like
             // the editor lost the file: say so instead.

package/dist/component-update-schedule.d.ts

@@ -32,6 +32,8 @@ export interface InvalidComponentUpdateSchedule {
 }
 export type ComponentUpdateScheduleResult = ValidComponentUpdateSchedule | InvalidComponentUpdateSchedule;
 export type ComponentUpdateRegistry = Readonly<Record<string, ComponentClass | undefined>>;
+/** Whether instances of `Class` run each frame (its prototype defines onUpdate). */
+export declare function implementsOnUpdate(Class: ComponentClass | undefined): boolean;
 /**
  * Resolves one entity's deterministic component update schedule without
  * constructing components or mutating either input.

package/dist/component-update-schedule.js

@@ -4,8 +4,26 @@ function codeUnitCompare(left, right) {
 function registeredClass(registry, componentName) {
     return Object.hasOwn(registry, componentName) ? registry[componentName] : undefined;
 }
-function updates(Class) {
-    return typeof Class?.prototype.onUpdate === 'function';
+/** Whether instances of `Class` run each frame (its prototype defines onUpdate). */
+export function implementsOnUpdate(Class) {
+    if (!Class)
+        return false;
+    const prototype = Reflect.get(Class, 'prototype');
+    return typeof prototype === 'object' && prototype !== null && typeof Reflect.get(prototype, 'onUpdate') === 'function';
+}
+/** Reads a Tarjan bookkeeping entry that the traversal has already recorded. */
+function recorded(map, node, what) {
+    const value = map.get(node);
+    if (value === undefined)
+        throw new Error(`Component update cycle search has no ${what} for "${node}"`);
+    return value;
+}
+/** The first member of a strongly connected group, which always has at least two members. */
+function firstMember(group) {
+    const [first] = group;
+    if (first === undefined)
+        throw new Error('Component update cycle group is empty');
+    return first;
 }
 function updateCycles(nodes, outgoing) {
     let nextIndex = 0;
@@ -23,21 +41,22 @@ function updateCycles(nodes, outgoing) {
         for (const dependent of [...(outgoing.get(node) ?? [])].sort(codeUnitCompare)) {
             if (!indices.has(dependent)) {
                 visit(dependent);
-                lowLinks.set(node, Math.min(lowLinks.get(node), lowLinks.get(dependent)));
+                lowLinks.set(node, Math.min(recorded(lowLinks, node, 'low link'), recorded(lowLinks, dependent, 'low link')));
             }
             else if (onStack.has(dependent)) {
-                lowLinks.set(node, Math.min(lowLinks.get(node), indices.get(dependent)));
+                lowLinks.set(node, Math.min(recorded(lowLinks, node, 'low link'), recorded(indices, dependent, 'index')));
             }
         }
         if (lowLinks.get(node) !== indices.get(node))
             return;
         const group = [];
-        while (stack.length > 0) {
-            const member = stack.pop();
+        let member = stack.pop();
+        while (member !== undefined) {
             onStack.delete(member);
             group.push(member);
             if (member === node)
                 break;
+            member = stack.pop();
         }
         if (group.length > 1)
             cycles.push(group.sort(codeUnitCompare));
@@ -46,19 +65,9 @@ function updateCycles(nodes, outgoing) {
         if (!indices.has(node))
             visit(node);
     }
-    return cycles.sort((left, right) => codeUnitCompare(left[0], right[0]));
+    return cycles.sort((left, right) => codeUnitCompare(firstMember(left), firstMember(right)));
 }
-/**
- * Resolves one entity's deterministic component update schedule without
- * constructing components or mutating either input.
- */
-export function resolveComponentUpdateSchedule(componentNames, registry) {
-    const present = new Set(componentNames);
-    const nodes = [...present]
-        .filter((name) => updates(registeredClass(registry, name)))
-        .sort(codeUnitCompare);
-    const outgoing = new Map(nodes.map((name) => [name, new Set()]));
-    const indegree = new Map(nodes.map((name) => [name, 0]));
+function duplicateComponentIssues(componentNames) {
     const issues = [];
     const counts = new Map();
     for (const name of componentNames)
@@ -74,9 +83,13 @@ export function resolveComponentUpdateSchedule(componentNames, registry) {
             cause: `Component "${componentName}" appears ${count} times on the same entity; component identity must be unique.`,
         });
     }
+    return issues;
+}
+function passiveDeclarerIssues({ present, registry }) {
+    const issues = [];
     for (const declarer of [...present].sort(codeUnitCompare)) {
         const Class = registeredClass(registry, declarer);
-        if (Class?.updateAfter !== undefined && !updates(Class)) {
+        if (Class?.updateAfter !== undefined && !implementsOnUpdate(Class)) {
             issues.push({
                 code: 'invalid-update-constraint',
                 reason: 'passive-declarer',
@@ -86,65 +99,75 @@ export function resolveComponentUpdateSchedule(componentNames, registry) {
             });
         }
     }
-    for (const declarer of nodes) {
-        const Class = registeredClass(registry, declarer);
+    return issues;
+}
+/** Adds every valid updateAfter edge to the graph and returns the constraints that are not. */
+function linkUpdateConstraints(graph, scope) {
+    const issues = [];
+    for (const declarer of graph.nodes) {
+        const Class = registeredClass(scope.registry, declarer);
         for (const target of new Set(Class?.updateAfter ?? [])) {
-            if (!present.has(target)) {
-                if (!registeredClass(registry, target)) {
-                    issues.push({
-                        code: 'invalid-update-constraint',
-                        reason: 'unknown-target',
-                        declarer,
-                        target,
-                        componentNames: [declarer, target],
-                        cause: `Component "${declarer}" declares updateAfter target "${target}", which is neither present nor registered.`,
-                    });
-                }
+            const verdict = constraintVerdict({ declarer, target }, graph, scope);
+            if (verdict === 'ignore')
                 continue;
-            }
-            if (target === declarer) {
-                issues.push({
-                    code: 'invalid-update-constraint',
-                    reason: 'self-edge',
-                    declarer,
-                    target,
-                    componentNames: [declarer],
-                    cause: `Component "${declarer}" cannot declare itself in updateAfter.`,
-                });
-                continue;
-            }
-            if (!outgoing.has(target)) {
-                issues.push({
-                    code: 'invalid-update-constraint',
-                    reason: 'passive-target',
-                    declarer,
-                    target,
-                    componentNames: [declarer, target],
-                    cause: `Component "${declarer}" declares updateAfter target "${target}", but "${target}" does not implement onUpdate.`,
-                });
+            if (verdict !== 'link') {
+                issues.push(verdict);
                 continue;
             }
-            const readers = outgoing.get(target);
-            if (readers.has(declarer))
+            const readers = graph.outgoing.get(target);
+            if (!readers || readers.has(declarer))
                 continue;
             readers.add(declarer);
-            indegree.set(declarer, (indegree.get(declarer) ?? 0) + 1);
+            graph.indegree.set(declarer, (graph.indegree.get(declarer) ?? 0) + 1);
         }
     }
-    for (const componentNames of updateCycles(nodes, outgoing)) {
-        issues.push({
-            code: 'component-update-cycle',
-            componentNames,
-            cause: `Component update cycle among ${componentNames.map((name) => `"${name}"`).join(', ')}.`,
-        });
+    return issues;
+}
+/**
+ * Whether `declarer` may update after `target`: an edge to link, a
+ * registered-but-absent target to ignore, or the invalid-constraint issue.
+ */
+function constraintVerdict({ declarer, target }, graph, { present, registry }) {
+    if (!present.has(target)) {
+        if (registeredClass(registry, target))
+            return 'ignore';
+        return {
+            code: 'invalid-update-constraint',
+            reason: 'unknown-target',
+            declarer,
+            target,
+            componentNames: [declarer, target],
+            cause: `Component "${declarer}" declares updateAfter target "${target}", which is neither present nor registered.`,
+        };
     }
-    if (issues.length > 0)
-        return { ok: false, issues };
+    if (target === declarer) {
+        return {
+            code: 'invalid-update-constraint',
+            reason: 'self-edge',
+            declarer,
+            target,
+            componentNames: [declarer],
+            cause: `Component "${declarer}" cannot declare itself in updateAfter.`,
+        };
+    }
+    if (graph.outgoing.has(target))
+        return 'link';
+    return {
+        code: 'invalid-update-constraint',
+        reason: 'passive-target',
+        declarer,
+        target,
+        componentNames: [declarer, target],
+        cause: `Component "${declarer}" declares updateAfter target "${target}", but "${target}" does not implement onUpdate.`,
+    };
+}
+/** Kahn's order over the graph, always taking the code-unit-smallest ready component first. */
+function updateOrder({ nodes, outgoing, indegree }) {
     const ready = nodes.filter((name) => indegree.get(name) === 0);
     const order = [];
-    while (ready.length > 0) {
-        ready.sort(codeUnitCompare);
-        const next = ready.shift();
+    ready.sort(codeUnitCompare);
+    let next = ready.shift();
+    while (next !== undefined) {
         order.push(next);
         for (const dependent of [...(outgoing.get(next) ?? [])].sort(codeUnitCompare)) {
             const remaining = (indegree.get(dependent) ?? 0) - 1;
@@ -152,6 +175,39 @@ export function resolveComponentUpdateSchedule(componentNames, registry) {
             if (remaining === 0)
                 ready.push(dependent);
         }
+        ready.sort(codeUnitCompare);
+        next = ready.shift();
     }
-    return { ok: true, order, issues: [] };
+    return order;
+}
+/**
+ * Resolves one entity's deterministic component update schedule without
+ * constructing components or mutating either input.
+ */
+export function resolveComponentUpdateSchedule(componentNames, registry) {
+    const present = new Set(componentNames);
+    const scope = { present, registry };
+    const nodes = [...present]
+        .filter((name) => implementsOnUpdate(registeredClass(registry, name)))
+        .sort(codeUnitCompare);
+    const graph = {
+        nodes,
+        outgoing: new Map(nodes.map((name) => [name, new Set()])),
+        indegree: new Map(nodes.map((name) => [name, 0])),
+    };
+    const issues = [
+        ...duplicateComponentIssues(componentNames),
+        ...passiveDeclarerIssues(scope),
+        ...linkUpdateConstraints(graph, scope),
+    ];
+    for (const cycle of updateCycles(nodes, graph.outgoing)) {
+        issues.push({
+            code: 'component-update-cycle',
+            componentNames: cycle,
+            cause: `Component update cycle among ${cycle.map((name) => `"${name}"`).join(', ')}.`,
+        });
+    }
+    if (issues.length > 0)
+        return { ok: false, issues };
+    return { ok: true, order: updateOrder(graph), issues: [] };
 }

package/dist/components/animated-sprite.js

@@ -3,6 +3,7 @@ import { Component } from '../component.js';
 import { ClipPlayer } from '../animation/clip-player.js';
 import { locateFrame, sheetCell } from '../animation/sheet.js';
 import { spritePlacement } from '../sprite-placement.js';
+import { reportRejection } from '../report-rejection.js';
 const clampAnchor = (value) => Math.min(1, Math.max(0, value));
 /**
  * Sprite animated from one or more spritesheets. The main sheet is the
@@ -215,13 +216,13 @@ export class AnimatedSprite extends Component {
         if (!url)
             return new THREE.Texture();
         const { texture, settled } = this.game.assets.texture(url);
-        void settled.then((outcome) => {
+        reportRejection(settled.then((outcome) => {
             if (!this.texs.includes(texture))
                 return;
             if (outcome === 'failed')
                 this.failedSheets.add(texture);
             this.applyFrame();
-        });
+        }), 'sheet texture settle');
         return texture;
     }
     showFrame(index) {

package/dist/components/sprite.js

@@ -1,6 +1,7 @@
 import * as THREE from 'three';
 import { Component } from '../component.js';
 import { spritePlacement } from '../sprite-placement.js';
+import { reportRejection } from '../report-rejection.js';
 const clampAnchor = (value) => Math.min(1, Math.max(0, value));
 /**
  * Textured or flat-color quad. In the unified pipeline, a 2D sprite is a
@@ -118,10 +119,10 @@ export class Sprite extends Component {
             }
             material.map = texture;
             material.color.set(0xffffff);
-            void settled.then((outcome) => {
+            reportRejection(settled.then((outcome) => {
                 if (outcome === 'failed')
                     this.dropFailedTexture(texture);
-            });
+            }), 'sprite texture settle');
         }
         this.mesh = new THREE.Mesh(this.createGeometry(), material);
         this.mesh.position.z = this.layer * 0.01;

package/dist/components/tilemap.d.ts

@@ -115,5 +115,11 @@ export declare class Tilemap extends Component implements SolidSource {
     private dropFailedTexture;
     private makeMaterial;
     private rebuildGeometry;
+    /** The loaded sheet image's size, or one pixel per sheet cell until it arrives. */
+    private sheetSize;
+    /** The four corners of a cell's quad, projected for the Game, on this layer's depth. */
+    private pushTileQuad;
+    /** The UVs of a tile's sheet cell, in the quad's corner order. */
+    private tileUvs;
     private rebuildSolids;
 }