@motionscript/geo 0.0.0-stage → 0.1.0-alpha.0

package/src/globe/projection.ts

@@ -0,0 +1,261 @@
+/**
+ * Where a latitude and a longitude are, in the three spaces the Globe works in:
+ * the unit sphere it draws on, the equirectangular texture it paints, and the
+ * orbit camera it is looked at through.
+ *
+ * All three are fixed by one decision, and it is the decision every other file
+ * in this node depends on, so it is made here and nowhere else.
+ *
+ * ## The convention, and why it is not the obvious one
+ *
+ * Two things have to be true at once, and motion-script's camera lets you have
+ * either but not both by default:
+ *
+ * 1. **The stored `orbit` field reads directly as a longitude.** That would let
+ *    the camera be three appearance numbers *and* the Fly To command be
+ *    arithmetic on two of them with nothing in between.
+ * 2. **East is to the right.** Looking at the Atlantic from space, Africa is
+ *    right of Brazil. A globe that fails this is a mirrored Earth, which no
+ *    amount of convenience elsewhere pays for.
+ *
+ * The clash: `resolveCameraPlacement` puts a camera at azimuth `a` at
+ * `(sin a, ·, cos a)`, and `cameraOrbit` (`view3d-kit/shared.ts`) feeds it
+ * `90 - orbit`, so a camera at stored orbit θ sits at `(cos θ, ·, sin θ)` and its
+ * screen-right is `-Z`. Increasing θ therefore swings the scene **rightward** —
+ * measured, not reasoned: it is what every existing 3D node does, and the globe
+ * has to match or it is the one viewport whose drag goes backwards.
+ *
+ * So (1) is what gives. Longitude runs the *other* way round the Y axis —
+ * {@link latLonToVector} negates Z, which is what puts east on the right — and a
+ * camera at heading θ is consequently centred over longitude −θ. The stored
+ * field is a heading, labelled "Orbit" like every other viewport's, and
+ * {@link orbitForLongitude} is the one place the two are converted.
+ *
+ * The Fly To command is where that conversion earns its keep: its arguments
+ * genuinely are a latitude and a longitude, and it turns them into a heading
+ * here rather than anywhere else.
+ *
+ * ## The texture
+ *
+ * Plain equirectangular, the orientation any world map image already has:
+ * longitude −180…180 left to right, latitude +90…−90 top to bottom. That falls
+ * out of the convention above rather than being chosen — see {@link latLonToUV},
+ * which derives it from three's own sphere generator — and it is the strongest
+ * evidence the convention is right: get the handedness wrong and the map that
+ * wraps correctly is a mirrored one.
+ */
+
+/** A point on the unit sphere. */
+export interface Vec3 {
+  x: number
+  y: number
+  z: number
+}
+
+/** A position on the globe, in degrees. */
+export interface LatLon {
+  /** Degrees north of the equator, −90…90. */
+  lat: number
+  /** Degrees east of the prime meridian, −180…180. */
+  lon: number
+}
+
+/**
+ * The bounding box every country path is centred against.
+ *
+ * A `Path` centres on its *own* bounding box unless it is given one, so drawing
+ * the world as one path per country and leaving this off stacks all 177 of them
+ * on the origin. Passing the same frame to each is what keeps them in place —
+ * the same reason the LaTeX renderer passes whole-formula bounds to every glyph.
+ */
+export const WORLD_BOUNDS = [-180, -90, 180, 90] as const
+
+const DEG = Math.PI / 180
+
+/**
+ * The unit-sphere direction of a latitude and longitude.
+ *
+ * `z` is negated against the textbook spherical formula, which is the whole of
+ * the convention above: it is what puts east on the right.
+ */
+export function latLonToVector({ lat, lon }: LatLon): Vec3 {
+  const phi = lat * DEG
+  const lambda = lon * DEG
+  const ring = Math.cos(phi)
+  return {
+    x: ring * Math.cos(lambda),
+    y: Math.sin(phi),
+    z: -ring * Math.sin(lambda),
+  }
+}
+
+/** {@link latLonToVector}, scaled off the surface — markers, arc endpoints. */
+export function latLonToPosition(
+  at: LatLon,
+  radius: number
+): [number, number, number] {
+  const { x, y, z } = latLonToVector(at)
+  return [x * radius, y * radius, z * radius]
+}
+
+/**
+ * Where a latitude and longitude land in the equirectangular texture, as `uv`
+ * in `[0,1]²`.
+ *
+ * Derived rather than chosen, from the two pieces of machinery underneath:
+ *
+ * - three's `SphereGeometry` puts vertex `u` at `(-cos 2πu, ·, sin 2πu)` and
+ *   writes `uv = (u, 1 - v)`, with `v = 0` at the north pole.
+ * - motion-script uploads a rasterized surface with `flipY = true`
+ *   (`skia-render/src/three/handlers/texture.ts`), so the buffer's **first row
+ *   is `uv.y = 1`**.
+ *
+ * Solving `(-cos 2πu, sin 2πu)` against {@link latLonToVector}'s `(x, z)` gives
+ * `2πu = π + λ`, and the latitude falls straight out of `y = cos θ`. The result
+ * is the ordinary world-map layout, which is the point.
+ */
+export function latLonToUV({ lat, lon }: LatLon): { u: number; v: number } {
+  return { u: (lon + 180) / 360, v: 0.5 + lat / 180 }
+}
+
+/**
+ * Where a latitude and longitude land in the **drawing space** of the baked
+ * texture: pixels, **y upward**, origin at the buffer's centre.
+ *
+ * Two of motion-script's conventions meet here, and neither is guessable from a
+ * picture that comes out wrong, so both are written down:
+ *
+ * - **The origin is the buffer's centre**, because `SkiaRenderContext.rasterize`
+ *   translates the offscreen canvas by half its size before handing it to the
+ *   source. Drawn from a top-left origin the map lands a quarter of the world
+ *   off the edge — and still wraps onto the sphere without complaint.
+ * - **`y` is up.** A `PathCommand[]`, and a line's `points`, are authored y-up
+ *   and mirrored by the backend on the way to Skia (`flipPathY`, and the
+ *   `points` map beside it in `render-context.ts`). Drawn y-down the world is
+ *   simply upside down — and every continent still has its own shape, so it
+ *   reads as a texture flipped somewhere in the pipeline rather than as a sign
+ *   in the one function that decides.
+ *
+ * Deliberately *not* the raw buffer's own row order. The backend's flip lands
+ * north on the first row, and `flipY` on the uploaded texture maps that row to
+ * `uv.y = 1` — which is where {@link latLonToUV} independently puts the north
+ * pole. A test ties the two together rather than trusting them to agree.
+ */
+export function latLonToCanvas(
+  { lat, lon }: LatLon,
+  width: number,
+  height: number
+): { x: number; y: number } {
+  return { x: (lon / 360) * width, y: (lat / 180) * height }
+}
+
+/**
+ * The frame every country path is centred against, in that same space.
+ *
+ * See {@link WORLD_BOUNDS} for why passing it to each path matters.
+ */
+export function canvasBounds(
+  width: number,
+  height: number
+): [number, number, number, number] {
+  return [-width / 2, -height / 2, width / 2, height / 2]
+}
+
+/**
+ * The stored `orbit` heading that puts `lon` at the centre of the frame.
+ *
+ * **A negation, and it is the price of two things that matter more than the
+ * field reading as a longitude.**
+ *
+ * `orbit` has to behave exactly as it does on every other 3D node: the canvas
+ * drag adds to it (`orbitByDrag`), and increasing it must swing the scene the
+ * same way it swings a molecule or a surface, or the globe is the one viewport
+ * whose drag goes backwards. That pins `orbit` to `cameraOrbit` with no
+ * conversion in between.
+ *
+ * East also has to be on the right, which pins {@link latLonToVector}'s sign.
+ *
+ * Those two together force the third: a camera at heading θ is centred over
+ * longitude −θ. So the stored field is a **heading**, not a longitude — which is
+ * why the panel labels it "Orbit" like every other viewport's, and why the Fly
+ * To command, whose arguments genuinely are a latitude and a longitude,
+ * converts through here.
+ */
+export function orbitForLongitude(lon: number): number {
+  return -lon
+}
+
+/** The longitude a stored `orbit` heading is centred over. Its own inverse. */
+export function longitudeForOrbit(orbit: number): number {
+  return -orbit
+}
+
+/**
+ * Points along the great circle from `from` to `to`, `segments` spans of them.
+ *
+ * Spherical linear interpolation rather than a lerp of the two lat/lons: the
+ * latter is a rhumb line, which crosses the antimeridian the long way and bulges
+ * badly at high latitudes — a "London to Tokyo" arc drawn that way runs through
+ * Kazakhstan instead of over the pole, which is the one thing the picture exists
+ * to show.
+ *
+ * `lift` raises the middle of the arc off the surface, as a fraction of the
+ * radius, on a sine so both ends meet the sphere flush. Zero draws the path on
+ * the ground.
+ */
+export function greatCircle(
+  from: LatLon,
+  to: LatLon,
+  options: { radius?: number; lift?: number; segments?: number } = {}
+): [number, number, number][] {
+  const radius = options.radius ?? 1
+  const lift = options.lift ?? 0
+  const segments = Math.max(1, Math.floor(options.segments ?? 64))
+
+  const a = latLonToVector(from)
+  const b = latLonToVector(to)
+
+  const dot = clamp(a.x * b.x + a.y * b.y + a.z * b.z, -1, 1)
+  const omega = Math.acos(dot)
+
+  const points: [number, number, number][] = []
+  for (let i = 0; i <= segments; i++) {
+    const t = i / segments
+    // Antipodal or coincident endpoints leave the plane of the circle
+    // undefined; a straight blend is the honest answer for both, and
+    // renormalising below puts it back on the sphere either way.
+    const [wa, wb] =
+      Math.abs(omega) < 1e-6
+        ? [1 - t, t]
+        : [
+            Math.sin((1 - t) * omega) / Math.sin(omega),
+            Math.sin(t * omega) / Math.sin(omega),
+          ]
+
+    const x = a.x * wa + b.x * wb
+    const y = a.y * wa + b.y * wb
+    const z = a.z * wa + b.z * wb
+    const length = Math.hypot(x, y, z) || 1
+    const scale = (radius * (1 + lift * Math.sin(Math.PI * t))) / length
+
+    points.push([x * scale, y * scale, z * scale])
+  }
+  return points
+}
+
+/**
+ * The signed turn from one heading to another, taking whichever way round is
+ * shorter — so 170° to −170° is a 20° nudge east rather than 340° west.
+ *
+ * The same arithmetic `camera-kit`'s unused `shortestTurn` states; it is
+ * duplicated rather than imported because that one is private to a module this
+ * package's 3D nodes do not otherwise depend on, and because a Fly To that got
+ * this wrong would be the command's single most visible failure.
+ */
+export function shortestTurn(from: number, to: number): number {
+  return ((((to - from) % 360) + 540) % 360) - 180
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return value < min ? min : value > max ? max : value
+}

