@fluritheme/moon-explorer 0.0.0-stage → 0.1.0

package/dist/render.js

@@ -0,0 +1,467 @@
+import { clamp, ease } from "./model.js";
+function path(c, points, color, width) {
+    c.beginPath();
+    c.moveTo(points[0], points[1]);
+    for (let i = 2; i < points.length; i += 2)
+        c.lineTo(points[i], points[i + 1]);
+    c.strokeStyle = color;
+    c.lineWidth = width;
+    c.lineCap = "round";
+    c.lineJoin = "round";
+    c.stroke();
+}
+function ellipse(c, x, y, rx, ry, fill, rotation = 0) {
+    c.beginPath();
+    c.ellipse(x, y, Math.max(0.01, rx), Math.max(0.01, ry), rotation, 0, Math.PI * 2);
+    c.fillStyle = fill;
+    c.fill();
+}
+function round(c, x, y, w, h, r, fill, stroke) {
+    c.beginPath();
+    c.roundRect(x, y, w, h, r);
+    c.fillStyle = fill;
+    c.fill();
+    if (stroke) {
+        c.lineWidth = 0.8;
+        c.strokeStyle = stroke;
+        c.stroke();
+    }
+}
+function star(c, x, y, size, alpha) {
+    c.save();
+    c.globalAlpha = alpha;
+    c.beginPath();
+    c.moveTo(x, y - size);
+    c.quadraticCurveTo(x + size * 0.15, y - size * 0.15, x + size, y);
+    c.quadraticCurveTo(x + size * 0.15, y + size * 0.15, x, y + size);
+    c.quadraticCurveTo(x - size * 0.15, y + size * 0.15, x - size, y);
+    c.quadraticCurveTo(x - size * 0.15, y - size * 0.15, x, y - size);
+    c.fillStyle = "#fff4c7";
+    c.fill();
+    c.restore();
+}
+function shadow(c, x, y, width, alpha = 0.15) {
+    c.save();
+    c.globalAlpha = alpha;
+    ellipse(c, x, y, width, width * 0.13, "#10142a");
+    c.restore();
+}
+function flag(c, x, y, t, accent) {
+    c.save();
+    c.translate(x, y);
+    path(c, [0, 0, 0, -64], "#727d8b", 2);
+    path(c, [-1, -64, -1, -1], "#e9e5d6", 0.7);
+    ellipse(c, 0, -64, 2, 2, "#eee6c8");
+    c.beginPath();
+    c.moveTo(1, -63);
+    c.bezierCurveTo(10, -66 + Math.sin(t) * 1.2, 20, -59, 31, -63);
+    c.lineTo(31, -43);
+    c.bezierCurveTo(20, -39 + Math.sin(t) * 0.8, 10, -46, 1, -42);
+    c.closePath();
+    c.fillStyle = accent;
+    c.fill();
+    path(c, [2, -61, 29, -61], "#ffffff65", 0.8);
+    ellipse(c, 15, -52, 5, 5, "#fff0d0");
+    ellipse(c, 17, -53, 4, 4, accent);
+    star(c, 23, -54, 1.7, 0.85);
+    c.restore();
+}
+function rover(c, x, y, t, accent, facing) {
+    c.save();
+    c.translate(x, y);
+    c.scale(facing, 1);
+    shadow(c, 0, 1, 48, 0.17);
+    for (const wheelX of [-30, 30]) {
+        path(c, [0, -15, wheelX, -9], "#8a8a84", 3);
+        ellipse(c, wheelX, -8, 11, 11, "#242e39");
+        ellipse(c, wheelX, -8, 7.5, 7.5, "#56606c");
+        ellipse(c, wheelX, -8, 3, 3, "#c5c5b3");
+        for (let i = 0; i < 8; i++) {
+            const a = (i * Math.PI) / 4 + t * 2;
+            path(c, [
+                wheelX + Math.cos(a) * 8,
+                -8 + Math.sin(a) * 8,
+                wheelX + Math.cos(a) * 10,
+                -8 + Math.sin(a) * 10,
+            ], "#bcc1ba", 1.3);
+        }
+    }
+    round(c, -38, -27, 73, 17, 5, "#d5d6c7", "#62717b");
+    round(c, -37, -27, 73, 5, 2, "#f5ebd5");
+    round(c, -35, -24, 18, 10, 2, accent);
+    round(c, 7, -25, 22, 13, 2, "#8e9e9f");
+    for (let i = 0; i < 3; i++)
+        path(c, [11 + i * 5, -24, 11 + i * 5, -13], "#b7d2cd", 0.6);
+    path(c, [0, -29, -2, -48], "#7f8c91", 2);
+    c.save();
+    c.translate(-2, -47);
+    c.rotate(-0.35);
+    c.beginPath();
+    c.arc(0, 0, 10, 0, Math.PI);
+    c.fillStyle = "#d4ded5";
+    c.fill();
+    path(c, [-10, 0, 10, 0], "#75868b", 1);
+    path(c, [0, 0, 0, -6], "#a1aaa7", 1);
+    c.restore();
+    path(c, [29, -28, 34, -48], "#a6b0a8", 1);
+    ellipse(c, 34, -49, 2, 2, accent);
+    round(c, -22, -31, 21, 5, 1, "#74828a");
+    c.restore();
+}
+function lander(c, x, y, phase, t, accent, landingStart, ground) {
+    c.save();
+    c.translate(x, y);
+    const descending = phase === "landing";
+    const float = descending ? Math.sin(t * 5) * 0.02 : 0;
+    c.rotate(float);
+    const altitude = Math.max(0, y - ground);
+    void altitude;
+    shadow(c, 0, ground - y + 3, 52, 0.12);
+    if (descending && t < 3.6) {
+        const flame = (13 + Math.sin(t * 38) * 5) * (1 - ease((t - 2.7) / 0.9));
+        c.beginPath();
+        c.moveTo(-9, 17);
+        c.quadraticCurveTo(-5, 27 + flame, 0, 39 + flame);
+        c.quadraticCurveTo(5, 28 + flame, 9, 17);
+        const g = c.createLinearGradient(0, 17, 0, 45 + flame);
+        g.addColorStop(0, "#d8efff");
+        g.addColorStop(0.3, "#ffdc8e");
+        g.addColorStop(1, "#ff7a3800");
+        c.fillStyle = g;
+        c.fill();
+        ellipse(c, 0, 20, 5, 9, "#ffefc9");
+    }
+    for (const f of [-1, 1]) {
+        path(c, [f * 21, 1, f * 44, 31], "#8c989e", 3);
+        path(c, [f * 20, 6, f * 39, 26], "#d7d5bd", 1);
+        ellipse(c, f * 45, 32, 12, 3, "#78868a");
+        round(c, f < 0 ? -52 : 30, 29, 23, 3, 1, "#bbc6bd");
+    }
+    round(c, -26, -30, 52, 41, 6, "#d9c89b", "#687f87");
+    round(c, -24, -27, 48, 15, 4, "#fff1cf");
+    round(c, -22, -10, 44, 19, 2, "#b7a46e");
+    path(c, [-22, -8, 0, 7, 22, -8], "#eedbb1", 0.7);
+    path(c, [-21, 6, 0, -6, 22, 6], "#8b896d", 0.7);
+    c.beginPath();
+    c.moveTo(-25, -25);
+    c.lineTo(-18, -43);
+    c.lineTo(17, -43);
+    c.lineTo(27, -25);
+    c.closePath();
+    c.fillStyle = "#d8dfd6";
+    c.fill();
+    round(c, -14, -38, 28, 15, 5, "#284353", "#7c9b9d");
+    path(c, [-9, -36, -1, -36], "#bce7da", 1.3);
+    round(c, -10, -19, 20, 9, 2, accent);
+    round(c, -18, 10, 36, 9, 2, "#6f7f87");
+    path(c, [-5, 12, -5, 18], "#b8c1b1", 0.8);
+    path(c, [5, 12, 5, 18], "#b8c1b1", 0.8);
+    path(c, [17, -42, 25, -57], "#b4c2b7", 1.3);
+    ellipse(c, 26, -58, 2, 2, "#e5debf");
+    path(c, [-18, -43, -22, -50, -17, -57], "#d5d7bf", 1.5);
+    ellipse(c, -17, -58, 4, 2, accent);
+    if (!descending) {
+        path(c, [-4, 6, -4, 31], "#78888b", 1.5);
+        for (let i = 0; i < 5; i++)
+            path(c, [-7, 12 + i * 4, 0, 12 + i * 4], "#c5ccb8", 1.2);
+    }
+    void landingStart;
+    c.restore();
+}
+function astronaut(c, m, o) {
+    const t = m.phaseTime, phase = m.phase, s = m.size;
+    const moving = phase === "walking";
+    const driving = phase === "driving";
+    const crouch = phase === "sampling"
+        ? Math.sin(clamp(t / 4.2, 0, 1) * Math.PI) * 10
+        : phase === "planting"
+            ? Math.sin(clamp(t / 3.6, 0, 1) * Math.PI) * 6
+            : 0;
+    const bounce = moving
+        ? Math.sin(t * 5) * 1.3
+        : Math.sin(m.elapsed * 2) * 0.55;
+    const jump = phase === "jumping";
+    const swing = moving ? Math.sin(t * 5) * 0.48 : 0;
+    const seated = driving || (phase === "boarding" && t > 1);
+    const feetLift = seated ? 16 : 0;
+    c.save();
+    c.translate(m.x, m.y);
+    c.scale(s, s);
+    c.scale(m.facing, 1);
+    if (phase === "celebrating")
+        c.rotate(Math.sin(t * 6) * 0.07);
+    if (phase === "egress")
+        c.rotate(Math.sin(t * 5) * 0.035);
+    shadow(c, 0, (m.surface.y - m.y) / s + 1, 20 * (1 - clamp((m.surface.y - m.y) / 130, 0, 0.6)), 0.18);
+    c.translate(0, crouch + bounce - feetLift);
+    // Soft backpack silhouette, antenna and curved oxygen hose.
+    round(c, -23, -51, 16, 34, 5, "#adb6b1", "#344b55");
+    round(c, -25, -46, 8, 23, 3, "#d1d7cb");
+    round(c, -25, -43, 8, 6, 1, o.accent);
+    path(c, [-18, -51, -20, -63], "#6d8791", 1.6);
+    ellipse(c, -20, -64, 1.8, 1.8, o.accent);
+    path(c, [-22, -35, -27, -24, -18, -17, -12, -29], "#e6d6b5", 3.2);
+    path(c, [-22, -35, -27, -24, -18, -17, -12, -29], "#7f8b86", 0.7);
+    // Far arm and articulated legs.
+    const armFar = moving ? -swing * 0.8 : jump ? -1.1 : seated ? -0.7 : 0.15;
+    limb(c, -8, -38, -12, -25, -11, -13, armFar, "#b5bcb7", 6);
+    ellipse(c, -11, -12, 4, 4.5, "#81979a");
+    const legA = jump ? -0.65 : seated ? -1.2 : swing, legB = jump ? 0.55 : seated ? -0.8 : -swing;
+    leg(c, -6, -18, legA, seated, "#b8bfb7", crouch);
+    leg(c, 6, -18, legB, seated, "#e8e7d6", crouch);
+    // Suit with illuminated panel, stitching and little utility belt.
+    const suit = c.createLinearGradient(-13, -48, 14, -17);
+    suit.addColorStop(0, "#f8f1d9");
+    suit.addColorStop(0.55, "#e0e2d3");
+    suit.addColorStop(1, "#a8b9b1");
+    round(c, -13, -47, 28, 31, 9, suit, "#405963");
+    path(c, [-9, -42, -9, -26], "#fff8df", 1.2);
+    round(c, -10, -36, 21, 13, 3, "#a4b8b5", "#6b8d92");
+    round(c, -8, -34, 17, 7, 1, "#263f4a");
+    ellipse(c, -4, -30, 1.1, 1.1, "#b4f8e0");
+    ellipse(c, 1, -30, 1.1, 1.1, o.accent);
+    path(c, [5, -32, 7, -32], "#d3f3e1", 0.6);
+    round(c, -12, -22, 25, 5, 1, "#778d8e");
+    round(c, -1, -23, 6, 7, 1, "#cbd3bb");
+    round(c, 8, -43, 6, 4, 1, o.accent);
+    // Helmet: dark rim, pearl shell, gold metallic visor and layered reflections.
+    const headTilt = phase === "observing"
+        ? -0.18
+        : phase === "sleeping"
+            ? 0.19
+            : phase === "sampling"
+                ? 0.2
+                : Math.sin(m.elapsed * 0.8) * 0.025;
+    c.save();
+    c.translate(0, -52);
+    c.rotate(headTilt);
+    ellipse(c, 0, 0, 22, 21, "#546a70");
+    const shell = c.createRadialGradient(-8, -9, 3, 0, 0, 24);
+    shell.addColorStop(0, "#fff8df");
+    shell.addColorStop(0.65, "#e7e9d9");
+    shell.addColorStop(1, "#879e9b");
+    ellipse(c, 0, -1, 21, 21, shell);
+    ellipse(c, 2, 0, 16.5, 15.5, "#38505b");
+    const visor = c.createLinearGradient(-8, -13, 12, 16);
+    visor.addColorStop(0, "#4d747d");
+    visor.addColorStop(0.35, "#183948");
+    visor.addColorStop(0.7, "#11252e");
+    visor.addColorStop(1, "#998263");
+    ellipse(c, 3, 0, 14.5, 13.5, visor);
+    c.save();
+    c.beginPath();
+    c.ellipse(3, 0, 14.5, 13.5, 0, 0, Math.PI * 2);
+    c.clip();
+    const ref = c.createLinearGradient(-12, -13, 16, 9);
+    ref.addColorStop(0, "#f2e4b9c0");
+    ref.addColorStop(0.4, "#a9e6d542");
+    ref.addColorStop(1, "#d7e9ff00");
+    c.fillStyle = ref;
+    c.beginPath();
+    c.moveTo(-13, -9);
+    c.lineTo(14, -17);
+    c.lineTo(6, -6);
+    c.lineTo(-14, 4);
+    c.fill();
+    path(c, [-8, -8, 0, -11, 8, -10], "#f5f5dca0", 1.2);
+    ellipse(c, 8, -4, 2.5, 4, "#d2f5e525", -0.45);
+    c.restore();
+    ellipse(c, -19, 0, 4, 7, "#889f9d");
+    ellipse(c, -20, 0, 2, 4, "#c7d2ba");
+    round(c, -7, 17, 16, 4, 2, "#7d9696");
+    // Eyes are tiny emissive shapes, watching nearby pointers through the visor.
+    let eyeX = 4, eyeY = 4;
+    const dx = o.pointer.x - m.x, dy = o.pointer.y - (m.y - 55 * s);
+    if (o.pointer.active && Math.hypot(dx, dy) < 180 * s) {
+        eyeX += clamp(dx / (80 * s), -2, 2) * m.facing;
+        eyeY += clamp(dy / (80 * s), -1.5, 1.5);
+    }
+    const blink = Math.sin(m.elapsed * 1.7) > 0.988;
+    const asleep = phase === "sleeping";
+    if (asleep || blink) {
+        path(c, [eyeX - 6, eyeY, eyeX - 3, eyeY], "#deedcc", 1);
+        path(c, [eyeX + 1, eyeY, eyeX + 4, eyeY], "#deedcc", 1);
+    }
+    else {
+        ellipse(c, eyeX - 4.5, eyeY, 1.1, 1.6, "#e2f6d8");
+        ellipse(c, eyeX + 2.5, eyeY, 1.1, 1.6, "#e2f6d8");
+    }
+    c.restore();
+    let armAngle = moving ? swing * 0.65 : 0.15;
+    let handX = 20, handY = -24;
+    if (phase === "waving" || phase === "celebrating") {
+        armAngle = -1.4 + Math.sin(t * 8) * 0.22;
+        handX = 22 + Math.sin(t * 8) * 3;
+        handY = -62;
+    }
+    else if (phase === "sampling") {
+        armAngle = 0.5;
+        handX = 25;
+        handY = -12 - Math.sin(t * 5) * 3;
+    }
+    else if (phase === "planting") {
+        armAngle = -0.4;
+        handX = 24;
+        handY = -34;
+    }
+    else if (phase === "observing") {
+        armAngle = -1;
+        handX = 20;
+        handY = -48;
+    }
+    else if (jump) {
+        armAngle = -1.1;
+        handX = 28;
+        handY = -48;
+    }
+    else if (seated) {
+        armAngle = -0.7;
+        handX = 27;
+        handY = -24;
+    }
+    void armAngle;
+    path(c, [12, -39, 19, -34, handX, handY], "#47616b", 8);
+    path(c, [12, -39, 19, -34, handX, handY], "#e6e4d1", 6);
+    ellipse(c, handX, handY, 4.3, 4.7, "#a1b7b3");
+    path(c, [14, -37, 17, -36], o.accent, 3);
+    if (phase === "sampling") {
+        path(c, [handX + 2, handY - 2, handX + 10, handY - 12], "#a6bbb2", 2);
+        path(c, [handX + 5, handY - 14, handX + 15, handY - 10], "#91a7a6", 4);
+        if (t > 2.2) {
+            round(c, 17, -13, 9, 7, 1, "#afccbe");
+            ellipse(c, 21, -16, 5, 5, "#a19e88");
+        }
+    }
+    if (phase === "planting" && t < 1.8) {
+        path(c, [25, 0, 25, -60 * ease(t / 1.8)], "#aebdb2", 1.5);
+    }
+    if (phase === "observing") {
+        c.save();
+        c.translate(20, -49);
+        c.rotate(-0.3);
+        round(c, -4, -4, 24, 8, 2, "#6a858d");
+        round(c, 15, -5, 7, 10, 2, o.accent);
+        ellipse(c, 22, 0, 2, 5, "#c3eddf");
+        c.restore();
+    }
+    if (phase === "sleeping") {
+        for (let i = 0; i < 3; i++) {
+            c.globalAlpha = (1 - ((m.elapsed * 0.25 + i * 0.3) % 1)) * 0.8;
+            c.fillStyle = "#e9d4a9";
+            c.font = `${8 + i * 2}px monospace`;
+            c.fillText("z", 24 + i * 9, -66 - ((m.elapsed * 8 + i * 12) % 35));
+        }
+        c.globalAlpha = 1;
+    }
+    if (phase === "celebrating") {
+        for (let i = 0; i < 4; i++) {
+            const a = i * 1.8 + t;
+            star(c, Math.cos(a) * 31, -66 + Math.sin(a) * 14, 2.5, Math.sin((t * Math.PI) / 1.4));
+        }
+    }
+    if (phase === "waving" && t > 0.3 && t < 2.7) {
+        c.save();
+        c.scale(m.facing, 1);
+        round(c, 28, -83, 32, 20, 6, "#f5f0d8", "#9aa8a5");
+        c.beginPath();
+        c.moveTo(30, -64);
+        c.lineTo(26, -57);
+        c.lineTo(38, -64);
+        c.fillStyle = "#f5f0d8";
+        c.fill();
+        c.fillStyle = "#35515b";
+        c.font = "bold 9px monospace";
+        c.fillText("hi!", 35, -70);
+        c.restore();
+    }
+    c.restore();
+}
+function leg(c, x, y, a, seated, color, crouch = 0) {
+    const kneeX = x + Math.sin(a) * 10, kneeY = y + Math.cos(a) * 9, footX = x + Math.sin(a) * 17 + (seated ? 13 : 0), footY = seated ? -4 : -2 - crouch;
+    path(c, [x, y, kneeX, kneeY, footX, footY - 3], "#405963", 8);
+    path(c, [x, y, kneeX, kneeY, footX, footY - 3], color, 6);
+    round(c, footX - 4, footY - 5, 12, 7, 3, "#8aa1a0", "#4b6570");
+    path(c, [footX - 2, footY + 1, footX + 7, footY + 1], "#d9dccb", 1.2);
+}
+function limb(c, x, y, mx, my, ex, ey, a, color, width) {
+    c.save();
+    c.translate(x, y);
+    c.rotate(a);
+    path(c, [0, 0, mx - x, my - y, ex - x, ey - y], color, width);
+    c.restore();
+}
+export function paint(c, m, o) {
+    for (const f of m.footprints) {
+        c.save();
+        c.globalAlpha = clamp(f.life / 65, 0, 0.2);
+        c.translate(f.x, f.y);
+        c.rotate(f.facing * 0.3);
+        ellipse(c, f.side * 2, -0.4, 2.4, 1, "#233d4a");
+        c.restore();
+    }
+    for (const rock of m.rocks) {
+        if (rock.collected)
+            continue;
+        c.save();
+        c.translate(rock.x, rock.y);
+        c.rotate(0.07);
+        shadow(c, 0, 0, rock.size * 1.2, 0.12);
+        c.beginPath();
+        c.moveTo(-rock.size, 0);
+        c.lineTo(-rock.size * 0.6, -rock.size * 0.9);
+        c.lineTo(rock.size * 0.3, -rock.size * 1.2);
+        c.lineTo(rock.size, -rock.size * 0.4);
+        c.lineTo(rock.size * 0.7, 0);
+        c.closePath();
+        c.fillStyle = "#a0a49b";
+        c.fill();
+        path(c, [
+            -rock.size * 0.5,
+            -rock.size * 0.8,
+            rock.size * 0.2,
+            -rock.size * 0.9,
+            rock.size * 0.6,
+            -rock.size * 0.3,
+        ], "#d7d6c3", 1);
+        c.restore();
+    }
+    for (const f of m.flags) {
+        c.save();
+        c.translate(f.x, f.y);
+        c.scale(m.size, m.size);
+        flag(c, 0, 0, m.elapsed * 0.7 + f.phase, o.accent);
+        c.restore();
+    }
+    if (o.lander) {
+        c.save();
+        c.translate(m.landerX, m.landerY - 32 * m.size);
+        c.scale(m.size, m.size);
+        lander(c, 0, 0, m.phase, m.phaseTime, o.accent, m.landingStartY, (m.surface.y - m.landerY) / m.size + 32);
+        c.restore();
+    }
+    if (o.rover && m.phase !== "landing") {
+        c.save();
+        c.translate(m.roverX, m.roverY);
+        c.scale(m.size, m.size);
+        rover(c, 0, 0, m.elapsed, o.accent, m.facing);
+        c.restore();
+    }
+    for (const d of m.dust) {
+        c.save();
+        c.globalAlpha = clamp(d.life / d.ttl, 0, 0.4);
+        ellipse(c, d.x, d.y, d.radius, d.radius * 0.6, "#b8afa0");
+        c.restore();
+    }
+    if (m.phase !== "landing" || m.phaseTime > 3.35)
+        astronaut(c, m, o);
+    for (const a of m.stars) {
+        c.save();
+        const tail = 70, alpha = Math.sin(clamp(1 - a.life / a.ttl, 0, 1) * Math.PI);
+        const g = c.createLinearGradient(a.x - tail, a.y - tail * 0.35, a.x, a.y);
+        g.addColorStop(0, "#fff0bb00");
+        g.addColorStop(1, `rgba(255,240,187,${alpha * 0.8})`);
+        path(c, [a.x - tail, a.y - tail * 0.35, a.x, a.y], g, 1.5);
+        star(c, a.x, a.y, 3, alpha);
+        c.restore();
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,94 @@
+export type ExplorerPhase = "landing" | "egress" | "idle" | "walking" | "jumping" | "sampling" | "planting" | "waving" | "boarding" | "driving" | "dismounting" | "observing" | "sleeping" | "celebrating";
+export type Mission = "explore" | "sample" | "flag" | "rover" | "observe" | "wave" | "jump" | "rest";
+export interface MoonExplorerOptions {
+    /** Defaults to the full document. A scoped root is never restyled. */
+    root?: HTMLElement;
+    /** Upper edges of these elements become landing/walking surfaces. */
+    surfaces?: string;
+    /** Character scale. Clamped to 0.55–1.8. */
+    size?: number;
+    /** Animation speed, 0.3–2.5. */
+    pace?: number;
+    /** Autonomous missions continue when visible. */
+    autoExplore?: boolean;
+    /** Mouse curiosity and click-to-wave, without blocking page controls. */
+    interactive?: boolean;
+    rover?: boolean;
+    lander?: boolean;
+    shootingStars?: boolean;
+    /** Persistent flags and sample rocks, bounded to protect long sessions. */
+    maxFlags?: number;
+    accent?: string;
+    seed?: number;
+    maxFPS?: number;
+    maxDPR?: number;
+    zIndex?: number;
+    /** Respect reduced-motion by default; static never schedules animation. */
+    motion?: "respect" | "static";
+}
+export type MoonExplorerUpdate = Partial<Omit<MoonExplorerOptions, "root" | "surfaces" | "seed">>;
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface LunarSurface {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+}
+export interface MoonWorld {
+    bounds: Rect;
+    view: Rect;
+    surfaces: LunarSurface[];
+}
+export interface ExplorerSnapshot {
+    state: "idle" | "running" | "paused" | "destroyed";
+    phase: ExplorerPhase;
+    mission: Mission | null;
+    /** Document CSS coordinates. Scrolling changes the camera, not these values. */
+    x: number;
+    y: number;
+    facing: 1 | -1;
+    surface: string;
+    samples: number;
+    flags: number;
+    distance: number;
+    roverDistance: number;
+    missionsCompleted: number;
+    elapsed: number;
+    reducedMotion: boolean;
+}
+export interface ExplorerEventData {
+    phase: ExplorerPhase;
+    mission: Mission | null;
+    samples: number;
+    flags: number;
+    surface: string;
+}
+export type ExplorerEvent = "phase" | "mission" | "sample" | "flag" | "landed";
+export interface MoonExplorerController {
+    /** Queue a mission. Returns false when unavailable or destroyed. */
+    mission(kind: Mission, selector?: string): boolean;
+    explore(selector?: string): boolean;
+    collect(): boolean;
+    plantFlag(): boolean;
+    ride(): boolean;
+    observe(): boolean;
+    jump(): boolean;
+    wave(): boolean;
+    rest(): boolean;
+    /** A decorative shooting star, visible immediately when animation is running. */
+    shootingStar(): void;
+    /** Repeat the landing sequence on a measured surface. */
+    land(selector?: string): boolean;
+    pause(): void;
+    resume(): void;
+    refresh(): void;
+    update(options: MoonExplorerUpdate): void;
+    destroy(): void;
+    getState(): Readonly<ExplorerSnapshot>;
+    on(event: ExplorerEvent, handler: (data: ExplorerEventData) => void): () => void;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/licensing.json

@@ -0,0 +1,51 @@
+{
+  "name": "Fluri Themes Commercial License",
+  "version": "1.0",
+  "effectiveDate": "2026-11-14",
+  "license": "SEE LICENSE IN LICENSE",
+  "url": "https://fluri.xyz/license/",
+  "price": {
+    "amount": 19,
+    "currency": "EUR",
+    "billing": "one-time"
+  },
+  "personalProjects": "unlimited",
+  "clientProjects": "unlimited",
+  "futureThemesIncluded": true,
+  "packages": {
+    "@fluritheme/fluri": {
+      "lastMIT": "0.2.1",
+      "firstCommercial": "0.3.0"
+    },
+    "@fluritheme/fluri-react": {
+      "lastMIT": "0.2.1",
+      "firstCommercial": "0.3.0"
+    },
+    "@fluritheme/spider": {
+      "lastMIT": "0.2.1",
+      "firstCommercial": "0.3.0"
+    },
+    "@fluritheme/grinch": {
+      "lastMIT": "0.1.1",
+      "firstCommercial": "0.2.0"
+    },
+    "@fluritheme/black-cat": {
+      "firstCommercial": "0.1.0"
+    },
+    "@fluritheme/ghost": {
+      "firstCommercial": "0.1.0"
+    },
+    "@fluritheme/rainy-window": {
+      "firstCommercial": "0.1.0"
+    },
+    "@fluritheme/tiny-builders": {
+      "firstCommercial": "0.1.0"
+    },
+    "@fluritheme/origami-world": {
+      "firstCommercial": "0.1.0"
+    },
+    "@fluritheme/moon-explorer": {
+      "firstCommercial": "0.1.0"
+    }
+  }
+}

package/package.json

@@ -1,6 +1,81 @@
 {
   "name": "@fluritheme/moon-explorer",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "A beautifully animated little lunar expedition for real websites: astronaut landing, low-gravity walks, rock sampling, flags, rover rides, telescope observations and shooting stars.",
+  "type": "module",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://fluri.xyz/",
+  "author": {
+    "name": "František Gejdoš",
+    "email": "fluritheme@gmail.com",
+    "url": "https://fluri.xyz/founder/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fluritheme/moon-explorer.git"
+  },
+  "bugs": {
+    "email": "fluritheme@gmail.com"
+  },
+  "keywords": [
+    "moon",
+    "astronaut",
+    "space",
+    "lunar",
+    "rover",
+    "website-effects",
+    "canvas",
+    "animation",
+    "interactive",
+    "typescript",
+    "fluri",
+    "zero-dependencies"
+  ],
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "LICENSE-MIT-LEGACY",
+    "LICENSING.md",
+    "licensing.json"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22.12"
+  },
+  "packageManager": "pnpm@10.33.2",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "vite --host 127.0.0.1 --port 5312",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:browser": "playwright test",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "release:check": "node scripts/release-check.mjs",
+    "check": "pnpm typecheck && pnpm test && pnpm build && pnpm test:browser && pnpm format:check && pnpm release:check",
+    "prepublishOnly": "pnpm build && pnpm release:check",
+    "previews": "node scripts/render-previews.mjs"
+  },
+  "devDependencies": {
+    "@playwright/test": "1.64.1",
+    "@types/node": "26.6.6",
+    "prettier": "3.9.10",
+    "typescript": "6.0.3",
+    "vite": "8.3.6",
+    "vitest": "5.1.0"
+  }
+}