@waica/engine 0.17.0 → 0.19.0

package/README.md

@@ -194,6 +194,28 @@ game.time.now  // seconds of Game Time since the Game started
 - **Scope.** A timer or tween is scene-scoped by default: `unloadScene()` and every scene load — including a Game's first — cancel it, running no callback. `{ scope: 'session' }` survives a scene change. `{ owner: entity }` cancels it immediately when that entity is destroyed, whatever its scope; an owner already dead at scheduling time yields an inactive handle. `game.dispose()` cancels everything in both scopes. This is the opposite default from `game.onUpdate`/`game.events` (ADR 0011), which survive a scene change by construction, and the same one `game.audio.play()` uses (ADR 0012) — see ADR 0017 for why timers follow audio's rule rather than the host-subscription one: a timer's callback almost always closes over the scene that scheduled it.
 - **No Promises.** Nothing here returns one, and nothing is async — a `.then` continuation is not step-exact (it runs after the whole synchronous frame), which is exactly what `game.time` exists to avoid. Compose delays with `after`, not `await`.
 
+## game.cameraEffects: shake, fade and flash
+
+Every `Game` owns a `cameraEffects: CameraEffects` service beside `game.camera`, which stays the plain `THREE.OrthographicCamera` (ADR 0020). Effects advance only inside a Simulation Step, right after the scene camera, so nothing moves while the Game is not simulating, is stopped, or a Run Session is paused; `step { frames: N }` advances them by exactly N steps.
+
+```ts
+game.cameraEffects.shake({ intensity: 0.3, seconds: 0.25 })          // world units, decaying to 0
+const out = game.cameraEffects.fade({ to: 'black', seconds: 0.4 })   // 'black' | 'white' | '#rrggbb' | 'clear'
+game.cameraEffects.flash({ color: 'white', seconds: 0.15 })          // up to 1, back to exactly 0
+out.cancel()                                                          // opacity stays where it was
+await out.done                                                        // true: completed; false: cancelled or replaced
+```
+
+- **Shake.** An offset added to the camera only while drawing (the world render and Anchored Pieces), never to the base center that follow, deadzone and limits compute, so smoothing never feeds on it. Each axis stays within `intensity · (1 − ease(t / seconds))` (`easing` takes `game.time`'s names, `'linear'` by default) and is exactly `{0, 0}` from `seconds` on. Overlapping shakes apply the largest current amplitude. The jitter is deterministic per Simulation Step (no `Math.random`), so a Run Session reproduces it. It is not re-clamped to `limits`: at a map edge up to `intensity` beyond them can show. Under a fixed `resolution` the offset snaps to whole screen pixels; the base center is never snapped.
+- **Fade.** Carries an HTML layer over the game viewport — inside the letterbox, above the world, UI Pieces and Anchored Pieces — from its current opacity to 1 in the given color, or to 0 with `'clear'`, and then holds. A new `fade` cancels a running one (its `done` resolves `false`) and starts from the current opacity.
+- **Flash.** Its own layer above the Fade, shown at opacity 1 and returned to exactly 0 over `seconds`; it never changes the Fade.
+- **Scope.** A Fade is session-scoped: it survives `unloadScene()` and every scene load with its color, opacity and any running progress, so it can cover a scene change. A Shake or Flash is scene-scoped: `unloadScene()` ends it, running no callback (its `done` resolves `false`). `game.dispose()` ends everything and removes the layers. This follows the audio and timer scope notes above (ADR 0011, ADR 0017): a transition fade is exactly the case that must cross a scene change.
+- **Invalid arguments never throw.** A non-finite or negative `seconds`/`intensity`, an unknown color or an unknown easing logs one `[waica]` warning and returns a handle whose `done` resolves `false`; no effect changes.
+- **Scene Transition.** `SceneTransition` takes `fadeSeconds` (default 0: a hard cut) and `fadeColor` (default `'black'`): it fades out over `fadeSeconds`, loads its destination, then clears over `fadeSeconds` in the incoming scene. Simulation and input keep running; the component ignores further triggers during its outgoing fade. The Runtime Bridge `scene` operation stays a hard cut.
+- **Runtime Snapshot.** Every snapshot carries `camera: { shake: { x, y }, fade: { color, opacity }, flash: { color, opacity } }` from the last completed step, under the `'camera-effects'` capability.
+
+A Fade to a color that nothing clears leaves the view covered; the engine does not warn.
+
 ## game.ui.attach: Anchored Pieces
 
 A UI Piece shown with `game.ui.show(name)` is a screen-space singleton. `game.ui.attach(piece, entity, options?)` instead creates an **Anchored Piece**: a new instance of the piece that follows `entity` across the screen, with its own shadow root and its own values. Every call is a new instance — five orcs can each carry a `health-bar` — and the screen piece of the same name is never mounted, shown or changed by it.
@@ -224,3 +246,25 @@ bar.remove()
 - **Runtime Snapshot.** Every snapshot carries `ui: { shown, anchored }`: the visible screen pieces by name, and each live instance in creation order as `{ piece, entity, x, y, clipped, values }`, with the pixel coordinates of its last placement; `values` are bounded like component state (a string over 4 KiB becomes a `$waica: 'truncated'` marker), and once every entity is cut the 1 MiB snapshot cap drops instances from the end.
 
 The trade-off is ADR 0018's: Anchored Pieces are HTML drawn over the game view, not text rendered in the three scene. They always draw above the world — a label behind a tree draws over it — hide with the rest of the UI overlay while the Game is not simulating (including the editor's edit mode), and do not align to a pixel-art grid.
