@johnmorrisdotca/chikyu-earth 0.4.0 → 0.7.0

package/dist/space/ephemeris.js

@@ -0,0 +1,162 @@
+// Where the Sun, the Moon and the planets are, as seen from the centre of the Earth, for any date. astronomy-engine (MIT) does the sums; this file asks it
+// for a handful of vectors, keeps them in the scene's axes, and lets a draw interpolate between two answers a second apart instead of asking at every frame.
+import { Body, GeoVector, HelioVector, SiderealTime } from "astronomy-engine";
+/**
+ * The planets drawn, nearest the Sun first.
+ *
+ * @example
+ * ```ts
+ * import { PLANETS } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(PLANETS.join(", "));
+ * ```
+ */
+export const PLANETS = ["Mercury", "Venus", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"];
+/** Equatorial J2000 axes (x to the vernal equinox, z to the north pole) to the scene's (y up). */
+const scene = (v) => [v.x, v.z, -v.y];
+const AU_KM = 149_597_870.7;
+/**
+ * The Earth's radius in kilometres, the unit of the scene's distances.
+ *
+ * @example
+ * ```ts
+ * import { EARTH_RADIUS_KM } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(EARTH_RADIUS_KM);
+ * ```
+ */
+export const EARTH_RADIUS_KM = 6371;
+/**
+ * Earth radii in one astronomical unit.
+ *
+ * @example
+ * ```ts
+ * import { AU_IN_EARTH_RADII } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(Math.round(AU_IN_EARTH_RADII));
+ * ```
+ */
+export const AU_IN_EARTH_RADII = AU_KM / EARTH_RADIUS_KM;
+/**
+ * The state of the sky at `ms`: nine vectors and an angle, in a few tenths of a millisecond. It needs astronomy-engine (an optional peer dependency).
+ *
+ * @param ms - A moment, in milliseconds since the Unix epoch.
+ * @returns The Sun, the Moon and the planets as seen from the Earth's centre, and how far the Earth has turned.
+ *
+ * @example
+ * ```ts
+ * import { frameAt } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const frame = frameAt(Date.UTC(2026, 10, 2, 12));
+ * console.log(frame.moon.map((n) => n.toFixed(4)));
+ * ```
+ */
+export function frameAt(ms) {
+    const date = new Date(ms);
+    const planets = {};
+    for (const name of PLANETS)
+        planets[name] = scene(GeoVector(Body[name], date, true));
+    return {
+        ms,
+        sun: scene(GeoVector(Body.Sun, date, true)),
+        moon: scene(GeoVector(Body.Moon, date, true)),
+        planets,
+        spin: SiderealTime(date) * 15,
+    };
+}
+const lerp3 = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
+/**
+ * A frame between two others, `t` from 0 to 1. The spin goes the short way round, so a step under half a turn is right.
+ *
+ * @param a - The earlier frame.
+ * @param b - The later frame.
+ * @param t - How far from `a` to `b`, from 0 to 1.
+ * @returns The frame at that fraction.
+ *
+ * @example
+ * ```ts
+ * import { blend, frameAt } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const start = Date.UTC(2026, 10, 2);
+ * const middle = blend(frameAt(start), frameAt(start + 1000), 0.5);
+ * console.log(middle.ms - start);
+ * ```
+ */
+export function blend(a, b, t) {
+    const planets = {};
+    for (const name of PLANETS)
+        planets[name] = lerp3(a.planets[name], b.planets[name], t);
+    let turn = b.spin - a.spin;
+    turn -= 360 * Math.round(turn / 360);
+    return { ms: a.ms + (b.ms - a.ms) * t, sun: lerp3(a.sun, b.sun, t), moon: lerp3(a.moon, b.moon, t), planets, spin: a.spin + turn * t };
+}
+/**
+ * Answers for any moment from two real ones: `at(ms)` asks astronomy-engine only when `ms` leaves the span the last two answers cover, and then looks
+ * `stepMs` ahead, so playing time at a steady rate costs one pair of lookups every `stepMs` and every draw in between is arithmetic.
+ *
+ * @param initialStepMs - How far ahead the second answer looks, in milliseconds.
+ * @returns A track: `at(ms)` for a frame, `lookups` for how many times the ephemeris was asked, `reset()` and `setStep(ms)`.
+ *
+ * @example
+ * ```ts
+ * import { createTrack } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const track = createTrack(1000);
+ * const start = Date.UTC(2026, 10, 2);
+ * for (let step = 0; step < 10; step += 1) track.at(start + step * 50);
+ * console.log(track.lookups);
+ * ```
+ */
+export function createTrack(initialStepMs = 1000) {
+    let stepMs = initialStepMs;
+    let a;
+    let b;
+    let lookups = 0;
+    return {
+        at(ms) {
+            if (!a || !b || ms < a.ms || ms > b.ms) {
+                a = frameAt(ms);
+                b = frameAt(ms + stepMs);
+                lookups += 2;
+            }
+            return blend(a, b, (ms - a.ms) / (b.ms - a.ms));
+        },
+        /** How many times astronomy-engine has been asked for a frame. */
+        get lookups() {
+            return lookups;
+        },
+        reset() {
+            a = undefined;
+            b = undefined;
+        },
+        /** Look further ahead (a faster game clock): the next lookup uses it. */
+        setStep(ms) {
+            stepMs = Math.max(1, ms);
+            a = undefined;
+            b = undefined;
+        },
+    };
+}
+/** The path a planet takes round the Sun, as `count` points around the orbit that starts where the planet is at `ms`, relative to the Sun (scene axes, AU).
+ *
+ * @param name - The planet.
+ * @param ms - The moment the orbit starts at, in milliseconds since the Unix epoch.
+ * @param count - How many segments to cut the orbit into.
+ * @returns `count + 1` points, the last on the first.
+ *
+ * @example
+ * ```ts
+ * import { orbitPath } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const points = orbitPath("Jupiter", Date.UTC(2026, 10, 2), 12);
+ * console.log(points.length);
+ * ```
+ */
+export function orbitPath(name, ms, count = 96) {
+    const periodDays = { Mercury: 87.97, Venus: 224.7, Mars: 686.98, Jupiter: 4332.6, Saturn: 10759, Uranus: 30688, Neptune: 60182 }[name];
+    const points = [];
+    for (let i = 0; i <= count; i += 1)
+        points.push(scene(HelioVector(Body[name], new Date(ms + (i / count) * periodDays * 86_400_000))));
+    return points;
+}
+/** The Earth's own place relative to the Sun, for placing the orbits round the Sun's place in the Earth-centred scene. */

package/dist/space/index.d.ts

@@ -0,0 +1,3 @@
+export { AU_IN_EARTH_RADII, blend, createTrack, EARTH_RADIUS_KM, frameAt, orbitPath, PLANETS, type Frame, type PlanetName, type Vec3 } from "./ephemeris.ts";
+export { compress, MOON_COMPRESSED, placeAround, placeMoon, placeSun, RADIUS, SUN_COMPRESSED, truePosition, type ScaleMode } from "./scale.ts";
+export { plainPainter, type BodyDrawing, type BodyPainter } from "./scene.ts";

package/dist/space/index.js

@@ -0,0 +1,5 @@
+// The space view's pure parts: where the bodies are (astronomy-engine, an optional peer) and the two scales. They import on a server. The element is
+// `@johnmorrisdotca/chikyu-earth/space/element`.
+export { AU_IN_EARTH_RADII, blend, createTrack, EARTH_RADIUS_KM, frameAt, orbitPath, PLANETS } from "./ephemeris.js";
+export { compress, MOON_COMPRESSED, placeAround, placeMoon, placeSun, RADIUS, SUN_COMPRESSED, truePosition } from "./scale.js";
+export { plainPainter } from "./scene.js";

package/dist/space/scale.d.ts

@@ -0,0 +1,124 @@
+import { type Vec3 } from "./ephemeris.ts";
+/**
+ * The scale the space view is drawn in: `compressed` squeezes the distances so the Moon, the Sun and Neptune fit one view, and `true` keeps the real ones.
+ *
+ * @example
+ * ```ts
+ * import { placeMoon, type ScaleMode } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const mode: ScaleMode = "compressed";
+ * console.log(placeMoon(mode, [0.00257, 0, 0]));
+ * ```
+ */
+export type ScaleMode = "compressed" | "true";
+/**
+ * The Moon's distance in a compressed view, in Earth radii (the true one is about 60).
+ *
+ * @example
+ * ```ts
+ * import { MOON_COMPRESSED } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(MOON_COMPRESSED);
+ * ```
+ */
+export declare const MOON_COMPRESSED = 10;
+/**
+ * The Sun's distance from the Earth in a compressed view, in Earth radii (the true one is about 23,500). One astronomical unit is this long there.
+ *
+ * @example
+ * ```ts
+ * import { SUN_COMPRESSED } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(SUN_COMPRESSED);
+ * ```
+ */
+export declare const SUN_COMPRESSED = 44;
+/**
+ * A place in astronomical units from the Earth's centre, at true distance, in Earth radii.
+ *
+ * @param v - The place, in astronomical units.
+ * @returns The same direction, in Earth radii.
+ *
+ * @example
+ * ```ts
+ * import { truePosition } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(truePosition([0.00257, 0, 0]).map(Math.round));
+ * ```
+ */
+export declare const truePosition: (v: Vec3) => Vec3;
+/**
+ * The same direction at a compressed distance from the Earth: the Moon is 10 Earth radii away, and a body k times further than the Moon is k^0.25 times as far here.
+ *
+ * @param v - The place, in astronomical units from the Earth's centre.
+ * @returns The place in Earth radii, compressed; the centre stays at the centre.
+ *
+ * @example
+ * ```ts
+ * import { compress } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(compress([0.00257, 0, 0]), compress([0, 0, 0]));
+ * ```
+ */
+export declare function compress(v: Vec3): Vec3;
+/**
+ * The Moon, from the Earth's centre.
+ *
+ * @param mode - The scale.
+ * @param geo - The Moon's place in astronomical units from the Earth's centre.
+ * @returns Where to draw it, in Earth radii.
+ *
+ * @example
+ * ```ts
+ * import { placeMoon } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(placeMoon("true", [0.00257, 0, 0]).map(Math.round));
+ * ```
+ */
+export declare const placeMoon: (mode: ScaleMode, geo: Vec3) => Vec3;
+/**
+ * The Sun, from the Earth's centre: in a compressed view always 44 Earth radii away, in its real direction.
+ *
+ * @param mode - The scale.
+ * @param geo - The Sun's place in astronomical units from the Earth's centre.
+ * @returns Where to draw it, in Earth radii.
+ *
+ * @example
+ * ```ts
+ * import { placeSun } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(placeSun("compressed", [1, 0, 0]));
+ * ```
+ */
+export declare function placeSun(mode: ScaleMode, geo: Vec3): Vec3;
+/**
+ * A place `helio` astronomical units from the Sun (a planet, or a point on its orbit), round the Sun at `sun`. True: as it is. Compressed: the same direction from
+ * the Sun, at 44 Earth radii times its distance in astronomical units to the power 0.45, so the Earth's own orbit is the 44 and Neptune's is about 200 (30 times as far, really).
+ *
+ * @param mode - The scale.
+ * @param sun - Where the Sun is drawn, in Earth radii.
+ * @param helio - The place in astronomical units from the Sun.
+ * @returns Where to draw the place, in Earth radii from the Earth's centre.
+ *
+ * @example
+ * ```ts
+ * import { placeAround } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(placeAround("compressed", [44, 0, 0], [1, 0, 0]));
+ * ```
+ */
+export declare function placeAround(mode: ScaleMode, sun: Vec3, helio: Vec3): Vec3;
+/**
+ * Radii in Earth radii: the real ones, and ones large enough to see in a compressed view.
+ *
+ * @example
+ * ```ts
+ * import { RADIUS } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(RADIUS["Moon"]);
+ * ```
+ */
+export declare const RADIUS: Record<string, {
+    true: number;
+    compressed: number;
+}>;

package/dist/space/scale.js

@@ -0,0 +1,141 @@
+// The two scales the space view can show. The true one is the Earth's radius for a unit and the real distances in it; the compressed one keeps every
+// direction but squeezes the distances so that the Moon, the Sun and Neptune fit one view. Pure.
+import { AU_IN_EARTH_RADII } from "./ephemeris.js";
+const MOON_AU = 0.00257;
+/**
+ * The Moon's distance in a compressed view, in Earth radii (the true one is about 60).
+ *
+ * @example
+ * ```ts
+ * import { MOON_COMPRESSED } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(MOON_COMPRESSED);
+ * ```
+ */
+export const MOON_COMPRESSED = 10;
+/**
+ * The Sun's distance from the Earth in a compressed view, in Earth radii (the true one is about 23,500). One astronomical unit is this long there.
+ *
+ * @example
+ * ```ts
+ * import { SUN_COMPRESSED } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(SUN_COMPRESSED);
+ * ```
+ */
+export const SUN_COMPRESSED = 44;
+const length = (v) => Math.hypot(v[0], v[1], v[2]);
+const scaled = (v, k) => [v[0] * k, v[1] * k, v[2] * k];
+/**
+ * A place in astronomical units from the Earth's centre, at true distance, in Earth radii.
+ *
+ * @param v - The place, in astronomical units.
+ * @returns The same direction, in Earth radii.
+ *
+ * @example
+ * ```ts
+ * import { truePosition } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(truePosition([0.00257, 0, 0]).map(Math.round));
+ * ```
+ */
+export const truePosition = (v) => scaled(v, AU_IN_EARTH_RADII);
+/**
+ * The same direction at a compressed distance from the Earth: the Moon is 10 Earth radii away, and a body k times further than the Moon is k^0.25 times as far here.
+ *
+ * @param v - The place, in astronomical units from the Earth's centre.
+ * @returns The place in Earth radii, compressed; the centre stays at the centre.
+ *
+ * @example
+ * ```ts
+ * import { compress } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(compress([0.00257, 0, 0]), compress([0, 0, 0]));
+ * ```
+ */
+export function compress(v) {
+    const l = length(v);
+    return l === 0 ? [0, 0, 0] : scaled(v, (MOON_COMPRESSED * (l / MOON_AU) ** 0.25) / l);
+}
+/**
+ * The Moon, from the Earth's centre.
+ *
+ * @param mode - The scale.
+ * @param geo - The Moon's place in astronomical units from the Earth's centre.
+ * @returns Where to draw it, in Earth radii.
+ *
+ * @example
+ * ```ts
+ * import { placeMoon } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(placeMoon("true", [0.00257, 0, 0]).map(Math.round));
+ * ```
+ */
+export const placeMoon = (mode, geo) => (mode === "true" ? truePosition(geo) : compress(geo));
+/**
+ * The Sun, from the Earth's centre: in a compressed view always 44 Earth radii away, in its real direction.
+ *
+ * @param mode - The scale.
+ * @param geo - The Sun's place in astronomical units from the Earth's centre.
+ * @returns Where to draw it, in Earth radii.
+ *
+ * @example
+ * ```ts
+ * import { placeSun } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(placeSun("compressed", [1, 0, 0]));
+ * ```
+ */
+export function placeSun(mode, geo) {
+    if (mode === "true")
+        return truePosition(geo);
+    const l = length(geo);
+    return l === 0 ? [0, 0, 0] : scaled(geo, SUN_COMPRESSED / l);
+}
+/**
+ * A place `helio` astronomical units from the Sun (a planet, or a point on its orbit), round the Sun at `sun`. True: as it is. Compressed: the same direction from
+ * the Sun, at 44 Earth radii times its distance in astronomical units to the power 0.45, so the Earth's own orbit is the 44 and Neptune's is about 200 (30 times as far, really).
+ *
+ * @param mode - The scale.
+ * @param sun - Where the Sun is drawn, in Earth radii.
+ * @param helio - The place in astronomical units from the Sun.
+ * @returns Where to draw the place, in Earth radii from the Earth's centre.
+ *
+ * @example
+ * ```ts
+ * import { placeAround } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(placeAround("compressed", [44, 0, 0], [1, 0, 0]));
+ * ```
+ */
+export function placeAround(mode, sun, helio) {
+    if (mode === "true")
+        return [sun[0] + helio[0] * AU_IN_EARTH_RADII, sun[1] + helio[1] * AU_IN_EARTH_RADII, sun[2] + helio[2] * AU_IN_EARTH_RADII];
+    const l = length(helio);
+    if (l === 0)
+        return sun;
+    const d = (SUN_COMPRESSED * l ** 0.45) / l;
+    return [sun[0] + helio[0] * d, sun[1] + helio[1] * d, sun[2] + helio[2] * d];
+}
+/**
+ * Radii in Earth radii: the real ones, and ones large enough to see in a compressed view.
+ *
+ * @example
+ * ```ts
+ * import { RADIUS } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(RADIUS["Moon"]);
+ * ```
+ */
+export const RADIUS = {
+    Sun: { true: 109.1, compressed: 5 },
+    Earth: { true: 1, compressed: 1 },
+    Moon: { true: 0.2727, compressed: 0.9 },
+    Mercury: { true: 0.383, compressed: 0.5 },
+    Venus: { true: 0.949, compressed: 0.8 },
+    Mars: { true: 0.532, compressed: 0.6 },
+    Jupiter: { true: 10.97, compressed: 1.8 },
+    Saturn: { true: 9.14, compressed: 1.6 },
+    Uranus: { true: 3.98, compressed: 1.0 },
+    Neptune: { true: 3.86, compressed: 1.0 },
+};

package/dist/space/scene.d.ts

@@ -0,0 +1,131 @@
+import type * as THREE from "three";
+import type { AssetCache, Item3D } from "@johnmorrisdotca/kazoku-ui/renderer";
+import { type ThreeParts } from "../realistic/textures.ts";
+import type { Layer } from "../realistic/tiers.ts";
+import { type Frame, type PlanetName, type Vec3 } from "./ephemeris.ts";
+import { type ScaleMode } from "./scale.ts";
+type Three = ThreeParts;
+/** The camera's distance, in Earth radii, at which the Earth fills the view at zoom 1. */
+export declare const FIT_DISTANCE = 3.4;
+/**
+ * The ten bodies the space view places, names and lets a reader choose: the Earth, the Sun, the Moon and the seven other planets.
+ *
+ * @example
+ * ```ts no-run
+ * import { BODY_NAMES } from "@johnmorrisdotca/chikyu-earth/space/element";
+ *
+ * console.log(BODY_NAMES.join(", "));
+ * ```
+ */
+export declare const BODY_NAMES: readonly ["Earth", "Sun", "Moon", "Mercury", "Venus", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"];
+/**
+ * The name of one of the bodies in `BODY_NAMES`.
+ *
+ * @example
+ * ```ts no-run
+ * import { BODY_NAMES, type BodyName } from "@johnmorrisdotca/chikyu-earth/space/element";
+ *
+ * const mars: BodyName = "Mars";
+ * console.log(BODY_NAMES.includes(mars));
+ * ```
+ */
+export type BodyName = (typeof BODY_NAMES)[number];
+export interface SpaceModel {
+    /** Moment shown, milliseconds since the epoch. */
+    time: number;
+    mode: ScaleMode;
+    /** The shared controls' yaw, tilt and zoom. */
+    view: {
+        yaw: number;
+        tilt: number;
+        zoom: number;
+    };
+    /** The home place: the camera starts above it. */
+    centre: {
+        lon: number;
+        lat: number;
+    };
+    /** Earth's turn against the stars (degrees) at the moment the camera was last moved: the camera is fixed to the stars, not to the ground. */
+    cameraSpin: number | null;
+    orbits: boolean;
+    labels: boolean;
+    /** Milliseconds of game time one second of wall time covers (the ephemeris is looked up once per such span). */
+    stepMs: number;
+    /** The body the camera looks at, and (in `zoom`) fills the view with at 1x. */
+    focus: BodyName;
+    /** Filled at each draw. */
+    drawn: {
+        frame: Frame;
+        distance: number;
+        radiusPx: number;
+    } | null;
+    /** How many times astronomy-engine has been asked for a frame. */
+    lookups: number;
+    ratio(): number;
+}
+export declare const newSpaceModel: () => SpaceModel;
+/** Where a body is on the screen: its centre and its apparent radius, in CSS pixels in the box. */
+export interface BodyPlace {
+    x: number;
+    y: number;
+    r: number;
+}
+/**
+ * One body as drawn by a painter: an object of radius 1 at the origin, which the scene places, scales and (for the Sun) turns to face the camera.
+ *
+ * @example
+ * ```ts no-run
+ * import type { BodyDrawing } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const drawing = { object: undefined as never, dispose: () => undefined } satisfies BodyDrawing;
+ * console.log(typeof drawing.dispose);
+ * ```
+ */
+export interface BodyDrawing {
+    object: THREE.Object3D;
+    /** Told at each draw the unit direction from the body to the Sun, in scene axes (x to the vernal equinox, y north). */
+    light?(toSun: Vec3): void;
+    /** True to have the scene turn the object to face the camera (a disc or a glow). */
+    billboard?: boolean;
+    dispose(): void;
+}
+/**
+ * The seam for drawing the Sun and the planets. The space view places them, sizes them, lights them and labels them; a painter only makes what is drawn at
+ * each place. The default (`plainPainter`) is a sphere in the body's colour, and a glow for the Sun. Another package can supply better looking ones.
+ *
+ * @example
+ * ```ts no-run
+ * import { plainPainter, type BodyPainter } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const painter: BodyPainter = { make: (three, name) => plainPainter.make(three, name) };
+ * console.log(typeof painter.make);
+ * ```
+ */
+export interface BodyPainter {
+    make(three: ThreeParts, name: PlanetName | "Sun"): BodyDrawing;
+}
+export interface SpaceDeps {
+    assets: AssetCache;
+    textureBase: () => string;
+    cap: () => number;
+    invalidate: () => void;
+    onError?: (error: unknown) => void;
+    onTier?: (layer: Layer, width: number) => void;
+    /** Where each body is on the screen, in CSS pixels in the box, or null when it is behind the camera. Called at each draw. */
+    onLabels?: (places: Record<BodyName, BodyPlace | null>) => void;
+    /** How the Sun and the planets are drawn; left out, plain spheres in the right colours (see `BodyPainter`). */
+    painter?: BodyPainter;
+}
+/**
+ * The default look: a sphere in the planet's colour, lit by the Sun, and for the Sun a glowing disc.
+ *
+ * @example
+ * ```ts no-run
+ * import { plainPainter } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(typeof plainPainter.make);
+ * ```
+ */
+export declare const plainPainter: BodyPainter;
+export declare function createSpaceItem(model: SpaceModel, deps: SpaceDeps): Item3D<Three>;
+export {};