package/src/globe/world-map.ts

@@ -0,0 +1,227 @@
+/**
+ * The world as a flat drawing — the one `Graphics2D` that becomes the sphere's
+ * texture.
+ *
+ * Baking the map in 2D rather than tessellating it in 3D is the node's central
+ * decision, and it is not a shortcut. A WebGL line ignores any width above one
+ * pixel (motion-script says so outright on `LineStroke3D`), so borders drawn as
+ * 3D lines are hairlines at every zoom and every resolution, and the only way to
+ * thicken one is to sweep a tube along it — three hundred tubes, for a picture
+ * that is flat. Drawn here, a border is an ordinary stroke: any weight, any
+ * colour, joined and antialiased by Skia, and it costs one rasterize rather than
+ * one per frame.
+ *
+ * Everything here is therefore *style*, and the node's cache key is exactly the
+ * arguments below. Nothing that moves — a marker, an arc, the camera — is drawn
+ * into this, because baking something that moves would put every frame of its
+ * animation through a full re-rasterize.
+ *
+ * ## One path per country, and this is the whole performance story
+ *
+ * The obvious shape is one `path` op holding all 289 rings — the nonzero fill
+ * rule sorts out what is land, and it is one op instead of 177. **Do not do
+ * that.** Skia's cost for filling and stroking a single path is badly
+ * superlinear in its *contour* count, and the difference is not marginal:
+ *
+ *     one path, 289 contours, 10,649 commands   10,691 ms
+ *     one path per country (177 of them)           205 ms
+ *
+ * Measured in the browser, on the same data, at the same resolution — a 52×
+ * difference, and the reason adding a Globe to a scene used to lock the app for
+ * ten seconds. It is also almost independent of the texture's resolution (256²
+ * and 2048² are within 10% of each other), which is the tell that the cost is
+ * geometry, not pixels, and that turning the map down would not have saved it.
+ *
+ * Splitting per country is safe for the fill: each country's rings — exterior
+ * and holes together — stay in *its* path, so the nonzero rule still cuts
+ * Lesotho out of South Africa, and Lesotho's own path paints it back.
+ *
+ * ## The lines are a separate pass, and have to be
+ *
+ * The country paths are filled and **not** stroked. Stroking them would draw
+ * every international border twice — once from each side, since both countries
+ * carry it — and a doubly-composited antialiased fringe reads as a line half
+ * again as wide as the coastlines beside it. `borders.ts` deduplicates the
+ * segments and stitches them into runs; this file strokes those instead, so
+ * every line on the map is drawn exactly once at exactly one weight.
+ */
+
+import { Graphics2D, type PathCommand } from "@motionscript/core"
+
+import { canvasBounds, latLonToCanvas } from "./projection"
+import { borderLines } from "./borders"
+import { world, type Ring } from "./world"
+
+/** Everything that changes the baked pixels. Also the node's cache key. */
+export interface WorldMapStyle {
+  /** Buffer width in pixels. Height is half of it — the equirectangular ratio. */
+  width: number
+  ocean: string
+  land: string
+  /**
+   * The colour of every coast and border.
+   *
+   * Alpha is fine here, and that is worth saying because it briefly was not:
+   * while the country paths were stroked, a shared border was drawn twice and a
+   * translucent one came out at double density. `drawBoundaries` draws each line
+   * exactly once, so the colour means what it says.
+   */
+  border: string
+  borderWidth: number
+  graticule: boolean
+  graticuleColor: string
+  /** Degrees between graticule lines. */
+  graticuleStep: number
+  graticuleWidth: number
+}
+
+/** The buffer's height for a given width — equirectangular is always 2:1. */
+export function mapHeight(width: number): number {
+  return Math.round(width / 2)
+}
+
+/**
+ * The map, drawn.
+ *
+ * **Hoist the result.** motion-script identifies a surface texture by its source
+ * object, so a fresh `Graphics2D` every frame misses the raster cache, redraws
+ * ten thousand paths, reads the buffer back off the GPU and uploads it again —
+ * sixty times a second, to produce the same image. `Globe` holds one against
+ * this style; nothing else should call this.
+ */
+export function worldMapGraphics(style: WorldMapStyle): Graphics2D {
+  const width = style.width
+  const height = mapHeight(width)
+  const bounds = canvasBounds(width, height)
+
+  const g = new Graphics2D()
+
+  // The ocean is the whole buffer rather than a sphere-coloured backdrop,
+  // because the texture has to be opaque: the sphere is lit, and a transparent
+  // texel would show the inside of the far side through it.
+  g.rect({ width, height }).fill(style.ocean)
+
+  // Land, filled and **not** stroked — see `drawBoundaries` for where the lines
+  // come from and why they cannot come from here.
+  //
+  // One path per country, not one for the world: see the module note for what
+  // that costs.
+  for (const country of world().countries) {
+    const commands: PathCommand[] = []
+    for (const ring of country.rings) appendRing(commands, ring, width, height)
+    if (commands.length === 0) continue
+    g.path({ data: commands, centerBounds: bounds }).fill(style.land)
+  }
+
+  if (style.borderWidth > 0) drawBoundaries(g, style, width, height, bounds)
+
+  // Last, and over the land. The graticule is reference rather than art
+  // direction — the same reading the Canvas 3D viewport's grid takes — so it
+  // reads as an overlay on whatever it crosses rather than as terrain.
+  if (style.graticule) {
+    for (const line of graticuleLines(style.graticuleStep, width, height)) {
+      g.line({ points: line }).stroke({
+        fill: style.graticuleColor,
+        weight: style.graticuleWidth,
+      })
+    }
+  }
+
+  return g
+}
+
+function appendRing(
+  commands: PathCommand[],
+  ring: Ring,
+  width: number,
+  height: number
+): void {
+  const count = ring.points.length / 2
+  for (let i = 0; i < count; i++) {
+    const { x, y } = latLonToCanvas(
+      { lon: ring.points[i * 2]!, lat: ring.points[i * 2 + 1]! },
+      width,
+      height
+    )
+    commands.push(i === 0 ? { type: "M", x, y } : { type: "L", x, y })
+  }
+  // Closed explicitly: the ring's repeated last point was dropped when it was
+  // vendored, so without this the stroke leaves a notch at every country's
+  // starting vertex and the fill's last edge is implied rather than drawn.
+  commands.push({ type: "Z" })
+}
+
+/**
+ * Every coast and border, stroked once each.
+ *
+ * **One path per run**, for exactly the reason the countries are one path each:
+ * a path's stroke cost is superlinear in its contour count. Gathering the 277
+ * runs into two paths of ~200 contours put this straight back on the cliff the
+ * countries were moved off — measured at 2.5 s of stall, against none at one
+ * run per path.
+ *
+ * One-per-run rather than a tuned chunk size because there is no number to
+ * defend: 277 paths is the same order as the 177 the countries already use, and
+ * a constant here would be a knob whose safe range nobody could state.
+ */
+function drawBoundaries(
+  g: Graphics2D,
+  style: WorldMapStyle,
+  width: number,
+  height: number,
+  bounds: readonly [number, number, number, number]
+): void {
+  const paint = { fill: style.border, weight: style.borderWidth }
+
+  for (const line of borderLines()) {
+    const count = line.length / 2
+    if (count < 2) continue
+    const commands: PathCommand[] = []
+    for (let i = 0; i < count; i++) {
+      const { x, y } = latLonToCanvas(
+        { lon: line[i * 2]!, lat: line[i * 2 + 1]! },
+        width,
+        height
+      )
+      commands.push(i === 0 ? { type: "M", x, y } : { type: "L", x, y })
+    }
+    // Left open: a boundary run is a line, not a ring, and closing it would draw
+    // a chord back to wherever the run happened to start.
+    g.path({ data: commands, centerBounds: bounds }).stroke(paint)
+  }
+}
+
+/**
+ * The meridians and parallels, as polylines in drawing space.
+ *
+ * Straight lines, because an equirectangular projection is exactly the one where
+ * meridians and parallels are straight — the grid is curved on the sphere only
+ * because the sphere curves. Meridians run pole to pole and parallels edge to
+ * edge, and both stop short of the poles by one step so the drawing does not
+ * pile every meridian onto the same two points.
+ */
+function graticuleLines(
+  step: number,
+  width: number,
+  height: number
+): { x: number; y: number }[][] {
+  const spacing = Math.max(5, Math.min(90, step))
+  const lines: { x: number; y: number }[][] = []
+
+  for (let lon = -180; lon <= 180; lon += spacing) {
+    const meridian: { x: number; y: number }[] = []
+    for (let lat = -90; lat <= 90; lat += 5) {
+      meridian.push(latLonToCanvas({ lat, lon }, width, height))
+    }
+    lines.push(meridian)
+  }
+
+  for (let lat = -90 + spacing; lat <= 90 - spacing; lat += spacing) {
+    lines.push([
+      latLonToCanvas({ lat, lon: -180 }, width, height),
+      latLonToCanvas({ lat, lon: 180 }, width, height),
+    ])
+  }
+
+  return lines
+}