+
+## game.assets: textures, preload and Assets Ready
+
+Every `Game` owns an `assets: AssetLoader` — the engine's texture cache. `Sprite`, `AnimatedSprite` and `Tilemap` load through it: one fetch and one base texture per URL for the whole life of the Game, and every component gets its own clone of that base (three shares the GPU upload between clones with equal sampler parameters and reference-counts their disposal), so eight crates cost one image. A scene load never waits for images — `loadScene` stays synchronous — and **Assets Ready** is a promise beside it (ADR 0019):
+
+```ts
+game.registerSceneCatalog({ scenes, registry })
+game.loadSceneByName('main')
+await game.assets.ready() // every texture requested so far has loaded, or failed and been recorded
+game.start()
+
+await game.assets.preload(['waica:iso-crate', 'src/art/tree.png']) // ahead of a later scene
+game.assets.status // { pending, loaded, failed } — a fresh object on every read
+```
+
+- **Cache rule.** Keyed by the URL as received: components pass what `resolveProps` resolved, `preload` resolves each uri through the registered scene catalog first (identity before `registerSceneCatalog`, and for a uri the resolver leaves unchanged). N requests of one URL call the backend once; `status.loaded` counts URLs, not requests. Keep-all: `unloadScene()`, `loadScene` and `loadSceneByName` never dispose, evict or reset an entry — `main → cave → main` re-downloads nothing — and only `game.dispose()` disposes every cached base, exactly once, leaving `status` at zeros. Components dispose only their own clone.
+- **`ready()`.** Resolves the first time `pending` is 0 after the call: at once when nothing is pending, otherwise once every URL requested before or while waiting has settled. Readiness is relative to the moment it is awaited — a later spawn that requests new art reopens it until that art settles — and concurrent callers all resolve. It never rejects, and it has no timeout: a stalled image with no error event holds a host that awaits it (a Run Session is bounded by the MCP's session timeout instead).
+- **`preload(uris)`.** Requests every uri and resolves once all of them settled, failures included. A component that later asks for the same resolved URL is a cache hit.
+- **`status`.** `pending` is current; `loaded` and `failed` are cumulative for the Game and only grow until `dispose()`. A host that wants a loading bar reads it from `game.onUpdate`.
+- **Failure rule.** A texture that fails to load is recorded, not thrown: `console.warn('[waica] assets: failed to load "<url>"', error)` once per Game per URL, `failed` counts it, `ready()` resolves, and every consumer falls back to its flat material — `Sprite` and `Tilemap` drop the failed map, dispose their clone and render their `color` again; `AnimatedSprite` never installs the failed sheet's clone, so that sheet's frames show a plain white quad. Asking for that URL again on the same Game is a cached failure — no retry, no second warning.
+- **`GameOptions.textures`.** Replaces the real `THREE.TextureLoader` backend for that Game (ADR 0013's seam, applied to textures): `happy-dom` decodes no images, so a project's own tests inject a backend that resolves at once. The Runtime Bridge reports `assets` in its metadata under the `'assets'` capability, and a Run Session waits for `pending === 0` at readiness, after a `scene` operation and before every screenshot.
+

package/dist/assets/asset-loader.d.ts

@@ -0,0 +1,76 @@
+import * as THREE from 'three';
+import { type TextureBackend } from './texture-backend.js';
+/** `game.assets.status`: a fresh snapshot of the cache's counters, cumulative for the Game. */
+export interface AssetStatus {
+    /** Requested URLs that have not settled yet. */
+    pending: number;
+    /** Settled URLs whose image arrived. */
+    loaded: number;
+    /** Settled URLs whose load failed — recorded, warned once, never retried. */
+    failed: number;
+}
+export type TextureOutcome = 'loaded' | 'failed';
+/** What a consumer gets from `game.assets.texture(url)`: its own clone, and when the image settled. */
+export interface TextureHandle {
+    texture: THREE.Texture;
+    settled: Promise<TextureOutcome>;
+}
+export interface AssetLoaderOptions {
+    /** Replaces the real `THREE.TextureLoader` implementation (ADR 0013); defaults to it. */
+    backend?: TextureBackend;
+    /**
+     * Resolves a uri for `preload()` the way the scene loader resolves every
+     * prefab's string prop (`resolveProps` in scene.ts). Looked up on every
+     * call: `Game` wires this to its registered scene catalog, which survives
+     * `unloadScene()`. Defaults to identity, so an already-resolved or
+     * unresolvable uri passes through unchanged either way.
+     */
+    resolveAsset?: (uri: string) => string;
+}
+/**
+ * The engine's texture cache (`game.assets`, ADR 0019): keep-all for the
+ * Game's whole life, keyed by the URL as received, one backend load and one
+ * base texture per URL. `ready()` is the **Assets Ready** signal — a
+ * promise beside the synchronous scene load — and a failed image is
+ * recorded, not thrown, so it never breaks a host or a Run Session that
+ * awaits it. `unloadScene()` never touches this cache; `dispose()` empties it.
+ */
+export declare class AssetLoader {
+    private readonly backend;
+    private readonly resolveAsset;
+    private readonly entries;
+    private pendingCount;
+    private loadedCount;
+    private failedCount;
+    constructor(options?: AssetLoaderOptions);
+    /** A fresh object on every read: `pending` is current, `loaded` and `failed` only grow until `dispose()`. */
+    get status(): AssetStatus;
+    /**
+     * The consumer entry (Sprite, AnimatedSprite, Tilemap): requests `url`
+     * — already resolved by `resolveProps` — and returns a clone of its base
+     * right away, so a mesh exists before the image arrives, plus the
+     * settlement of that URL, which also fires on a cache hit.
+     */
+    texture(url: string): TextureHandle;
+    /**
+     * Requests every uri ahead of time, each resolved through the registered
+     * scene catalog. Resolves once all of them settled, failures included —
+     * a failure still only warns once, the same as a component's request.
+     */
+    preload(uris: string[]): Promise<void>;
+    /**
+     * Assets Ready: resolves the first time `pending` is 0 after the call —
+     * at once when nothing is pending, otherwise once every URL requested
+     * before or while waiting has settled. Never rejects. Resolves after the
+     * `settled` continuations consumers chained before the call, so a host
+     * that does `await game.assets.ready()` then `game.start()` renders its
+     * first frame with the textures in place.
+     */
+    ready(): Promise<void>;
+    /** Disposes every cached base exactly once and forgets everything; called by `Game.dispose()`. */
+    dispose(): void;
+    private request;
+    private load;
+    /** One backend load as an outcome, never a rejection — a backend that throws synchronously included. */
+    private attempt;
+}

package/dist/assets/asset-loader.js

@@ -0,0 +1,138 @@
+import * as THREE from 'three';
+import { ThreeTextureBackend } from './texture-backend.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
+ * clone — and, while the image is still missing, makes the renderer warn
+ * on every frame. Sharing the Source and mirroring `version` instead marks
+ * the clone uploadable exactly when the base is, and three then keeps one
+ * GPU texture per (Source, sampler parameters), reference-counted across
+ * clones (WebGLTextures). Colour space is the base's; filters, repeat and
+ * offset are the clone's own.
+ */
+function cloneOf(base) {
+    const clone = new THREE.Texture();
+    clone.source = base.source;
+    clone.colorSpace = base.colorSpace;
+    clone.version = base.version;
+    return clone;
+}
+/**
+ * The engine's texture cache (`game.assets`, ADR 0019): keep-all for the
+ * Game's whole life, keyed by the URL as received, one backend load and one
+ * base texture per URL. `ready()` is the **Assets Ready** signal — a
+ * promise beside the synchronous scene load — and a failed image is
+ * recorded, not thrown, so it never breaks a host or a Run Session that
+ * awaits it. `unloadScene()` never touches this cache; `dispose()` empties it.
+ */
+export class AssetLoader {
+    backend;
+    resolveAsset;
+    entries = new Map();
+    pendingCount = 0;
+    loadedCount = 0;
+    failedCount = 0;
+    constructor(options = {}) {
+        this.backend = options.backend ?? new ThreeTextureBackend();
+        this.resolveAsset = options.resolveAsset ?? ((uri) => uri);
+    }
+    /** A fresh object on every read: `pending` is current, `loaded` and `failed` only grow until `dispose()`. */
+    get status() {
+        return { pending: this.pendingCount, loaded: this.loadedCount, failed: this.failedCount };
+    }
+    /**
+     * The consumer entry (Sprite, AnimatedSprite, Tilemap): requests `url`
+     * — already resolved by `resolveProps` — and returns a clone of its base
+     * right away, so a mesh exists before the image arrives, plus the
+     * settlement of that URL, which also fires on a cache hit.
+     */
+    texture(url) {
+        const entry = this.request(url);
+        const texture = cloneOf(entry.base);
+        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) => {
+                if (outcome === 'loaded')
+                    texture.version = entry.base.version;
+            });
+        }
+        return { texture, settled: entry.settled };
+    }
+    /**
+     * Requests every uri ahead of time, each resolved through the registered
+     * scene catalog. Resolves once all of them settled, failures included —
+     * a failure still only warns once, the same as a component's request.
+     */
+    async preload(uris) {
+        await Promise.all(uris.map((uri) => this.request(this.resolveAsset(uri)).settled));
+    }
+    /**
+     * Assets Ready: resolves the first time `pending` is 0 after the call —
+     * at once when nothing is pending, otherwise once every URL requested
+     * before or while waiting has settled. Never rejects. Resolves after the
+     * `settled` continuations consumers chained before the call, so a host
+     * that does `await game.assets.ready()` then `game.start()` renders its
+     * first frame with the textures in place.
+     */
+    async ready() {
+        while (this.pendingCount > 0) {
+            const inFlight = [...this.entries.values()].filter((entry) => entry.outcome === null);
+            await Promise.all(inFlight.map((entry) => entry.settled));
+        }
+    }
+    /** Disposes every cached base exactly once and forgets everything; called by `Game.dispose()`. */
+    dispose() {
+        for (const entry of this.entries.values())
+            entry.base.dispose();
+        this.entries.clear();
+        this.pendingCount = 0;
+        this.loadedCount = 0;
+        this.failedCount = 0;
+    }
+    request(url) {
+        const existing = this.entries.get(url);
+        if (existing)
+            return existing;
+        const base = new THREE.Texture();
+        base.colorSpace = THREE.SRGBColorSpace;
+        const entry = { base, outcome: null, settled: Promise.resolve('failed') };
+        // Registered and counted before the backend runs, so a backend that
+        // throws synchronously still settles this very entry.
+        this.entries.set(url, entry);
+        this.pendingCount += 1;
+        entry.settled = this.load(url, entry);
+        return entry;
+    }
+    async load(url, entry) {
+        const attempt = await this.attempt(url);
+        // A dispose() in flight already forgot this entry and disposed its base:
+        // nothing to write, warn about or count. Only the settlement is still
+        // owed, so a consumer awaiting it never hangs; it reports what the
+        // backend did.
+        if (this.entries.get(url) !== entry)
+            return attempt.outcome;
+        if (attempt.outcome === 'loaded') {
+            // The image lands on the base's Source, which every clone shares.
+            entry.base.image = attempt.texture.image;
+            entry.base.needsUpdate = true;
+            this.loadedCount += 1;
+        }
+        else {
+            console.warn(`[waica] assets: failed to load "${url}"`, attempt.error);
+            this.failedCount += 1;
+        }
+        entry.outcome = attempt.outcome;
+        this.pendingCount -= 1;
+        return attempt.outcome;
+    }
+    /** One backend load as an outcome, never a rejection — a backend that throws synchronously included. */
+    async attempt(url) {
+        try {
+            return { outcome: 'loaded', texture: await this.backend.load(url) };
+        }
+        catch (error) {
+            return { outcome: 'failed', error };
+        }
+    }
+}

