@waica/engine 0.18.0 → 0.19.1

package/dist/game.d.ts

@@ -4,6 +4,7 @@ import type { TextureBackend } from './assets/texture-backend.js';
 import type { AudioBackend } from './audio/backend.js';
 import { AudioSubsystem } from './audio/audio-subsystem.js';
 import { type SceneCameraJson } from './camera.js';
+import { CameraEffects } from './camera-effects.js';
 import type { Component } from './component.js';
 import { Entity } from './entity.js';
 import { Emitter } from './events.js';
@@ -83,6 +84,11 @@ export declare class Game {
      * (ADR 0011): `unloadScene()` never touches it. See ADR 0019.
      */
     readonly assets: AssetLoader;
+    /**
+     * Shake, Fade and Flash, beside `camera` and never written into it
+     * (ADR 0020). A Fade survives `unloadScene()`; a Shake or Flash does not.
+     */
+    readonly cameraEffects: CameraEffects;
     /** Simulated scheduling: `after`, `every`, `tween`, `now`. See ADR 0017. */
     readonly time: GameTime;
     /** Registry retained by loadScene for runtime prefab spawning. */

package/dist/game.js

@@ -4,7 +4,8 @@ import { AssetLoader } from './assets/asset-loader.js';
 import { AudioSubsystem } from './audio/audio-subsystem.js';
 import { dispatchCollisions as dispatchHitboxCollisions } from './collision-dispatch.js';
 import { isCameraVelocityProvider, resolveSceneCamera, stepSceneCamera, } from './camera.js';
-import { resolveComponentUpdateSchedule } from './component-update-schedule.js';
+import { advanceCameraEffects, CameraEffects, layoutCameraEffects } from './camera-effects.js';
+import { implementsOnUpdate, resolveComponentUpdateSchedule } from './component-update-schedule.js';
 import { Entity } from './entity.js';
 import { Emitter } from './events.js';
 import { consumeSimulationSteps, MAX_CHAINED_HOPS, SIMULATION_STEP, snapElapsedToStep, } from './fixed-step.js';
@@ -19,6 +20,16 @@ import { loadScene, registryEntry, spawnFromJson, } from './scene.js';
 import { createSpatialQuery } from './spatial-query.js';
 import { Stats } from './stats.js';
 import { anchoredPiecesOf, GameUi } from './ui.js';
+import { componentClassOf } from './component-registry.js';
+/** Maps a resolved update order back to the entity's components; the order only names components it was built from. */
+function componentsInOrder(order, byName) {
+    return order.map((name) => {
+        const component = byName.get(name);
+        if (!component)
+            throw new Error(`Component update schedule names "${name}", which is not on the entity`);
+        return component;
+    });
+}
 /**
  * Engine core: loop, unified 2D/3D three scene, orthographic camera,
  * entities with components, and input. See DESIGN.md.
@@ -42,6 +53,11 @@ export class Game {
      * (ADR 0011): `unloadScene()` never touches it. See ADR 0019.
      */
     assets;
+    /**
+     * Shake, Fade and Flash, beside `camera` and never written into it
+     * (ADR 0020). A Fade survives `unloadScene()`; a Shake or Flash does not.
+     */
+    cameraEffects;
     /** Simulated scheduling: `after`, `every`, `tween`, `now`. See ADR 0017. */
     time = new GameTime();
     /** Registry retained by loadScene for runtime prefab spawning. */
@@ -116,6 +132,11 @@ export class Game {
             // catalog is registered at call time, which outlives every scene.
             resolveAsset: (uri) => this.sceneCatalog?.registry.resolveAsset?.(uri) ?? uri,
         });
+        this.cameraEffects = new CameraEffects({
+            host: () => canvas.parentElement ?? document.body,
+            // One screen pixel in world units: the shake snaps to it (never the base).
+            pixel: () => (this.resolution ? this.viewHeight / this.resolution.height : null),
+        });
         this.renderer = new THREE.WebGLRenderer({ canvas, antialias: true });
         this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
         this.scene.background = new THREE.Color(background);
