@buoy-gg/shared-ui 7.0.41 → 7.0.42

package/lib/module/ui/backgrounds/variants/deepField.js

@@ -1,378 +1 @@
-"use strict";
-
-/**
- * Deep Field — a faithful port of the Everlights `ParallaxDriftBackground`.
- *
- * The sibling `Starfield` preset is a cheap approximation of the same idea: 99
- * stars quantised into five depth bands. This one reproduces the original's
- * field exactly — same seed, same generator call order, same 160 stars, same
- * `z = zNear + zSpan·√rnd()` far-plane bias, same sizes, brightnesses, palette
- * and drift. Drop the constants below into the Skia version and you get the
- * same sky.
- *
- * WHAT COULDN'T COME ACROSS 1:1, and what was done instead:
- *
- *  - **Continuous per-star speed.** The original runs a worklet per star, so
- *    every one of the 160 drifts at its own `drift/z`. Here a distinct speed
- *    means a distinct animated node, so SPEED (and only speed) is quantised
- *    into 18 bands — banded uniformly in 1/z, which is what speed is
- *    proportional to, so the steps are even. Size, brightness, colour and
- *    twinkle phase all stay per-star and exact, and those are the properties
- *    the eye actually reads as depth.
- *
- *  - **The soft bulb sprite.** The original bakes one 64px sprite (blurred halo
- *    at r=6/α.30 over a blurred core at r=4/α1) and stamps it at `dia`. That is
- *    why stars stay fine points even at dia=20 — the lit core is only 12.5% of
- *    the stamp. There is no blur primitive here, so each star is a small solid
- *    core at that same 12.5%, and the nearer ones get one or two concentric
- *    discs standing in for the halo, graded DOWN in alpha toward the blur's
- *    outer extent (~0.24·dia) so the glow fades out rather than ending in a
- *    hard rim. Far stars end up a single ~1px dot, which is what the sprite
- *    renders them as anyway.
- *
- *  - **Additive blending.** `blendMode="plus"` becomes ordinary alpha
- *    compositing. Over a near-black base the two agree except where stars
- *    overlap, which at this density is rare.
- *
- * It costs roughly twice the cheap Starfield — see `registry.tsx` — which is
- * the whole reason both are in the catalogue.
- */
-
-import { memo } from "react";
-import { Animated, View } from "react-native";
-import { absoluteFill } from "../../../utils/absoluteFill.js";
-import { Base, RadialGlow, RasterLayer, useLoop, usePulse } from "../primitives.js";
-import { flattenOver, mulberry32, withAlpha } from "../rng.js";
-import { MeteorShower } from "./meteors.js";
-
-// ---------------------------------------------------------------------------
-// The original's shipping constants, verbatim.
-// ---------------------------------------------------------------------------
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-const COUNT = 160;
-const DRIFT = 0.016; // horizontal travel/sec at z=1, as a fraction of width
-const BASE_DIA = 5; // sprite diameter px at z=1
-const Z_NEAR = 0.25;
-const Z_FAR = 1.0;
-const Z_SPAN = Z_FAR - Z_NEAR;
-const MAX_DIA = BASE_DIA / Z_NEAR;
-const TWINKLE = 0.08;
-
-/** The classic white/blue mix — `[r,g,b]` 0..1 in the original. */
-const PALETTE = ["#FFFFFF", "#B3D9FF", "#8CB3FF"];
-
-/** The backdrop the field sits on — also what `opaque` mode flattens against. */
-const BASE_COLOR = "#050609";
-
-/**
- * Default speed bands. 18 is the point where stepping stops being visible:
- * adjacent bands differ by ~6% in speed, well under what reads as a seam. The
- * bench route sweeps this, since it is the main lever on cost.
- */
-const BAND_COUNT = 18;
-/** Twinkle groups — bands are round-robined across these. */
-const TWINKLE_GROUPS = 4;
-const TWINKLE_MS = [4200, 4900, 5600, 6300];
-
-/** How the ±8% brightness wobble is applied. */
-
-/** How many concentric discs stand in for the sprite's blurred halo. */
-
-/**
- * The original field, regenerated.
- *
- * The generator order matters as much as the seed: the source pulls fx, fy, z
- * and tw off ONE mulberry32 stream per star, so drawing them in any other order
- * — four separate `scatter()` calls, say — gives a different sky from the same
- * seed. Built once at module load.
- */
-function buildField(count) {
-  const rnd = mulberry32((0x5747 ^ count) >>> 0);
-  const stars = [];
-  for (let i = 0; i < count; i++) {
-    const fx = rnd();
-    const fy = rnd();
-    // Bias toward the far plane so close, fast streaks stay sparse.
-    const z = Z_NEAR + Z_SPAN * Math.sqrt(rnd());
-    const tw = rnd() * Math.PI * 2;
-    const dia = Math.min(BASE_DIA / z, MAX_DIA);
-    const near = (Z_FAR - z) / Z_SPAN; // 0 far → 1 near
-    stars.push({
-      fx,
-      fy,
-      z,
-      tw,
-      // 0.125·dia = the sprite's lit core (r=4 of 64), with a 1px floor so
-      // the farthest stars still land on a pixel.
-      core: Math.max(1, dia * 0.125),
-      // Outer extent of the sprite's blurred halo (r=6 + blur 2.5 of 64 is
-      // ~gone by 0.24·dia). The discs grade DOWN in alpha toward this edge —
-      // see DeepBand — so it fades out instead of ending in a hard rim.
-      halo: dia * 0.24,
-      haloDiscs: z < 0.45 ? 2 : z < 0.7 ? 1 : 0,
-      alpha: 0.2 + 0.8 * near,
-      color: PALETTE[Math.floor((tw * 0.5 + 0.5) * PALETTE.length) % PALETTE.length]
-    });
-  }
-  return stars;
-}
-
-/**
- * Fields by star count, built on demand.
- *
- * 160 is the real preset. The larger counts exist for AMPLIFIED benchmarking:
- * at 160 the difference between two rendering structures is ~2 CPU points,
- * which on real hardware sits under a noise floor several times that — so the
- * variants are compared at a scale where the difference is unmistakable, and
- * the structure that wins there is the one worth shipping at 160.
- *
- * Note the seed is `0x5747 ^ count`, exactly as the original does it, so each
- * count is its own field rather than a prefix of a bigger one. That is fine
- * here: only the 160 field has to match Everlights.
- */
-const fieldCache = new Map();
-function getField(count) {
-  const cached = fieldCache.get(count);
-  if (cached) return cached;
-  const built = buildField(count);
-  fieldCache.set(count, built);
-  return built;
-}
-const FIELD = getField(COUNT);
-
-/**
- * Bucket by 1/z (∝ speed) rather than by z, so the bands are evenly spaced in
- * the quantity being quantised. Each band carries its member stars and the
- * speed of its centre. Cached per count — the bench route asks for several.
- */
-const bandCache = new Map();
-function buildBands(count, starCount) {
-  const key = `${count}:${starCount}`;
-  const cached = bandCache.get(key);
-  if (cached) return cached;
-  const field = getField(starCount);
-  const invNear = 1 / Z_NEAR; // 4
-  const invFar = 1 / Z_FAR; // 1
-  const span = invNear - invFar;
-  const buckets = Array.from({
-    length: count
-  }, () => []);
-  for (const star of field) {
-    const t = (1 / star.z - invFar) / span;
-    const idx = Math.min(count - 1, Math.max(0, Math.floor(t * count)));
-    buckets[idx].push(star);
-  }
-  const bands = buckets.map((stars, i) => ({
-    stars,
-    // z at the band's centre, back out of the 1/z bucketing.
-    z: 1 / (invFar + (i + 0.5) / count * span)
-  }));
-  bandCache.set(key, bands);
-  return bands;
-}
-const DeepBand = /*#__PURE__*/memo(function DeepBand({
-  bands,
-  index,
-  width,
-  height,
-  animated,
-  raster,
-  halo,
-  opaque,
-  drift,
-  opacity
-}) {
-  const band = bands[index];
-  // One full width of travel takes z / DRIFT seconds, exactly as in the
-  // original's `phase = fx - t·(drift/z)`.
-  const driftValue = useLoop(band.z / DRIFT * 1000, animated && drift);
-  const translateX = driftValue.interpolate({
-    inputRange: [0, 1],
-    outputRange: [0, -width]
-  });
-  // Over a known backdrop an opaque colour is pixel-identical to the
-  // translucent one — the GPU just skips the blend.
-  const paint = (color, alpha) => opaque ? flattenOver(color, alpha, BASE_COLOR) : withAlpha(color, alpha);
-  const parts = [];
-  for (let i = 0; i < band.stars.length; i++) {
-    const star = band.stars[i];
-    const y = star.fy * height;
-    const discs = halo === "none" ? 0 : halo === "flat" ? star.haloDiscs > 0 ? 1 : 0 : star.haloDiscs;
-    // Drawn twice, one width apart, so the layer tiles seamlessly when the
-    // loop snaps back to 0.
-    for (let copy = 0; copy < 2; copy++) {
-      const x = star.fx * width + copy * width;
-      const key = `${i}-${copy}`;
-      for (let h = 0; h < discs; h++) {
-        // Disc 0 is the inner/brighter one so single-disc stars keep a tight
-        // bump; disc 1 adds the faint outer skirt. The alphas approximate the
-        // sprite's blurred α.30 halo (≈0.27 near the core → ~0 at the edge):
-        // stacked they composite to ~0.24 inside, 0.10 outside — a falloff,
-        // not the old hard 0.3/0.51 rim that read as a fat blob.
-        const outer = h === 1;
-        const d = star.halo * (outer ? 1 : 0.65);
-        parts.push(/*#__PURE__*/_jsx(View, {
-          style: {
-            position: "absolute",
-            left: x - d / 2,
-            top: y - d / 2,
-            width: d,
-            height: d,
-            borderRadius: d / 2,
-            backgroundColor: paint(star.color, star.alpha * (outer ? 0.1 : 0.16))
-          }
-        }, `${key}-h${h}`));
-      }
-      parts.push(/*#__PURE__*/_jsx(View, {
-        style: {
-          position: "absolute",
-          left: x - star.core / 2,
-          top: y - star.core / 2,
-          width: star.core,
-          height: star.core,
-          borderRadius: star.core / 2,
-          backgroundColor: paint(star.color, star.alpha)
-        }
-      }, key));
-    }
-  }
-  return /*#__PURE__*/_jsx(Animated.View, {
-    style: [{
-      position: "absolute",
-      left: 0,
-      top: 0,
-      width: width * 2,
-      height
-    },
-    // Fused mode puts the wobble on THIS layer instead of a wrapper above
-    // it, so the twinkle costs no extra composited surface.
-    opacity ? {
-      opacity,
-      transform: [{
-        translateX
-      }]
-    } : {
-      transform: [{
-        translateX
-      }]
-    }],
-    pointerEvents: "none",
-    children: /*#__PURE__*/_jsx(RasterLayer, {
-      raster: raster,
-      style: {
-        width: width * 2,
-        height
-      },
-      children: parts
-    })
-  });
-});
-
-/**
- * The four wobble values. The original wobbles each star by
- * `1 + 0.08·sin(t·3 + tw)`; per-star that would be 160 nodes, so bands are
- * round-robined across four pulses at slightly different periods — same ±8%
- * amplitude, and the differing periods keep the sky from pulsing as a unit.
- *
- * Fixed count, called unconditionally, so hook order never varies with props.
- */
-function useTwinkles(animated, enabled) {
-  const a = usePulse(TWINKLE_MS[0], animated && enabled);
-  const b = usePulse(TWINKLE_MS[1], animated && enabled);
-  const c = usePulse(TWINKLE_MS[2], animated && enabled);
-  const d = usePulse(TWINKLE_MS[3], animated && enabled);
-  // Full ±8%, like the original's `1 + 0.08·sin`. The top half exceeds 1 and
-  // the compositor clamps it — the original does the same (`if (a > 1) a = 1`),
-  // so bright stars flatten at the peak there too; dimmer-than-1 layers just
-  // never get the boost, which is the remaining (invisible) approximation.
-  const range = {
-    inputRange: [0, 1],
-    outputRange: [1 - TWINKLE, 1 + TWINKLE]
-  };
-  return [a.interpolate(range), b.interpolate(range), c.interpolate(range), d.interpolate(range)];
-}
-/**
- * The tunable body. `DeepField` below is this with the shipping defaults; the
- * bench route (`example-dev-build/app/bg-bench.tsx`) drives the knobs so every
- * measured variant is this exact code, not a copy of it.
- */
-export const DeepFieldTunable = /*#__PURE__*/memo(function DeepFieldTunable({
-  width,
-  height,
-  animated,
-  bandCount = BAND_COUNT,
-  raster = true,
-  twinkle = "group",
-  halo = "full",
-  opaque = false,
-  drift = true,
-  starCount = COUNT,
-  chrome = true
-}) {
-  const bands = buildBands(bandCount, starCount);
-  const twinkles = useTwinkles(animated, twinkle !== "off");
-  const bandViews = [];
-  for (let i = 0; i < bandCount; i++) {
-    bandViews.push(/*#__PURE__*/_jsx(DeepBand, {
-      bands: bands,
-      index: i,
-      width: width,
-      height: height,
-      animated: animated,
-      raster: raster,
-      halo: halo,
-      opaque: opaque,
-      drift: drift,
-      opacity: twinkle === "fused" ? twinkles[i % TWINKLE_GROUPS] : undefined
-    }, i));
-  }
-  return /*#__PURE__*/_jsxs(View, {
-    style: absoluteFill,
-    pointerEvents: "none",
-    children: [chrome ? /*#__PURE__*/_jsxs(_Fragment, {
-      children: [/*#__PURE__*/_jsx(Base, {
-        color: BASE_COLOR
-      }), /*#__PURE__*/_jsx(RadialGlow, {
-        size: width * 1.7,
-        color: "#1E3A8A",
-        alpha: 0.16,
-        rings: 8,
-        falloff: 2.1,
-        style: {
-          position: "absolute",
-          left: -width * 0.35,
-          top: -width
-        }
-      })]
-    }) : null, twinkle === "group" ?
-    // Group mode: one full-screen Animated.View per pulse, each wrapping
-    // its share of the bands. Costs four extra composited surfaces.
-    Array.from({
-      length: TWINKLE_GROUPS
-    }, (_, g) => /*#__PURE__*/_jsx(Animated.View, {
-      style: [absoluteFill, {
-        opacity: twinkles[g]
-      }],
-      pointerEvents: "none",
-      children: bandViews.filter((_, i) => i % TWINKLE_GROUPS === g)
-    }, g)) : bandViews]
-  });
-});
-
-/**
- * The shipping preset: the Everlights field with the meteor layer on top —
- * the old standalone "Meteors" preset was folded in here (its own 40-star sky
- * dropped; this field is the better one). `DeepFieldTunable` stays meteor-free
- * so the bench route keeps measuring the field itself.
- */
-export const DeepField = /*#__PURE__*/memo(function DeepField(props) {
-  return /*#__PURE__*/_jsxs(View, {
-    style: absoluteFill,
-    pointerEvents: "none",
-    children: [/*#__PURE__*/_jsx(DeepFieldTunable, {
-      ...props
-    }), /*#__PURE__*/_jsx(MeteorShower, {
-      ...props
-    })]
-  });
-});
+"use strict";import{memo as T}from"react";import{Animated as S,View as E}from"react-native";import{absoluteFill as B}from"../../../utils/absoluteFill.js";import{Base as Z,RadialGlow as q,RasterLayer as G,useLoop as X,usePulse as _}from"../primitives.js";import{flattenOver as H,mulberry32 as J,withAlpha as Q}from"../rng.js";import{MeteorShower as Y}from"./meteors.js";import{jsx as p,Fragment as tt,jsxs as N}from"react/jsx-runtime";const $=160;const ot=.016;const k=5;const M=.25;const w=1;const z=w-M;const et=k/M;const P=.08;const I=["#FFFFFF","#B3D9FF","#8CB3FF"];const V="#050609";const nt=18;const L=4;const R=[4200,4900,5600,6300];function st(o){const t=J((22343^o)>>>0);const r=[];for(let s=0;s<o;s++){const c=t();const f=t();const e=M+z*Math.sqrt(t());const l=t()*Math.PI*2;const u=Math.min(k/e,et);const m=(w-e)/z;r.push({fx:c,fy:f,z:e,tw:l,core:Math.max(1,u*.125),halo:u*.24,haloDiscs:e<.45?2:e<.7?1:0,alpha:.2+.8*m,color:I[Math.floor((l*.5+.5)*I.length)%I.length]})}return r}const j=new Map;function K(o){const t=j.get(o);if(t)return t;const r=st(o);j.set(o,r);return r}const mt=K($);const U=new Map;function rt(o,t){const r=`${o}:${t}`;const s=U.get(r);if(s)return s;const c=K(t);const f=1/M;const e=1/w;const l=f-e;const u=Array.from({length:o},()=>[]);for(const h of c){const d=(1/h.z-e)/l;const b=Math.min(o-1,Math.max(0,Math.floor(d*o)));u[b].push(h)}const m=u.map((h,d)=>({stars:h,z:1/(e+(d+.5)/o*l)}));U.set(r,m);return m}const ct=T(function o({bands:t,index:r,width:s,height:c,animated:f,raster:e,halo:l,opaque:u,drift:m,opacity:h}){const d=t[r];const b=X(d.z/ot*1e3,f&&m);const g=b.interpolate({inputRange:[0,1],outputRange:[0,-s]});const F=(a,n)=>u?H(a,n,V):Q(a,n);const i=[];for(let a=0;a<d.stars.length;a++){const n=d.stars[a];const A=n.fy*c;const W=l==="none"?0:l==="flat"?n.haloDiscs>0?1:0:n.haloDiscs;for(let D=0;D<2;D++){const v=n.fx*s+D*s;const C=`${a}-${D}`;for(let x=0;x<W;x++){const O=x===1;const y=n.halo*(O?1:.65);i.push(p(E,{style:{position:"absolute",left:v-y/2,top:A-y/2,width:y,height:y,borderRadius:y/2,backgroundColor:F(n.color,n.alpha*(O?.1:.16))}},`${C}-h${x}`))}i.push(p(E,{style:{position:"absolute",left:v-n.core/2,top:A-n.core/2,width:n.core,height:n.core,borderRadius:n.core/2,backgroundColor:F(n.color,n.alpha)}},C))}}return p(S.View,{style:[{position:"absolute",left:0,top:0,width:s*2,height:c},h?{opacity:h,transform:[{translateX:g}]}:{transform:[{translateX:g}]}],pointerEvents:"none",children:p(G,{raster:e,style:{width:s*2,height:c},children:i})})});function at(o,t){const r=_(R[0],o&&t);const s=_(R[1],o&&t);const c=_(R[2],o&&t);const f=_(R[3],o&&t);const e={inputRange:[0,1],outputRange:[1-P,1+P]};return[r.interpolate(e),s.interpolate(e),c.interpolate(e),f.interpolate(e)]}export const DeepFieldTunable=T(function o({width:t,height:r,animated:s,bandCount:c=nt,raster:f=true,twinkle:e="group",halo:l="full",opaque:u=false,drift:m=true,starCount:h=$,chrome:d=true}){const b=rt(c,h);const g=at(s,e!=="off");const F=[];for(let i=0;i<c;i++){F.push(p(ct,{bands:b,index:i,width:t,height:r,animated:s,raster:f,halo:l,opaque:u,drift:m,opacity:e==="fused"?g[i%L]:void 0},i))}return N(E,{style:B,pointerEvents:"none",children:[d?N(tt,{children:[p(Z,{color:V}),p(q,{size:t*1.7,color:"#1E3A8A",alpha:.16,rings:8,falloff:2.1,style:{position:"absolute",left:-t*.35,top:-t}})]}):null,e==="group"?Array.from({length:L},(i,a)=>p(S.View,{style:[B,{opacity:g[a]}],pointerEvents:"none",children:F.filter((n,A)=>A%L===a)},a)):F]})});export const DeepField=T(function o(t){return N(E,{style:B,pointerEvents:"none",children:[p(DeepFieldTunable,{...t}),p(Y,{...t})]})});