package/dist/assets/texture-backend.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from 'three';
+/**
+ * The seam between `game.assets` and the browser (ADR 0013's move, applied
+ * to textures — ADR 0019). `load` resolves once the image behind `url` is
+ * decoded, with a texture whose `image` the loader adopts into its own
+ * cached base; it rejects on a load error and never throws synchronously.
+ * `happy-dom` decodes no images, so a test injects `FakeTextureBackend`
+ * (assets/test-helpers.ts) through `GameOptions.textures`.
+ */
+export interface TextureBackend {
+    load(url: string): Promise<THREE.Texture>;
+}
+/** The real implementation: one `THREE.TextureLoader` per Game, wrapped in a promise. */
+export declare class ThreeTextureBackend implements TextureBackend {
+    private readonly loader;
+    load(url: string): Promise<THREE.Texture>;
+}

package/dist/assets/texture-backend.js

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+/** The real implementation: one `THREE.TextureLoader` per Game, wrapped in a promise. */
+export class ThreeTextureBackend {
+    loader = new THREE.TextureLoader();
+    load(url) {
+        return new Promise((resolve, reject) => {
+            try {
+                this.loader.load(url, resolve, undefined, reject);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+}

package/dist/camera-effects.d.ts

@@ -0,0 +1,142 @@
+import type { ViewportRect } from './anchored-pieces.js';
+import { type EasingName } from './game-time.js';
+/** A Camera Effect color: a name or a six-digit hex, case-insensitive. */
+export type CameraEffectColor = 'black' | 'white' | `#${string}`;
+export interface ShakeOptions {
+    /** The largest offset, in world units, on each axis. Finite and >= 0. */
+    intensity: number;
+    /** Seconds of Game Time until the offset reaches 0. Finite and >= 0. */
+    seconds: number;
+    /** How the amplitude decays from `intensity` to 0; default `'linear'`. */
+    easing?: EasingName;
+}
+export interface FadeOptions {
+    /** The color to carry the view to (opacity 1), or `'clear'` (opacity 0, color kept). */
+    to: CameraEffectColor | 'clear';
+    /** Seconds of Game Time from the current opacity to the target. Finite and >= 0. */
+    seconds: number;
+    easing?: EasingName;
+}
+export interface FlashOptions {
+    color: CameraEffectColor;
+    /** Seconds of Game Time from opacity 1 back to 0. Finite and >= 0. */
+    seconds: number;
+}
+/** What `shake`, `fade` and `flash` hand back. */
+export interface CameraEffectHandle {
+    /** Stops the effect where it is. Idempotent; resolves `done` with false. */
+    cancel(): void;
+    /** True once the effect completed; false if cancelled, replaced, ended by its scope or invalid. */
+    readonly done: Promise<boolean>;
+    /**
+     * True once a *later* call to the same kind of effect has taken over
+     * before this one ended on its own — false while it is still running,
+     * and false once it ends on its own accord (completes, is cancelled, or
+     * ends by its scope) with nothing else in its place. A Shake never
+     * supersedes another (CA-7: overlapping shakes coexist), so this is
+     * always false for a Shake handle. Unlike `done`, this reads
+     * synchronously: a Promise only notifies its `.then()` in a microtask,
+     * which can land well after a caller scheduled on Game Time needs the
+     * answer on an exact Simulation Step (PR #98 review, `scene-
+     * transition.ts`).
+     */
+    readonly superseded: boolean;
+}
+/** The effects' state after the last completed Simulation Step (read-only copy). */
+export interface CameraEffectsState {
+    /** The offset, in world units, added to the camera only while drawing. */
+    shake: {
+        x: number;
+        y: number;
+    };
+    fade: {
+        color: string;
+        opacity: number;
+    };
+    flash: {
+        color: string;
+        opacity: number;
+    };
+}
+export interface CameraEffectsOptions {
+    /** Where the Fade and Flash layers mount (the canvas's parent); resolved lazily. */
+    host: () => HTMLElement;
+    /** One screen pixel in world units under a fixed resolution, or null (no snap). */
+    pixel: () => number | null;
+}
+declare const ADVANCE: unique symbol;
+declare const LAYOUT: unique symbol;
+/**
+ * Screen-level Camera Effects (issue #74, ADR 0020): Shake, Fade and Flash,
+ * beside `game.camera` and never written into it. They advance only inside
+ * a Simulation Step, right after the scene camera (spec inference 9), so
+ * nothing moves while the Game is not simulating or a Run Session is
+ * paused. A Shake is an offset the Game adds to the camera only while it
+ * draws; a Fade and a Flash are HTML layers over the letterboxed game
+ * viewport, above the UI overlay. A Fade is session-scoped (it survives a
+ * scene change, ADR 0011); a Shake or Flash dies with its scene.
+ */
+export declare class CameraEffects {
+    private readonly options;
+    private steps;
+    private readonly shakes;
+    private offset;
+    private fadeRun;
+    private flashRun;
+    private readonly fadeLayer;
+    private readonly flashLayer;
+    private rect;
+    constructor(options: CameraEffectsOptions);
+    /** A fresh copy of the effects after the last completed Simulation Step. */
+    get state(): CameraEffectsState;
+    /**
+     * Jitters the drawn view by up to `intensity` world units per axis,
+     * decaying to 0 over `seconds`. Overlapping shakes apply the largest
+     * current amplitude. Not re-clamped to the scene camera's limits; snapped
+     * to whole screen pixels under a fixed resolution.
+     */
+    shake(options: ShakeOptions): CameraEffectHandle;
+    /**
+     * Carries the Fade layer from its current opacity to 1 in `to`'s color,
+     * or to 0 with `'clear'`, over `seconds`; the result then holds. A new
+     * fade cancels a running one (its `done` resolves false).
+     */
+    fade(options: FadeOptions): CameraEffectHandle;
+    /**
+     * Shows the Flash layer at opacity 1 in `color` and returns it to exactly
+     * 0 over `seconds`, independent of (and drawn above) the Fade. A new flash
+     * replaces a running one.
+     */
+    flash(options: FlashOptions): CameraEffectHandle;
+    /**
+     * Ends every Shake and Flash (their `done` resolves false) and keeps the
+     * Fade — opacity, color and any running progress. Called by
+     * `Game.unloadScene()`.
+     */
+    unloadScene(): void;
+    /** Ends every effect and removes the layers (`Game.dispose()`). */
+    dispose(): void;
+    /** Engine-internal: see advanceCameraEffects. */
+    [ADVANCE](): void;
+    /** Engine-internal: see layoutCameraEffects. */
+    [LAYOUT](rect: ViewportRect): void;
+    /** Normalized progress of a timed effect after the current step: 1 at (and past) its end. */
+    private progress;
+    private advanceShakes;
+    /** Mirrors both layers' state onto their elements, mounting them on first need. */
+    private draw;
+    private mount;
+    /** Sizes a layer to the game viewport (the whole host until the Game lays it out). */
+    private place;
+    private invalid;
+}
+/**
+ * Engine-internal: advances every Camera Effect by exactly one Simulation
+ * Step. `Game.simulateStep()` calls it right after the scene camera, so
+ * nothing advances while the Game is not simulating. Not re-exported from
+ * the package entry.
+ */
+export declare function advanceCameraEffects(effects: CameraEffects): void;
+/** Engine-internal: sizes the Fade and Flash layers to the game viewport (`Game.resize()`). */
+export declare function layoutCameraEffects(effects: CameraEffects, rect: ViewportRect): void;
+export {};