package/src/globe/world.ts

@@ -0,0 +1,111 @@
+/**
+ * The vendored boundaries, decoded once and held.
+ *
+ * The generated module beside it is a string and a table of ring sizes; this
+ * turns them into flat coordinate arrays and memoises the result, so a document
+ * with a globe pays for the decode once per process and a document without one
+ * never pays at all. That laziness is the whole reason the data can be a plain
+ * static import rather than something threaded through a resolver: the 40 KB is
+ * transferred either way, but nothing is parsed, allocated or walked until a
+ * globe actually draws.
+ *
+ * Coordinates stay in **degrees**, not pixels and not sphere positions. The
+ * texture resolution is a prop and the projection is `projection.ts`'s business;
+ * baking either into the data would mean re-vendoring to change a number.
+ */
+
+import { COUNTRIES, POINTS, PRECISION, type CountryRow } from "./data/ne-110m"
+
+/**
+ * One closed ring, as `[lon, lat, lon, lat, …]` degrees.
+ *
+ * Flat rather than an array of pairs for the reason the Protein's structure is
+ * flat: the map is redrawn whenever its style changes and a pair object per
+ * vertex would put ten thousand allocations behind every colour edit.
+ */
+export interface Ring {
+  points: Float64Array
+  /**
+   * Whether this ring cuts rather than fills.
+   *
+   * It is drawn either way — the nonzero fill rule does the cutting, off the
+   * winding the vendoring script enforced. This is here so a caller that wants
+   * to *outline* only the coastlines can skip it.
+   */
+  hole: boolean
+}
+
+export interface Country {
+  id: string
+  name: string
+  rings: Ring[]
+}
+
+export interface World {
+  countries: readonly Country[]
+  /** Every ring of every country, in one list — the order the map draws in. */
+  rings: readonly Ring[]
+}
+
+let decoded: World | null = null
+
+/** The world, decoded on first use and shared thereafter. */
+export function world(): World {
+  return (decoded ??= decode())
+}
+
+function decode(): World {
+  const countries: Country[] = []
+  const rings: Ring[] = []
+
+  const cursor = { at: 0 }
+  for (const row of COUNTRIES as readonly CountryRow[]) {
+    const own: Ring[] = []
+    for (const size of row.rings) {
+      const ring = { points: readRing(cursor, Math.abs(size)), hole: size < 0 }
+      own.push(ring)
+      rings.push(ring)
+    }
+    countries.push({ id: row.id, name: row.name, rings: own })
+  }
+
+  // A short read leaves the tail unconsumed and every ring after the mistake
+  // shifted, which draws as a plausible-looking but wrong world rather than as
+  // an error — so the two halves of the generated file are checked against each
+  // other here, once, where the cost is nothing.
+  if (cursor.at !== POINTS.length) {
+    throw new Error(
+      `globe: boundary data is inconsistent — decoded ${cursor.at} of ${POINTS.length} characters`
+    )
+  }
+
+  return { countries, rings }
+}
+
+/** `count` points, delta-decoded from the ring's own origin. */
+function readRing(cursor: { at: number }, count: number): Float64Array {
+  const points = new Float64Array(count * 2)
+  let lon = 0
+  let lat = 0
+  for (let i = 0; i < count; i++) {
+    lon += readValue(cursor)
+    lat += readValue(cursor)
+    points[i * 2] = lon / PRECISION
+    points[i * 2 + 1] = lat / PRECISION
+  }
+  return points
+}
+
+/** One zig-zagged varint. The inverse of the script's `encodeValue`. */
+function readValue(cursor: { at: number }): number {
+  let shift = 0
+  let result = 0
+  for (;;) {
+    const byte = POINTS.charCodeAt(cursor.at++) - 63
+    result |= (byte & 0x1f) << shift
+    // The continuation bit: set on every chunk but the last.
+    if (byte < 0x20) break
+    shift += 5
+  }
+  return result & 1 ? ~(result >> 1) : result >> 1
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from "./border";
+export * from "./globe";
+// Not through ./globe: that barrel is copied with the globe item, and world.ts is not.
+export * from "./globe/world";
+export { NODES } from "./nodes";

package/src/nodes.ts

@@ -0,0 +1,19 @@
+import { GeoBorder } from "./border";
+import { Globe } from "./globe";
+
+/**
+ * Every node type this package publishes.
+ *
+ * A host registers these by handing the array to an engine —
+ * `new Engine(platform, { nodes: NODES })` — which reads each class's `@node()`
+ * key. The decorator only *declares* that key: nothing is registered by the mere
+ * act of importing a module, so a registry holds exactly what its owner asked
+ * for and two engines in one process can differ about it.
+ *
+ * Listing class **values** is also what survives bundling. This package declares
+ * `sideEffects: false`, which licenses a bundler to drop a module nothing
+ * imports a value from, and a document names a node type by string — so
+ * `import "./globe"` for its side effect is exactly what gets shaken out, where an
+ * array of bindings is a data dependency that cannot be.
+ */
+export const NODES = [Globe, GeoBorder];

package/README.md

@@ -1,4 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
-If no other versions are published within 30 days, this package and version will be deleted.