package/lib/module/ui/backgrounds/variants/hyperspace.js

@@ -1,214 +1 @@
-"use strict";
-
-/**
- * Hyperspace — a faithful port of the Everlights `HyperspaceBackground`
- * (components/hyperspace-background.tsx), the Star Wars "lightspeed" field:
- * crisp ROUND points streaming out of a centre vanishing point on the 3D
- * depth projection `screen = plane / z`.
- *
- * THE FIELD IS EXACT: one mulberry32 stream seeded `0x5747 ^ 260`, pulling
- * `ang, rad, z0, tw` per star in the original's call order — same 260 stars,
- * same sqrt-biased radii with the 12% clear centre, same palette pick
- * formula, same z sweep (1.0 → 0.06), same speed (0.55 z-units/sec, the
- * "lightspeed" tuning), same 0.15 + 0.85·near² brightness with 6% fade at
- * both ends of a star's life. Stars are round dots, NOT streaks — the
- * original never elongates anything.
- *
- * HOW THE PROJECTION RUNS WITHOUT SKIA: a star at plane offset p appears at
- * `centre + (p/z)·centre`, so a LAYER scaled by S = 1/z about the centre
- * carries every star along its exact trajectory. The z-sweep becomes scale
- * keyframes on ONE looping value.
- *
- * WHAT COULDN'T COME ACROSS 1:1, and what was done instead:
- *
- *  - **Continuous per-star start phase.** Every star has its own `z0`; per
- *    star that's 260 nodes. `z0` (and ONLY z0) is quantised into 8 shells —
- *    the same single-quantity discipline Deep Field applies to speed.
- *    Position, size, colour and brightness stay exact.
- *  - **The size CAP.** The original stamps its sprite at `dia = baseDia/z`
- *    capped at 4.5×base, but a scaling layer can't cap one star's size
- *    mid-flight. Instead each dot is drawn at the sprite's true lit-core
- *    size (12.5% of the stamp — 0.45px at z=1), which reaches the original's
- *    2px cap at the cap's own z and only overshoots inside the final 6%
- *    fade-out, where brightness is already dying.
- *  - **The blurred sprite.** As in Deep Field: a solid core at the lit 12.5%
- *    plus one concentric disc at the halo's α0.30 stands in for the blur.
- *  - **Additive blend + the 5% twinkle** are dropped; over near-black at this
- *    density neither reads.
- */
-
-import { memo } from "react";
-import { Animated, View } from "react-native";
-import { absoluteFill } from "../../../utils/absoluteFill.js";
-import { Base, RasterLayer, Vignette, useLoop } from "../primitives.js";
-import { mulberry32, withAlpha } from "../rng.js";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-const BASE_COLOR = "#050505";
-
-// ---------------------------------------------------------------------------
-// The original's constants, verbatim (variant 1, "lightspeed").
-// ---------------------------------------------------------------------------
-const COUNT = 260;
-const SPEED = 0.55; // z-units/sec → one life = 1/0.55 s
-const BASE_DIA = 3.6; // sprite diameter px at z=1
-const PLANE = 0.5;
-const Z_FAR = 1.0;
-const Z_NEAR = 0.06;
-const Z_SPAN = Z_FAR - Z_NEAR;
-/** The lit core of the 64px sprite is r=4 → 12.5% of the stamp. */
-const CORE_FRAC = 0.125;
-const CYCLE_MS = Math.round(1000 / SPEED);
-const PALETTE = ["#FFFFFF", "#B3D9FF", "#8CB3FF"];
-const SHELLS = 8;
-/**
- * The original field, regenerated — ONE rng stream, original call order
- * (ang, rad, z0, tw per star), original seed. Any other order or seed is a
- * different sky.
- */
-function buildField() {
-  const rnd = mulberry32((0x5747 ^ COUNT) >>> 0);
-  const stars = [];
-  for (let i = 0; i < COUNT; i++) {
-    const ang = rnd() * Math.PI * 2;
-    // sqrt-biased outward, inner 12% clear of the vanishing point.
-    const rad = (0.12 + 0.88 * Math.sqrt(rnd())) * PLANE;
-    const z0 = rnd();
-    const tw = rnd() * Math.PI * 2;
-    stars.push({
-      px: Math.cos(ang) * rad,
-      py: Math.sin(ang) * rad,
-      shell: Math.min(SHELLS - 1, Math.floor(z0 * SHELLS)),
-      // The original's exact (quirky) pick: floor((tw·0.5 + 0.5)·n) % n.
-      color: PALETTE[Math.floor((tw * 0.5 + 0.5) * PALETTE.length) % PALETTE.length]
-    });
-  }
-  return stars;
-}
-const FIELD = buildField();
-
-/** S(p) = 1/z with z falling linearly over the phase — the projection. */
-function scaleAt(p) {
-  return 1 / (Z_FAR - p * Z_SPAN);
-}
-
-/** The original's brightness: 0.15 + 0.85·near², faded over the first and
- * last 6% of a star's life (which also hides the shell's wrap snap). */
-function opacityAt(p) {
-  let bright = 0.15 + 0.85 * p * p;
-  if (p < 0.06) bright *= p / 0.06;else if (p > 0.94) bright *= (1 - p) / 0.06;
-  return Math.min(1, bright);
-}
-
-/** Interpolate stops for shell k (phase = (v + k/K) mod 1); the wrap point is
- * double-sampled 1e-4 apart inside the zero-opacity sliver. */
-function shellStops(k) {
-  const offset = k / SHELLS;
-  const vs = [];
-  const SEGMENTS = 18;
-  for (let i = 0; i <= SEGMENTS; i++) vs.push(i / SEGMENTS);
-  const vWrap = (1 - offset) % 1;
-  if (vWrap > 1e-3 && vWrap < 1 - 1e-3) vs.push(vWrap - 1e-4, vWrap + 1e-4);
-  vs.sort((a, b) => a - b);
-  const input = [];
-  const scale = [];
-  const opacity = [];
-  for (const v of vs) {
-    // At the loop boundary the offset-0 shell's phase must read as END of
-    // life (p=1, max scale, zero opacity), not wrap to 0 — otherwise the
-    // last segment lerps scale back to 1 at visible opacity and the stars
-    // retract to the centre once per cycle.
-    const p = offset === 0 && v === 1 ? 1 : (v + offset) % 1;
-    input.push(v);
-    scale.push(scaleAt(p));
-    opacity.push(opacityAt(p));
-  }
-  return {
-    input,
-    scale,
-    opacity
-  };
-}
-const SHELL_STOPS = Array.from({
-  length: SHELLS
-}, (_, k) => shellStops(k));
-export const Hyperspace = /*#__PURE__*/memo(function Hyperspace({
-  width,
-  height,
-  animated
-}) {
-  const drive = useLoop(CYCLE_MS, animated);
-  const cx = width / 2;
-  const cy = height / 2;
-
-  // Core at the sprite's lit 12.5% (0.45px at z=1) with a floor so the far
-  // stars land on a pixel; halo disc at the sprite's α0.30, 2.4× the core.
-  const core = Math.max(0.5, BASE_DIA * CORE_FRAC);
-  const halo = core * 2.4;
-  const shells = [];
-  for (let k = 0; k < SHELLS; k++) {
-    const stops = SHELL_STOPS[k];
-    const stars = [];
-    for (let i = 0; i < FIELD.length; i++) {
-      const star = FIELD[i];
-      if (star.shell !== k) continue;
-      // The original's projection at z=1: sx = cx + px·cx, sy = cy + py·cy
-      // (offsets scale with the HALF-extent — elliptical, exactly as there).
-      const x = cx + star.px * cx;
-      const y = cy + star.py * cy;
-      stars.push(/*#__PURE__*/_jsx(View, {
-        style: {
-          position: "absolute",
-          left: x - halo / 2,
-          top: y - halo / 2,
-          width: halo,
-          height: halo,
-          borderRadius: halo / 2,
-          backgroundColor: withAlpha(star.color, 0.3)
-        }
-      }, `${i}-h`), /*#__PURE__*/_jsx(View, {
-        style: {
-          position: "absolute",
-          left: x - core / 2,
-          top: y - core / 2,
-          width: core,
-          height: core,
-          borderRadius: core / 2,
-          backgroundColor: star.color
-        }
-      }, i));
-    }
-    shells.push(/*#__PURE__*/_jsx(Animated.View, {
-      style: [absoluteFill, {
-        opacity: drive.interpolate({
-          inputRange: stops.input,
-          outputRange: stops.opacity
-        }),
-        transform: [{
-          scale: drive.interpolate({
-            inputRange: stops.input,
-            outputRange: stops.scale
-          })
-        }]
-      }],
-      pointerEvents: "none",
-      children: /*#__PURE__*/_jsx(RasterLayer, {
-        style: absoluteFill,
-        raster: false,
-        children: stars
-      })
-    }, k));
-  }
-  return /*#__PURE__*/_jsxs(View, {
-    style: [absoluteFill, {
-      overflow: "hidden"
-    }],
-    pointerEvents: "none",
-    children: [/*#__PURE__*/_jsx(Base, {
-      color: BASE_COLOR
-    }), shells, /*#__PURE__*/_jsx(Vignette, {
-      color: "#000000",
-      alpha: 0.3,
-      spread: 0.3
-    })]
-  });
-});
+"use strict";import{memo as L}from"react";import{Animated as _,View as y}from"react-native";import{absoluteFill as E}from"../../../utils/absoluteFill.js";import{Base as b,RasterLayer as C,Vignette as v,useLoop as w}from"../primitives.js";import{mulberry32 as P,withAlpha as B}from"../rng.js";import{jsx as p,jsxs as N}from"react/jsx-runtime";const O="#050505";const S=260;const T=.55;const j=3.6;const D=.5;const R=1;const H=.06;const I=R-H;const k=.125;const V=Math.round(1e3/T);const g=["#FFFFFF","#B3D9FF","#8CB3FF"];const d=8;function Z(){const t=P((22343^S)>>>0);const s=[];for(let e=0;e<S;e++){const c=t()*Math.PI*2;const n=(.12+.88*Math.sqrt(t()))*D;const i=t();const a=t()*Math.PI*2;s.push({px:Math.cos(c)*n,py:Math.sin(c)*n,shell:Math.min(d-1,Math.floor(i*d)),color:g[Math.floor((a*.5+.5)*g.length)%g.length]})}return s}const x=Z();function q(t){return 1/(R-t*I)}function z(t){let s=.15+.85*t*t;if(t<.06)s*=t/.06;else if(t>.94)s*=(1-t)/.06;return Math.min(1,s)}function G(t){const s=t/d;const e=[];const c=18;for(let o=0;o<=c;o++)e.push(o/c);const n=(1-s)%1;if(n>.001&&n<1-.001)e.push(n-1e-4,n+1e-4);e.sort((o,l)=>o-l);const i=[];const a=[];const r=[];for(const o of e){const l=s===0&&o===1?1:(o+s)%1;i.push(o);a.push(q(l));r.push(z(l))}return{input:i,scale:a,opacity:r}}const U=Array.from({length:d},(t,s)=>G(s));export const Hyperspace=L(function t({width:s,height:e,animated:c}){const n=w(V,c);const i=s/2;const a=e/2;const r=Math.max(.5,j*k);const o=r*2.4;const l=[];for(let h=0;h<d;h++){const m=U[h];const F=[];for(let u=0;u<x.length;u++){const f=x[u];if(f.shell!==h)continue;const A=i+f.px*i;const M=a+f.py*a;F.push(p(y,{style:{position:"absolute",left:A-o/2,top:M-o/2,width:o,height:o,borderRadius:o/2,backgroundColor:B(f.color,.3)}},`${u}-h`),p(y,{style:{position:"absolute",left:A-r/2,top:M-r/2,width:r,height:r,borderRadius:r/2,backgroundColor:f.color}},u))}l.push(p(_.View,{style:[E,{opacity:n.interpolate({inputRange:m.input,outputRange:m.opacity}),transform:[{scale:n.interpolate({inputRange:m.input,outputRange:m.scale})}]}],pointerEvents:"none",children:p(C,{style:E,raster:false,children:F})},h))}return N(y,{style:[E,{overflow:"hidden"}],pointerEvents:"none",children:[p(b,{color:O}),l,p(v,{color:"#000000",alpha:.3,spread:.3})]})});