@@ -173,6 +194,7 @@ export class Game {
         // Scene-scoped timers/tweens die here too (ADR 0017): before entities are
         // destroyed below, so an owner's own destroy() cancellation is a no-op.
         this.time.cancelSceneScoped();
+        this.cameraEffects.unloadScene();
         // An explicit unload means "no scene": a swap queued earlier this frame
         // would otherwise flush next frame and resurrect one.
         this.pendingSceneLoad = null;
@@ -253,7 +275,7 @@ export class Game {
     }
     /** Applies persisted overrides to a freshly added component. */
     applyParamOverrides(entity, component) {
-        const Class = component.constructor;
+        const Class = componentClassOf(component);
         const override = this.paramOverrides[entity.name]?.[Class.componentName];
         if (override)
             Object.assign(component, override);
@@ -366,6 +388,7 @@ export class Game {
         this.resizeObserver.disconnect();
         this.ui.dispose();
         this.audio.dispose();
+        this.cameraEffects.dispose();
         // Cancels both scopes, including session-scoped work no entity owns
         // (entity.destroy() below only ever reaches owned work) — ADR 0017.
         this.time.cancelAll();
@@ -478,6 +501,7 @@ export class Game {
         }
         this.dispatchCollisions();
         this.updateSceneCamera(SIMULATION_STEP);
+        advanceCameraEffects(this.cameraEffects);
         this.finishStep();
     }
     /** Closes a step (real or the non-simulating stand-in): host callbacks, then the input frame. */
@@ -521,8 +545,12 @@ export class Game {
             }
         }
         const z = ySortZ(entries);
-        for (const [index, participant] of participants.entries())
-            participant.setSortZ(z[index]);
+        for (const [index, participant] of participants.entries()) {
+            const sortZ = z[index];
+            if (sortZ === undefined)
+                throw new Error(`ySortZ returned no z for y-sort participant ${index}`);
+            participant.setSortZ(sortZ);
+        }
     }
     renderSurface() {
         if (this.sceneProjection === 'isometric') {
@@ -535,15 +563,28 @@ export class Game {
         if (this.renderSort === 'y')
             this.applyYSort();
         this.ui.setActive(this.simulate);
-        anchoredPiecesOf(this.ui).place();
-        if (this.resolution) {
-            // Letterbox bars: clear the whole canvas, then render inside the scissor.
-            this.renderer.setScissorTest(false);
-            this.renderer.setClearColor(0x000000, 1);
-            this.renderer.clear(true, false, false);
-            this.renderer.setScissorTest(true);
+        // The shake offset exists only while drawing (ADR 0020): Anchored Pieces
+        // and the render see the drawn center, then the base comes back exactly,
+        // so follow smoothing never starts from its own jitter.
+        const { x, y } = this.camera.position;
+        const { shake } = this.cameraEffects.state;
+        this.camera.position.x = x + shake.x;
+        this.camera.position.y = y + shake.y;
+        try {
+            anchoredPiecesOf(this.ui).place();
+            if (this.resolution) {
+                // Letterbox bars: clear the whole canvas, then render inside the scissor.
+                this.renderer.setScissorTest(false);
+                this.renderer.setClearColor(0x000000, 1);
+                this.renderer.clear(true, false, false);
+                this.renderer.setScissorTest(true);
+            }
+            this.renderer.render(this.scene, this.camera);
+        }
+        finally {
+            this.camera.position.x = x;
+            this.camera.position.y = y;
         }
-        this.renderer.render(this.scene, this.camera);
     }
     componentUpdateSchedule(entity) {
         const components = [...entity.components];
@@ -551,11 +592,11 @@ export class Game {
         const names = [];
         const signatureParts = [];
         for (const component of components) {
-            const Class = component.constructor;
+            const Class = componentClassOf(component);
             const name = Class.componentName;
             names.push(name);
             byName.set(name, component);
-            signatureParts.push(`${name}:${typeof Class.prototype.onUpdate === 'function' ? 'updates' : 'passive'}:` +
+            signatureParts.push(`${name}:${implementsOnUpdate(Class) ? 'updates' : 'passive'}:` +
                 [...new Set(Class.updateAfter ?? [])].sort().join(','));
         }
         const signature = signatureParts.sort().join('|');
@@ -565,13 +606,13 @@ export class Game {
         // when nothing about this entity's components changed since last time.
         const cached = this.updateScheduleCache.get(entity);
         if (cached && cached.signature === signature) {
-            return cached.order.map((name) => byName.get(name));
+            return componentsInOrder(cached.order, byName);
         }
         const registry = {
             ...(this.registry?.components ?? {}),
         };
         for (const component of components) {
-            const Class = component.constructor;
+            const Class = componentClassOf(component);
             registry[Class.componentName] = Class;
         }
         const result = resolveComponentUpdateSchedule(names, registry);
@@ -586,7 +627,7 @@ export class Game {
         }
         this.invalidUpdateCompositions.delete(entity);
         this.updateScheduleCache.set(entity, { signature, order: result.order });
-        return result.order.map((name) => byName.get(name));
+        return componentsInOrder(result.order, byName);
     }
     updateSceneCamera(dt) {
         const cam = this.sceneCamera;
@@ -655,5 +696,6 @@ export class Game {
         this.camera.top = halfH;
         this.camera.bottom = -halfH;
         this.camera.updateProjectionMatrix();
+        layoutCameraEffects(this.cameraEffects, gameViewport(w, h, this.resolution));
     }
 }

package/dist/index.d.ts

@@ -17,6 +17,8 @@ export { spritePlacement } from './sprite-placement.js';
 export type { SpritePlacement, SpritePlacementInput } from './sprite-placement.js';
 export { CAMERA_DEFAULTS, isCameraVelocityProvider, resolveSceneCamera, stepSceneCamera } from './camera.js';
 export { SIMULATION_STEP, SIMULATION_TIME_EPSILON } from './fixed-step.js';
+export { CameraEffects } from './camera-effects.js';
+export type { CameraEffectColor, CameraEffectHandle, CameraEffectsOptions, CameraEffectsState, FadeOptions, FlashOptions, ShakeOptions, } from './camera-effects.js';
 export { GameTime, advanceGameTime } from './game-time.js';
 export type { EasingName, TimerHandle, TimerOptions, TweenOptions } from './game-time.js';
 export type { SceneCameraJson, CameraLimitsJson, CameraVelocity, CameraVelocityProvider, ResolvedSceneCamera, } from './camera.js';
@@ -35,7 +37,7 @@ export type { PointerCamera, PointerDeps, PointerPick, PointerResolution } from
 export { RUNTIME_BRIDGE_CAPABILITIES, RUNTIME_BRIDGE_PROTOCOL_VERSION, RUNTIME_BRIDGE_SYMBOL, RuntimeBridgeOperationError, } from './runtime-bridge.js';
 export type { RuntimeBridge, RuntimeBridgeActivation, RuntimeControlRequest, RuntimeControlResult, RuntimeMetadata, RuntimeMode, } from './runtime-bridge.js';
 export { RUNTIME_PROJECTION_LIMITS } from './runtime-inspection.js';
-export type { ProjectedValue, ProjectionIssue, ProjectionMarker, ProjectionMarkerKind, RuntimeComponentSnapshot, RuntimeEntitySnapshot, RuntimeSnapshot, RuntimeSnapshotAudio, RuntimeSnapshotFilters, RuntimeSnapshotTime, RuntimeSnapshotUi, RuntimeTransformSnapshot, } from './runtime-inspection.js';
+export type { ProjectedValue, ProjectionIssue, ProjectionMarker, ProjectionMarkerKind, RuntimeComponentSnapshot, RuntimeEntitySnapshot, RuntimeSnapshot, RuntimeSnapshotAudio, RuntimeSnapshotCamera, RuntimeSnapshotFilters, RuntimeSnapshotTime, RuntimeSnapshotUi, RuntimeTransformSnapshot, } from './runtime-inspection.js';
 export type { ArchetypeArt, ArchetypeManifest, BrowserArchetypeManifest, EntityTemplate, } from './archetype.js';
 export { Stats } from './stats.js';
 export type { StatValue } from './stats.js';

package/dist/index.js

@@ -7,6 +7,7 @@ export { projectIsometric, screenInputToLogical, unprojectIsometric } from './pr
 export { spritePlacement } from './sprite-placement.js';
 export { CAMERA_DEFAULTS, isCameraVelocityProvider, resolveSceneCamera, stepSceneCamera } from './camera.js';
 export { SIMULATION_STEP, SIMULATION_TIME_EPSILON } from './fixed-step.js';
+export { CameraEffects } from './camera-effects.js';
 export { GameTime, advanceGameTime } from './game-time.js';
 export { Entity } from './entity.js';
 export { Component } from './component.js';

package/dist/pointer.js

@@ -148,15 +148,32 @@ export class Pointer {
                 }
             }
         }
-        if (hits.length === 0)
-            return null;
-        if (hits.length === 1)
-            return hits[0].entity;
-        const z = ySortZ(hits.map((h) => ({ layer: h.layer, y: h.y })));
-        let bestIndex = 0;
-        for (let i = 1; i < hits.length; i += 1)
-            if (z[i] > z[bestIndex])
-                bestIndex = i;
-        return hits[bestIndex].entity;
+        return frontMostHit(hits);
     }
 }
+/** The front-most hit under y-sort; on an exact z tie the earlier hit wins. */
+function frontMostHit(hits) {
+    const [first] = hits;
+    if (!first)
+        return null;
+    if (hits.length === 1)
+        return first.entity;
+    const z = ySortZ(hits.map((h) => ({ layer: h.layer, y: h.y })));
+    let best = first;
+    let bestZ = zOfHit(z, 0);
+    for (const [index, hit] of hits.entries()) {
+        const hitZ = zOfHit(z, index);
+        if (hitZ > bestZ) {
+            best = hit;
+            bestZ = hitZ;
+        }
+    }
+    return best.entity;
+}
+/** `ySortZ` returns one z per entry, so every hit index has one. */
+function zOfHit(z, index) {
+    const value = z[index];
+    if (value === undefined)
+        throw new Error(`ySortZ returned no z for pointer hit ${index}`);
+    return value;
+}

package/dist/render-sort.js

@@ -4,6 +4,13 @@ export function isYSortParticipant(value) {
         typeof value.layer === 'number' &&
         typeof value.setSortZ === 'function');
 }
+/** The Y of the entry at `index`, which `ySortZ` only reads for indices it grouped from `entries`. */
+function entryY(entries, index) {
+    const entry = entries[index];
+    if (!entry)
+        throw new Error(`ySortZ has no entry at index ${index}`);
+    return entry.y;
+}
 /**
  * Z per entry under y-sort. Each layer keeps its 0.01 band; within a band,
  * lower Y gets a higher z (renders in front), and exact Y ties keep input
@@ -22,14 +29,13 @@ export function ySortZ(entries) {
         else
             byLayer.set(entry.layer, [index]);
     }
-    const layers = [...byLayer.keys()].sort((a, b) => a - b);
+    const layers = [...byLayer].sort(([a], [b]) => a - b);
     const z = new Array(entries.length);
-    for (const [i, layer] of layers.entries()) {
-        const indices = byLayer.get(layer);
-        const next = layers[i + 1];
+    for (const [i, [layer, indices]] of layers.entries()) {
+        const next = layers[i + 1]?.[0];
         const width = next === undefined ? 0.01 : Math.min(0.01, (next - layer) * 0.01);
         // Stable sort: back-to-front is descending Y, ties keep input order.
-        const ordered = [...indices].sort((a, b) => entries[b].y - entries[a].y);
+        const ordered = [...indices].sort((a, b) => entryY(entries, b) - entryY(entries, a));
         const step = width / (ordered.length + 1);
         for (const [rank, index] of ordered.entries()) {
             z[index] = layer * 0.01 + (rank + 1) * step;

package/dist/report-rejection.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Observes a task the engine starts without awaiting (a texture settling, an
+ * AudioContext state change): its rejection is logged once as a `[waica]`
+ * error instead of surfacing as an unhandled rejection. Internal; not part of
+ * the package entry.
+ */
+export declare function reportRejection(task: Promise<unknown>, context: string): void;

package/dist/report-rejection.js

@@ -0,0 +1,12 @@
+/**
+ * Observes a task the engine starts without awaiting (a texture settling, an
+ * AudioContext state change): its rejection is logged once as a `[waica]`
+ * error instead of surfacing as an unhandled rejection. Internal; not part of
+ * the package entry.
+ */
+export function reportRejection(task, context) {
+    task.catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`[waica] ${context} failed: ${message}`);
+    });
+}

package/dist/runtime-bridge.d.ts

@@ -15,9 +15,11 @@ export type RuntimeMode = 'paused' | 'real-time';
  * (ADR 0019) announces that every metadata carries `assets: { pending,
  * loaded, failed }` from `game.assets.status`, so a Run Session can wait
  * for Assets Ready (`pending === 0`) at readiness, after a `scene`
- * operation and before a screenshot.
+ * operation and before a screenshot. `camera-effects` (issue #74, ADR 0020)
+ * announces that every snapshot carries `camera: { shake, fade, flash }`
+ * from `game.cameraEffects`; the `scene` operation stays a hard cut.
  */
-export declare const RUNTIME_BRIDGE_CAPABILITIES: readonly ['click', 'scene', 'fixed-step', 'assets'];
+export declare const RUNTIME_BRIDGE_CAPABILITIES: readonly ['click', 'scene', 'fixed-step', 'assets', 'camera-effects'];
 export interface RuntimeMetadata {
     bridgeVersion: typeof RUNTIME_BRIDGE_PROTOCOL_VERSION;
     engineVersion: string;
@@ -104,6 +106,10 @@ export declare class EngineRuntimeBridge implements RuntimeBridge {
     metadata(): RuntimeMetadata;
     inspect(filters?: RuntimeSnapshotFilters): RuntimeSnapshot;
     control(request: RuntimeControlRequest): RuntimeControlResult;
+    private injectAction;
+    /** Advances whole Simulation Steps while paused. */
+    private step;
+    private loadScene;
     /** Counts one Simulation Step, whoever ran it (paused stepping or real-time playback). */
     private advance;
     unregister(): void;

package/dist/runtime-bridge.js

@@ -14,9 +14,17 @@ export const RUNTIME_BRIDGE_SYMBOL = Symbol.for('@waica/runtime-bridge/v1');
  * (ADR 0019) announces that every metadata carries `assets: { pending,
  * loaded, failed }` from `game.assets.status`, so a Run Session can wait
  * for Assets Ready (`pending === 0`) at readiness, after a `scene`
- * operation and before a screenshot.
+ * operation and before a screenshot. `camera-effects` (issue #74, ADR 0020)
+ * announces that every snapshot carries `camera: { shake, fade, flash }`
+ * from `game.cameraEffects`; the `scene` operation stays a hard cut.
  */
-export const RUNTIME_BRIDGE_CAPABILITIES = ['click', 'scene', 'fixed-step', 'assets'];
+export const RUNTIME_BRIDGE_CAPABILITIES = [
+    'click',
+    'scene',
+    'fixed-step',
+    'assets',
+    'camera-effects',
+];
 export class RuntimeBridgeOperationError extends Error {
     code;
     availableActions;
@@ -88,29 +96,11 @@ export class EngineRuntimeBridge {
             case 'press':
             case 'hold':
             case 'release':
-                if (!this.host.injectAction(request.action, request.operation)) {
-                    const available = this.host.availableActions();
-                    throw new RuntimeBridgeOperationError('runtime-operation-failed', `Unknown action "${request.action}". Available actions: ${available.join(', ') || '(none)'}.`, available);
-                }
+                this.injectAction(request);
                 break;
-            case 'step': {
-                if (this.mode !== 'paused') {
-                    throw new RuntimeBridgeOperationError('runtime-invalid-state', 'step is only available while the Runtime Bridge is paused.');
-                }
-                // A caller-chosen dt is rejected outright, never ignored: a pre-ADR-0014
-                // client that still sends one would otherwise believe it stepped by it.
-                if ('dt' in request) {
-                    throw new RuntimeBridgeOperationError('runtime-operation-failed', 'step takes no dt: it advances whole Simulation Steps of 1/60 s each; pass frames (1 through 600) instead.');
-                }
-                const frames = request.frames ?? 1;
-                if (!Number.isInteger(frames) || frames < 1 || frames > 600) {
-                    throw new RuntimeBridgeOperationError('runtime-operation-failed', 'frames must be an integer from 1 through 600.');
-                }
-                for (let index = 0; index < frames; index += 1) {
-                    this.host.step(() => this.advance());
-                }
+            case 'step':
+                this.step(request);
                 break;
-            }
             case 'click': {
                 if (!Number.isFinite(request.x) || !Number.isFinite(request.y)) {
                     throw new RuntimeBridgeOperationError('runtime-operation-failed', 'x and y must be finite numbers.');
@@ -118,13 +108,9 @@ export class EngineRuntimeBridge {
                 this.host.click(request.x, request.y);
                 break;
             }
-            case 'scene': {
-                if (!this.host.loadScene(request.scene)) {
-                    const available = this.host.availableScenes();
-                    throw new RuntimeBridgeOperationError('runtime-operation-failed', `Unknown scene "${request.scene}". Available scenes: ${available.join(', ') || '(none)'}.`, undefined, available);
-                }
+            case 'scene':
+                this.loadScene(request.scene);
                 break;
-            }
             default: {
                 const unsupported = request;
                 throw new RuntimeBridgeOperationError('runtime-operation-failed', `Unsupported runtime control operation "${unsupported.operation}".`);
@@ -132,6 +118,36 @@ export class EngineRuntimeBridge {
         }
         return { ...this.metadata(), heldActions: this.host.heldActions() };
     }
+    injectAction(request) {
+        if (this.host.injectAction(request.action, request.operation))
+            return;
+        const available = this.host.availableActions();
+        throw new RuntimeBridgeOperationError('runtime-operation-failed', `Unknown action "${request.action}". Available actions: ${available.join(', ') || '(none)'}.`, available);
+    }
+    /** Advances whole Simulation Steps while paused. */
+    step(request) {
+        if (this.mode !== 'paused') {
+            throw new RuntimeBridgeOperationError('runtime-invalid-state', 'step is only available while the Runtime Bridge is paused.');
+        }
+        // A caller-chosen dt is rejected outright, never ignored: a pre-ADR-0014
+        // client that still sends one would otherwise believe it stepped by it.
+        if ('dt' in request) {
+            throw new RuntimeBridgeOperationError('runtime-operation-failed', 'step takes no dt: it advances whole Simulation Steps of 1/60 s each; pass frames (1 through 600) instead.');
+        }
+        const frames = request.frames ?? 1;
+        if (!Number.isInteger(frames) || frames < 1 || frames > 600) {
+            throw new RuntimeBridgeOperationError('runtime-operation-failed', 'frames must be an integer from 1 through 600.');
+        }
+        for (let index = 0; index < frames; index += 1) {
+            this.host.step(() => this.advance());
+        }
+    }
+    loadScene(scene) {
+        if (this.host.loadScene(scene))
+            return;
+        const available = this.host.availableScenes();
+        throw new RuntimeBridgeOperationError('runtime-operation-failed', `Unknown scene "${scene}". Available scenes: ${available.join(', ') || '(none)'}.`, undefined, available);
+    }
     /** Counts one Simulation Step, whoever ran it (paused stepping or real-time playback). */
     advance() {
         this.frame += 1;

package/dist/runtime-inspection.d.ts

@@ -1,4 +1,5 @@
 import type { AudioChannelState, LiveSoundInfo } from './audio/types.js';
+import type { CameraEffectsState } from './camera-effects.js';
 import type { Game } from './game.js';
 import type { RuntimeMetadata } from './runtime-bridge.js';
 import type { StatValue } from './stats.js';
@@ -106,6 +107,13 @@ export interface RuntimeSnapshotUi {
         values: Record<string, StatValue | ProjectionMarker> | ProjectionMarker;
     }>;
 }
+/**
+ * `game.cameraEffects.state` (issue #74 CA-17), beside `time` and `ui`: the
+ * shake offset (world units, added to the camera only while drawing) and
+ * the Fade and Flash layers' `#rrggbb` color and opacity, all from the
+ * last completed Simulation Step. Emitted unconditionally — never filtered.
+ */
+export type RuntimeSnapshotCamera = CameraEffectsState;
 export interface RuntimeSnapshot extends RuntimeMetadata {
     stats: Record<string, StatValue>;
     /** The live scene's name (its catalog key), or null with no scene loaded. */
@@ -115,6 +123,7 @@ export interface RuntimeSnapshot extends RuntimeMetadata {
     audio: RuntimeSnapshotAudio;
     time: RuntimeSnapshotTime;
     ui: RuntimeSnapshotUi;
+    camera: RuntimeSnapshotCamera;
 }
 export declare const RUNTIME_PROJECTION_LIMITS: {
     readonly depth: 5;