diff --git a/CMakeLists.txt b/CMakeLists.txt
index 08a2a0e..eb51f2f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -26,7 +26,10 @@ set(SHAPE_LIB  "${DGGRID_DIR}/src/lib/shapelib/lib")
 # (src/igeo7_extension.cpp) is intentionally excluded.
 set(IGEO7_DIR "${CMAKE_SOURCE_DIR}/submodules/igeo7_duckdb")
 set(IGEO7_Z7_INC "${IGEO7_DIR}/src")
-set(IGEO7_Z7_SOURCES "${IGEO7_DIR}/src/z7/library.cpp")
+set(IGEO7_Z7_SOURCES
+    "${IGEO7_DIR}/src/z7/library.cpp"
+    "${IGEO7_DIR}/src/auth/authalic.cpp"
+)
 
 # ── Source files ──────────────────────────────────────────────────────────
 file(GLOB DGLIB_SOURCES  "${DGLIB_LIB}/*.cpp")
diff --git a/docs/.vitepress/config.ts b/docs/.vitepress/config.ts
index 5a97678..b3f9506 100644
--- a/docs/.vitepress/config.ts
+++ b/docs/.vitepress/config.ts
@@ -43,6 +43,7 @@ export default defineConfig({
           { text: 'Hierarchical Address Types', link: '/hierarchical-addresses' },
           { text: 'Index Arithmetic', link: '/index-arithmetic' },
           { text: 'IGEO7 / Z7 Index', link: '/igeo7' },
+          { text: 'Authalic Conversion', link: '/authalic' },
           { text: 'Multi-Aperture', link: '/multi-aperture' },
         ],
       },
diff --git a/docs/.vitepress/theme/components/AuthalicDemo.vue b/docs/.vitepress/theme/components/AuthalicDemo.vue
new file mode 100644
index 0000000..c5dea55
--- /dev/null
+++ b/docs/.vitepress/theme/components/AuthalicDemo.vue
@@ -0,0 +1,403 @@
+<script setup>
+import { ref, reactive, onMounted, computed } from 'vue'
+import { loadWebdggrid } from '../utils/loadWebdggrid.js'
+
+// Interactive demo for the two authalic use cases:
+//   1. Cell area on the WGS84 ellipsoid vs the authalic sphere — shows the
+//      mismatch between "DGGRID's claimed equal-area cells" and what flat
+//      planar area on geodetic coords gives you.
+//   2. Visual diff: pick a latitude, render the authalic shift on a
+//      tiny inline map (just text, no globe) — biggest at ±45°, zero at
+//      poles and equator.
+
+const state = reactive({
+  ready: false,
+  loading: true,
+  error: null,
+  testLat: 45,
+  resolution: 5,
+  // amplification factor for the shape-distortion overlay.
+  // 1× shows reality (rings nearly coincide with a small lat offset).
+  // ≥100× makes the *shape* difference (not just the lat shift) visible.
+  amplify: 200,
+  // when true, subtract the per-cell mean lat shift before amplifying so
+  // the user sees the *shape* component of the diff, not the bulk shift.
+  subtractMeanShift: true,
+  cellId: null,
+  geoArea: null,
+  authArea: null,
+  shift: null,
+  vertices: null,
+  vertsAuth: null,
+  cellAreaKm: null,
+  edgesGeo: null,
+  edgesAuth: null,
+})
+
+let dggs = null
+
+// WGS84 mean Earth radius — for sphere-area from steradians.
+const R_WGS84_AUTH_M = 6371007.181
+
+// Compute spherical excess of a polygon on the unit sphere (Girard's theorem).
+// Returns area in steradians.
+function sphericalExcess(ring) {
+  // Convert to 3D unit vectors.
+  const toVec = ([lng, lat]) => {
+    const lr = lng * Math.PI / 180
+    const tr = lat * Math.PI / 180
+    return [Math.cos(tr) * Math.cos(lr), Math.cos(tr) * Math.sin(lr), Math.sin(tr)]
+  }
+  const cross = (a, b) => [a[1]*b[2]-a[2]*b[1], a[2]*b[0]-a[0]*b[2], a[0]*b[1]-a[1]*b[0]]
+  const dot = (a, b) => a[0]*b[0] + a[1]*b[1] + a[2]*b[2]
+  const norm = a => { const m = Math.hypot(a[0], a[1], a[2]); return [a[0]/m, a[1]/m, a[2]/m] }
+
+  const verts = ring.map(toVec)
+  let total = 0
+  const n = verts.length
+  for (let i = 0; i < n; i++) {
+    const a = verts[i]
+    const b = verts[(i + 1) % n]
+    const c = verts[(i + 2) % n]
+    // Interior angle at b between great circles ba and bc:
+    //   angle = atan2(|n1 × n2|, n1 · n2) where n1,n2 are normals to those circles.
+    const n1 = norm(cross(a, b))
+    const n2 = norm(cross(b, c))
+    const angle = Math.acos(Math.max(-1, Math.min(1, -dot(n1, n2))))
+    total += angle
+  }
+  // Spherical excess = sum(angles) - (n-2)π
+  return total - (n - 2) * Math.PI
+}
+
+// Planar (shoelace) area on flat lng/lat — i.e. what you get if you forget
+// the sphere and treat coordinates as 2D. Wrong but illustrative.
+function planarArea(ring) {
+  let s = 0
+  for (let i = 0; i < ring.length; i++) {
+    const [x1, y1] = ring[i]
+    const [x2, y2] = ring[(i + 1) % ring.length]
+    s += (x1 * y2 - x2 * y1)
+  }
+  return Math.abs(s) / 2 // square degrees
+}
+
+onMounted(async () => {
+  try {
+    const Webdggrid = await loadWebdggrid()
+    dggs = await Webdggrid.load()
+    state.ready = true
+    state.loading = false
+    recompute()
+  } catch (e) {
+    state.error = e?.message ?? String(e)
+    state.loading = false
+  }
+})
+
+function recompute() {
+  if (!dggs) return
+  state.error = null
+  try {
+    // Find a cell at the requested latitude, on the prime meridian.
+    const seqs = dggs.geoToSequenceNum([[0, state.testLat]], state.resolution)
+    const cell = seqs[0]
+    state.cellId = cell.toString()
+
+    // The cell ring (lon, lat) — DGGRID-native order, no unwrap.
+    const ring = dggs.sequenceNumToGrid([cell], state.resolution, false)[0]
+
+    // Authalic-shifted ring (latitudes only).
+    const ringA = ring.map(([lng, lat]) => [lng, dggs.igeo7GeoToAuthalic(lat)])
+
+    state.vertices = ring
+    state.vertsAuth = ringA
+    state.shift = ring.map(([_, lat]) => dggs.igeo7GeoToAuthalic(lat) - lat)
+
+    // Area via Girard on each ring × authalic radius².
+    const exG = sphericalExcess(ring)
+    const exA = sphericalExcess(ringA)
+    state.geoArea  = (exG * R_WGS84_AUTH_M ** 2) / 1e6 // km²
+    state.authArea = (exA * R_WGS84_AUTH_M ** 2) / 1e6
+
+    // DGGRID's reported uniform cell area at this resolution (km²).
+    state.cellAreaKm = dggs.cellAreaKM(state.resolution)
+
+    // Edge lengths (great-circle, on the authalic sphere) for both rings.
+    // Useful to confirm the shape effect: even a polar cap's edges change
+    // length under the conversion by a fraction of a percent.
+    state.edgesGeo  = ringEdgeLengths(ring)
+    state.edgesAuth = ringEdgeLengths(ringA)
+  } catch (e) {
+    state.error = e?.message ?? String(e)
+  }
+}
+
+// Great-circle edge lengths on the authalic-radius sphere (km).
+function ringEdgeLengths(ring) {
+  const R = R_WGS84_AUTH_M / 1000
+  const out = []
+  const toRad = d => d * Math.PI / 180
+  for (let i = 0; i < ring.length; i++) {
+    const [l1, p1] = ring[i]
+    const [l2, p2] = ring[(i + 1) % ring.length]
+    const sinHalfDLat = Math.sin(toRad(p2 - p1) / 2)
+    const sinHalfDLon = Math.sin(toRad(l2 - l1) / 2)
+    const a = sinHalfDLat ** 2 + Math.cos(toRad(p1)) * Math.cos(toRad(p2)) * sinHalfDLon ** 2
+    out.push(2 * R * Math.asin(Math.min(1, Math.sqrt(a))))
+  }
+  return out
+}
+
+// SVG view of the cell — overlays the geodetic ring (blue) and the
+// authalic ring (orange). When `amplify > 1`, the orange ring's per-vertex
+// lat is exaggerated so the shape distortion is visible at human scales.
+const svgView = computed(() => {
+  if (!state.vertices) return null
+  const ring = state.vertices
+  const ringA = state.vertsAuth
+  const meanShift = state.subtractMeanShift
+    ? state.shift.reduce((a, b) => a + b, 0) / state.shift.length
+    : 0
+  const amplify = Math.max(1, state.amplify)
+
+  // Build the amplified ring: take the residual (per-vertex shift minus
+  // mean), multiply by amplify, add back to geodetic lat. This visually
+  // separates *shape change* from *bulk shift*.
+  const ringAmp = ring.map(([lng, lat], i) => {
+    const dRes = (ringA[i][1] - lat) - meanShift
+    return [lng, lat + meanShift + dRes * amplify]
+  })
+
+  // Project lng/lat to flat SVG coords with margin.
+  const allLng = [...ring, ...ringAmp].map(v => v[0])
+  const allLat = [...ring, ...ringAmp].map(v => v[1])
+  const lngMin = Math.min(...allLng), lngMax = Math.max(...allLng)
+  const latMin = Math.min(...allLat), latMax = Math.max(...allLat)
+  const lngRange = Math.max(1e-6, lngMax - lngMin)
+  const latRange = Math.max(1e-6, latMax - latMin)
+  const W = 360, H = 240, PAD = 24
+  const sx = (W - 2 * PAD) / lngRange
+  const sy = (H - 2 * PAD) / latRange
+  const s = Math.min(sx, sy)
+  const cx = (lngMin + lngMax) / 2
+  const cy = (latMin + latMax) / 2
+  const project = ([lng, lat]) => [
+    (W / 2) + (lng - cx) * s,
+    (H / 2) - (lat - cy) * s,
+  ]
+  const path = pts => pts.map(p => project(p)).map(([x, y], i) => (i ? 'L' : 'M') + x.toFixed(2) + ',' + y.toFixed(2)).join(' ') + ' Z'
+  return {
+    width: W,
+    height: H,
+    geoPath:  path(ring),
+    authPath: path(ringAmp),
+    geoPts:   ring.map(project),
+    authPts:  ringAmp.map(project),
+  }
+})
+
+const maxShift = computed(() =>
+  state.shift ? Math.max(...state.shift.map(Math.abs)) : 0
+)
+</script>
+
+<template>
+  <div class="auth-demo">
+    <div v-if="state.loading" class="status">Loading WebDggrid WASM…</div>
+    <div v-else-if="state.error && !state.ready" class="status error">
+      Failed to load: {{ state.error }}
+    </div>
+    <template v-else>
+      <div class="controls">
+        <label>
+          <span>Test latitude</span>
+          <input v-model.number="state.testLat" type="range" min="-89" max="89" step="1" @input="recompute" />
+          <strong>{{ state.testLat }}°</strong>
+        </label>
+        <label>
+          <span>Resolution</span>
+          <input v-model.number="state.resolution" type="range" min="1" max="8" step="1" @input="recompute" />
+          <strong>{{ state.resolution }}</strong>
+        </label>
+      </div>
+
+      <div v-if="state.error" class="status error">{{ state.error }}</div>
+
+      <div v-if="state.cellId" class="grid">
+        <section class="card">
+          <h4>Cell at ({{ 0 }}°, {{ state.testLat }}°)</h4>
+          <table class="kv">
+            <tbody>
+              <tr><th>Cell ID</th><td><code>{{ state.cellId }}</code></td></tr>
+              <tr><th>DGGRID claimed area</th><td>{{ state.cellAreaKm.toFixed(4) }} km²</td></tr>
+              <tr>
+                <th>Area (geodetic vertices, Girard)</th>
+                <td>{{ state.geoArea.toFixed(4) }} km²</td>
+              </tr>
+              <tr>
+                <th>Area (authalic vertices, Girard)</th>
+                <td>{{ state.authArea.toFixed(4) }} km²</td>
+              </tr>
+              <tr>
+                <th>Geo / authalic ratio</th>
+                <td>{{ (state.geoArea / state.authArea).toFixed(6) }}</td>
+              </tr>
+            </tbody>
+          </table>
+          <p class="hint">
+            DGGRID emits cells that are equal-area on the <em>authalic</em>
+            sphere. Computing area from the raw lat/lng vertices on a
+            uniform-radius sphere gives a slightly different number; the
+            authalic-shifted version recovers the equal-area property.
+          </p>
+        </section>
+
+        <section class="card">
+          <h4>Per-vertex latitude shift (geo → authalic)</h4>
+          <table class="rows">
+            <thead><tr><th>i</th><th>lng</th><th>geo lat</th><th>authalic lat</th><th>Δ</th></tr></thead>
+            <tbody>
+              <tr v-for="(v, i) in state.vertices" :key="i">
+                <td>{{ i }}</td>
+                <td><code>{{ v[0].toFixed(2) }}</code></td>
+                <td><code>{{ v[1].toFixed(4) }}</code></td>
+                <td><code>{{ state.vertsAuth[i][1].toFixed(4) }}</code></td>
+                <td :class="{ pos: state.shift[i] > 0, neg: state.shift[i] < 0 }">
+                  {{ state.shift[i].toFixed(4) }}°
+                </td>
+              </tr>
+            </tbody>
+          </table>
+          <p class="hint">
+            Max |Δ| at this cell: <strong>{{ maxShift.toFixed(4) }}°</strong>.
+            The shift peaks near ±45° and is zero at the equator and poles.
+          </p>
+        </section>
+
+        <section class="card shape-card">
+          <h4>Shape comparison (geodetic vs authalic)</h4>
+          <div class="shape-controls">
+            <label>
+              <span>Amplify shape diff</span>
+              <input v-model.number="state.amplify" type="range" min="1" max="2000" step="1" />
+              <strong>{{ state.amplify }}×</strong>
+            </label>
+            <label class="inline">
+              <input v-model="state.subtractMeanShift" type="checkbox" />
+              Subtract bulk lat shift (show shape change only)
+            </label>
+          </div>
+          <svg v-if="svgView" :viewBox="`0 0 ${svgView.width} ${svgView.height}`" class="shape-svg" preserveAspectRatio="xMidYMid meet">
+            <path :d="svgView.geoPath"  class="ring-geo"  />
+            <path :d="svgView.authPath" class="ring-auth" />
+            <circle v-for="(p, i) in svgView.geoPts"  :key="'g'+i" :cx="p[0]" :cy="p[1]" r="2.5" class="vert-geo"  />
+            <circle v-for="(p, i) in svgView.authPts" :key="'a'+i" :cx="p[0]" :cy="p[1]" r="2.5" class="vert-auth" />
+          </svg>
+          <p class="hint">
+            <span class="legend ring-geo-legend">geodetic</span>
+            <span class="legend ring-auth-legend">authalic</span>
+            (vertices marked). At <strong>1×</strong> the rings essentially
+            coincide — the conversion is a near-pure latitude translation
+            for any cell that doesn't span much latitude. With "subtract
+            bulk shift" on and amplification ≥100, what's left is the *shape
+            distortion* — the part where vertices at different lats shift by
+            slightly different amounts because <code>dξ/dφ</code> is non-
+            constant. It's small, but it's not zero.
+          </p>
+        </section>
+
+        <section class="card edge-card">
+          <h4>Edge lengths (km, on authalic-radius sphere)</h4>
+          <table class="rows">
+            <thead><tr><th>edge</th><th>geo</th><th>authalic</th><th>Δ%</th></tr></thead>
+            <tbody>
+              <tr v-for="(g, i) in state.edgesGeo" :key="i">
+                <td>{{ i }}</td>
+                <td><code>{{ g.toFixed(3) }}</code></td>
+                <td><code>{{ state.edgesAuth[i].toFixed(3) }}</code></td>
+                <td :class="{ pos: state.edgesAuth[i] > g, neg: state.edgesAuth[i] < g }">
+                  {{ ((state.edgesAuth[i] - g) / g * 100).toFixed(4) }}%
+                </td>
+              </tr>
+            </tbody>
+          </table>
+          <p class="hint">
+            If the conversion were a pure rigid translation, every edge would
+            change length identically. The non-uniform Δ% is direct evidence
+            of shape distortion (north–south edges shrink/stretch differently
+            from east–west edges).
+          </p>
+        </section>
+      </div>
+    </template>
+  </div>
+</template>
+
+<style scoped>
+.auth-demo { margin: 1.25rem 0; font-size: 0.92rem; }
+.status { padding: 0.75rem 1rem; border-radius: 6px; background: var(--vp-c-bg-soft); color: var(--vp-c-text-2); }
+.status.error { background: var(--vp-c-warning-soft); color: var(--vp-c-warning-1); border: 1px solid var(--vp-c-warning-2); }
+
+.controls {
+  display: flex; flex-wrap: wrap; gap: 1rem;
+  padding: 1rem; background: var(--vp-c-bg-soft); border-radius: 8px;
+  margin-bottom: 1rem;
+}
+.controls label {
+  display: flex; flex-direction: column; gap: 0.3rem;
+  flex: 1; min-width: 220px;
+}
+.controls label > span { font-size: 0.85rem; color: var(--vp-c-text-2); }
+.controls label > strong { color: var(--vp-c-brand-1); font-family: var(--vp-font-family-mono); }
+
+.grid { display: grid; grid-template-columns: 1fr; gap: 1rem; }
+@media (min-width: 900px) { .grid { grid-template-columns: 1fr 1fr; } }
+.card { border: 1px solid var(--vp-c-border); border-radius: 8px; padding: 1rem; background: var(--vp-c-bg); }
+.card h4 { margin: 0 0 0.75rem 0; font-size: 1rem; }
+
+table { width: 100%; border-collapse: collapse; font-size: 0.85rem; }
+.kv th, .kv td, .rows th, .rows td {
+  padding: 0.3rem 0.5rem; text-align: left;
+  border-bottom: 1px solid var(--vp-c-divider); vertical-align: top;
+}
+.kv th { color: var(--vp-c-text-2); width: 50%; }
+.rows thead th { font-size: 0.78rem; color: var(--vp-c-text-2); border-bottom: 2px solid var(--vp-c-divider); }
+.rows td.pos { color: #2da44e; }
+.rows td.neg { color: #d1242f; }
+.hint { margin: 0.6rem 0 0 0; font-size: 0.8rem; color: var(--vp-c-text-2); }
+code { font-family: var(--vp-font-family-mono); font-size: 0.85rem; }
+
+.shape-card { grid-column: 1 / -1; }
+.edge-card  { grid-column: 1 / -1; }
+
+.shape-controls {
+  display: flex; flex-wrap: wrap; gap: 1rem 1.5rem; align-items: center;
+  margin-bottom: 0.75rem;
+}
+.shape-controls label {
+  display: flex; align-items: center; gap: 0.5rem;
+  font-size: 0.85rem; color: var(--vp-c-text-2);
+}
+.shape-controls label.inline { gap: 0.35rem; cursor: pointer; }
+.shape-controls input[type='range'] { width: 180px; accent-color: var(--vp-c-brand-1); }
+.shape-controls strong { color: var(--vp-c-brand-1); font-family: var(--vp-font-family-mono); min-width: 3.5em; text-align: right; }
+
+.shape-svg {
+  display: block; width: 100%; max-width: 480px; margin: 0 auto;
+  background: var(--vp-c-bg-soft); border: 1px solid var(--vp-c-divider); border-radius: 4px;
+}
+.ring-geo  { fill: rgba(51, 136, 255, 0.10); stroke: #3388ff; stroke-width: 1.5; }
+.ring-auth { fill: none;                       stroke: #ec7014; stroke-width: 1.5; stroke-dasharray: 4 3; }
+.vert-geo  { fill: #3388ff; }
+.vert-auth { fill: #ec7014; }
+.legend {
+  display: inline-flex; align-items: center; gap: 0.35rem; margin-right: 0.85rem;
+  font-weight: 600;
+}
+.legend::before { content: ''; display: inline-block; width: 14px; height: 2px; }
+.ring-geo-legend  { color: #3388ff; }
+.ring-geo-legend::before  { background: #3388ff; }
+.ring-auth-legend { color: #ec7014; }
+.ring-auth-legend::before { background: #ec7014; }
+</style>
diff --git a/docs/.vitepress/theme/components/DggsGlobe.vue b/docs/.vitepress/theme/components/DggsGlobe.vue
index 3d04a23..0962d5e 100644
--- a/docs/.vitepress/theme/components/DggsGlobe.vue
+++ b/docs/.vitepress/theme/components/DggsGlobe.vue
@@ -1,6 +1,6 @@
 <script setup>
 import { ref, reactive, computed, onMounted, onUnmounted, watch } from 'vue'
-import { ylOrBrRgba, processFcForGlobe } from '../utils/globeUtils.js'
+import { ylOrBrRgba } from '../utils/globeUtils.js'
 import { loadWebdggrid } from '../utils/loadWebdggrid.js'
 
 const props = defineProps({
@@ -21,11 +21,12 @@ const props = defineProps({
   initialPoleLng: { type: Number, default: 0 },
   initialPoleLat: { type: Number, default: 0 },
   initialCenter: { type: Array, default: () => [0, 20] },
+  /** Equivalent MapLibre globe zoom level — mapped to a Cesium camera altitude. */
   initialZoom: { type: Number, default: 1.8 },
   /** Cell fill color [r,g,b,a] */
-  fillColor: { type: Array, default: () => [51, 136, 255, 71] },
+  fillColor: { type: Array, default: () => [56, 132, 255, 110] },
   /** Cell line color [r,g,b,a] */
-  lineColor: { type: Array, default: () => [0, 85, 204, 220] },
+  lineColor: { type: Array, default: () => [10, 70, 200, 245] },
   /** Allow map pan/zoom interaction */
   interactive: { type: Boolean, default: true },
 })
@@ -75,14 +76,21 @@ const availableIndexTypes = computed(() => {
   return types
 })
 
-// --- non-reactive map state (reactivity on MapLibre objects causes issues) ---
-let map           = null
-let deckOverlay   = null
-let webdggrid     = null
-let poleMarker    = null
-let lastFineFc    = null
-let lastBaseFc    = null
-let multiResTimer = null
+// --- non-reactive Cesium state ---
+let viewer            = null
+let webdggrid         = null
+let gridDataSource    = null
+let baseDataSource    = null
+let parentDataSource  = null
+let childrenDataSource = null
+let selectedDataSource = null
+let poleEntity        = null
+let pickHandler       = null
+let cameraMoveEndCb   = null
+let lastFineFc        = null
+let lastBaseFc        = null
+let multiResTimer     = null
+let themeObserver     = null
 
 // ---------------------------------------------------------------------------
 // CDN helpers
@@ -108,61 +116,121 @@ function loadLink(href) {
 }
 
 // ---------------------------------------------------------------------------
-// deck.gl layer helpers
+// Coordinate / camera helpers
 // ---------------------------------------------------------------------------
 
-function makeCellLayer(id, fc, colored, isBase) {
-  if (!fc) return null
-  const { GeoJsonLayer } = window.deck
-  return new GeoJsonLayer({
-    id,
-    data: fc,
-    filled: true,
-    stroked: true,
-    wrapLongitude: true,
-    getFillColor: f => {
-      if (isBase) return [0, 0, 0, 0]
-      if (colored) return ylOrBrRgba(f.properties.colorValue ?? 0, 179)
-      return props.fillColor
-    },
-    getLineColor: isBase ? [245, 158, 11, 220] : props.lineColor,
-    getLineWidth: isBase ? 2 : 1,
-    lineWidthUnits: 'pixels',
-    pickable: !isBase && props.showControls,
-    onHover: isBase || !props.showControls ? undefined : (info) => {
-      if (!tooltipEl.value) return
-      if (info.object) {
-        tooltipEl.value.style.display = 'block'
-        tooltipEl.value.style.left = `${info.x + 12}px`
-        tooltipEl.value.style.top  = `${info.y + 12}px`
-        tooltipEl.value.innerHTML  = `<b>Cell ID:</b> ${info.object.properties.id}`
-        map.getCanvas().style.cursor = 'pointer'
-      } else {
-        tooltipEl.value.style.display = 'none'
-        map.getCanvas().style.cursor = ''
-      }
-    },
-    onClick: isBase || !props.showControls ? undefined : (info) => {
-      if (info.object) {
-        const cellId = info.object.properties?.id ?? info.object.id
-        if (cellId != null) {
-          const resolution = ctrlMultiRes.value
-            ? zoomToResolution(map.getZoom(), ctrlResolution.value)
-            : ctrlResolution.value
-          selectCell(cellId, resolution)
-        }
-      }
-    },
-    updateTriggers: { getFillColor: [colored] },
+// True pass-through. Both the naive rewrap and the heavier
+// processFcForGlobe (centroid recenter + pole-vertex injection) end up
+// breaking polar cells in Cesium more than they help — keep the FC
+// untouched and let Cesium's GEODESIC arcType + the raw vertex order from
+// DGGRID do the work.
+function prepareFc(fc) {
+  return fc
+}
+
+function rgbaArrayToCesium([r, g, b, a]) {
+  return Cesium.Color.fromBytes(r, g, b, a ?? 255)
+}
+
+// Pull the current theme background from the live VitePress CSS variable.
+// Falls back to the standard VitePress dark/light bg when the variable hasn't
+// been computed yet (very early in mount).
+function readThemeBg() {
+  const isDark = document.documentElement.classList.contains('dark')
+  const cssBg = getComputedStyle(document.documentElement)
+    .getPropertyValue('--vp-c-bg').trim()
+  return cssBg || (isDark ? '#1b1b1f' : '#ffffff')
+}
+
+// Sync the Cesium scene chrome (background canvas, globe base color) with
+// the current VitePress theme. We always hide sky/atmosphere/sun/moon so
+// the canvas behind the globe is just the themed flat color — that's what
+// makes the globe look like a first-class part of the page rather than
+// a window into Cesium space.
+function applyTheme(v, hasBasemap) {
+  if (!v) return
+  const themed = Cesium.Color.fromCssColorString(readThemeBg())
+  v.scene.backgroundColor = themed
+  v.scene.globe.baseColor = themed
+  v.scene.skyAtmosphere.show = false
+  if (v.scene.skyBox) v.scene.skyBox.show = false
+  if (v.scene.sun)    v.scene.sun.show    = false
+  if (v.scene.moon)   v.scene.moon.show   = false
+  v.scene.requestRender()
+}
+
+// Map MapLibre-style globe zoom levels to a sensible Cesium camera altitude
+// so the existing `initialZoom` prop and the multi-res zoom-offset slider keep
+// working without changing their meaning.
+function altitudeFromZoom(zoom) {
+  return 40_000_000 * Math.pow(2, -zoom)
+}
+
+function zoomFromAltitude() {
+  if (!viewer) return 0
+  const h = viewer.camera.positionCartographic.height
+  return Math.log2(40_000_000 / Math.max(h, 1))
+}
+
+// ---------------------------------------------------------------------------
+// Cesium layer helpers
+// ---------------------------------------------------------------------------
+
+async function buildCellDataSource(fc, { fill, stroke, isBase, colored }) {
+  const ds = await Cesium.GeoJsonDataSource.load(fc, {
+    fill: rgbaArrayToCesium(fill),
+    stroke: rgbaArrayToCesium(stroke),
+    strokeWidth: isBase ? 3 : 1.5,
+    clampToGround: false,
   })
+
+  const baseFill = rgbaArrayToCesium(fill)
+
+  ds.entities.values.forEach((e) => {
+    if (!e.polygon) return
+    e.polygon.arcType = Cesium.ArcType.GEODESIC
+    e.polygon.height  = 0
+    e.polygon.outline = true
+    e.polygon.outlineWidth = isBase ? 3 : 1.5
+    if (isBase) {
+      e.polygon.fill = false
+    } else if (colored) {
+      const t = Number(e.properties?.colorValue?.getValue?.() ?? 0)
+      // Bumped alpha 179 → 220 for stronger fill in YlOrBr mode.
+      e.polygon.material = rgbaArrayToCesium(ylOrBrRgba(t, 220))
+    } else {
+      e.polygon.material = baseFill
+    }
+  })
+
+  return ds
 }
 
-function updateDeckLayers(fineFc, baseFc) {
+async function updateLayers(fineFc, baseFc) {
+  if (!viewer) return
   const colored = ctrlColorCells.value
-  const layers  = []
-  if (baseFc) layers.push(makeCellLayer('dggrid-base',  baseFc, false, true))
-  if (fineFc) layers.push(makeCellLayer('dggrid-cells', fineFc, colored, false))
-  deckOverlay.setProps({ layers })
+
+  if (gridDataSource) { viewer.dataSources.remove(gridDataSource, true); gridDataSource = null }
+  if (baseDataSource) { viewer.dataSources.remove(baseDataSource, true); baseDataSource = null }
+
+  if (baseFc) {
+    baseDataSource = await buildCellDataSource(baseFc, {
+      fill:    [0, 0, 0, 0],
+      stroke:  [245, 158, 11, 220],
+      isBase:  true,
+      colored: false,
+    })
+    await viewer.dataSources.add(baseDataSource)
+  }
+  if (fineFc) {
+    gridDataSource = await buildCellDataSource(fineFc, {
+      fill:    props.fillColor,
+      stroke:  props.lineColor,
+      isBase:  false,
+      colored,
+    })
+    await viewer.dataSources.add(gridDataSource)
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -175,19 +243,35 @@ function zoomToResolution(zoom, maxRes) {
 }
 
 function viewportSeqNums(resolution) {
-  const bounds  = map.getBounds()
-  const minLat  = Math.max(bounds.getSouth(), -89)
-  const maxLat  = Math.min(bounds.getNorth(),  89)
-  const minLng  = bounds.getWest()
-  const maxLng  = bounds.getEast()
+  const rect = viewer.camera.computeViewRectangle()
+  let minLng, maxLng, minLat, maxLat
+  if (rect) {
+    minLng = Cesium.Math.toDegrees(rect.west)
+    maxLng = Cesium.Math.toDegrees(rect.east)
+    minLat = Math.max(Cesium.Math.toDegrees(rect.south), -89)
+    maxLat = Math.min(Cesium.Math.toDegrees(rect.north),  89)
+    if (maxLng < minLng) maxLng += 360 // antimeridian-crossing rectangle
+  } else {
+    // Camera is looking past the globe edge (whole-world view). Sample the
+    // entire world instead of trying to enumerate every cell at this
+    // resolution — at res 15 that's billions of cells and traps the WASM
+    // module ("RuntimeError: null function").
+    minLng = -180; maxLng = 180; minLat = -89; maxLat = 89
+  }
+
   const steps   = 80
   const latStep = (maxLat - minLat) / steps
   const lngStep = (maxLng - minLng) / steps
 
   const coords = []
-  for (let i = 0; i <= steps; i++)
-    for (let j = 0; j <= steps; j++)
-      coords.push([minLng + j * lngStep, minLat + i * latStep])
+  for (let i = 0; i <= steps; i++) {
+    for (let j = 0; j <= steps; j++) {
+      let lng = minLng + j * lngStep
+      while (lng >  180) lng -= 360
+      while (lng < -180) lng += 360
+      coords.push([lng, minLat + i * latStep])
+    }
+  }
 
   const raw  = webdggrid.geoToSequenceNum(coords, resolution)
   const seen = new Set()
@@ -213,13 +297,13 @@ function generateGrid() {
   hierarchyInfo.allParents = []
   hierarchyInfo.children = []
   hierarchyInfo.neighbors = []
-  removeHierarchyMapLayers()
+  removeHierarchyLayers()
 
   const maxRes     = ctrlResolution.value
   const multiRes   = ctrlMultiRes.value
   const isMixed    = ctrlMixedAperture.value && ctrlTopology.value === 'HEXAGON'
   const resolution = multiRes
-    ? zoomToResolution(map.getZoom(), isMixed ? ctrlApertureSeq.value.length : maxRes)
+    ? zoomToResolution(zoomFromAltitude(), isMixed ? ctrlApertureSeq.value.length : maxRes)
     : isMixed ? Math.min(maxRes, ctrlApertureSeq.value.length) : maxRes
   const topology   = ctrlTopology.value
   const projection = ctrlProjection.value
@@ -236,15 +320,20 @@ function generateGrid() {
 
   webdggrid.setDggs(dggsConfig, resolution)
 
-  ctrlResolution.value = resolution
+  // In multi-res mode, ctrlResolution is the user's "Max Resolution" cap —
+  // don't write the engine's computed resolution back to it (that clobbers
+  // the cap and makes the Zoom→Res offset slider appear broken because the
+  // ceiling drops every call). In single-res mode, ctrlResolution IS the
+  // rendered resolution, so keep them in sync.
+  if (!multiRes) ctrlResolution.value = resolution
   status.value = 'Generating grid…'
   if (!multiRes) isGenerating.value = true
 
-  setTimeout(() => {
+  setTimeout(async () => {
     try {
       function buildFc(seqNums, res) {
         const total = webdggrid.nCells(res)
-        const fc    = webdggrid.sequenceNumToGridFeatureCollection(seqNums, res)
+        const fc    = webdggrid.sequenceNumToGridFeatureCollection(seqNums, res, false)
         fc.features.forEach(f => {
           if (typeof f.id === 'bigint') f.id = f.id.toString()
           const p = f.properties
@@ -256,7 +345,7 @@ function generateGrid() {
               : 0
           }
         })
-        return processFcForGlobe(fc)
+        return prepareFc(fc)
       }
 
       let seqNums
@@ -279,7 +368,7 @@ function generateGrid() {
       const fineFc = buildFc(seqNums, resolution)
       lastFineFc = fineFc
       lastBaseFc = baseFc
-      updateDeckLayers(fineFc, baseFc)
+      await updateLayers(fineFc, baseFc)
 
       const modeLabel = multiRes ? `res ${resolution} · viewport` : `res ${resolution} · globe`
       const apLabel = isMixed ? `mixed [${dggsConfig.apertureSequence}]` : topology
@@ -307,7 +396,7 @@ watch(ctrlTopology, (val) => {
 })
 
 watch(ctrlColorCells, () => {
-  if (isReady.value) updateDeckLayers(lastFineFc, lastBaseFc)
+  if (isReady.value) updateLayers(lastFineFc, lastBaseFc)
 })
 
 watch(ctrlZoomOffset, () => {
@@ -315,9 +404,25 @@ watch(ctrlZoomOffset, () => {
 })
 
 watch([ctrlPoleLng, ctrlPoleLat], () => {
-  if (poleMarker) poleMarker.setLngLat([ctrlPoleLng.value, ctrlPoleLat.value])
+  if (poleEntity) {
+    poleEntity.position = Cesium.Cartesian3.fromDegrees(ctrlPoleLng.value, ctrlPoleLat.value)
+  }
 })
 
+// In multi-res mode the "Generate Grid" button is hidden, so any setting
+// that affects the grid must auto-regenerate. Debounced so dragging the
+// resolution slider doesn't fire one regeneration per integer step.
+let multiResSettingsTimer = null
+function scheduleMultiResRegen() {
+  if (!ctrlMultiRes.value || !isReady.value || !webdggrid) return
+  clearTimeout(multiResSettingsTimer)
+  multiResSettingsTimer = setTimeout(generateGrid, 150)
+}
+watch(
+  [ctrlResolution, ctrlTopology, ctrlProjection, ctrlAperture, ctrlAzimuth, ctrlPoleLng, ctrlPoleLat, ctrlMixedAperture, ctrlApertureSeq],
+  scheduleMultiResRegen,
+)
+
 watch(ctrlMultiRes, (on) => {
   ctrlMaxResLabel.value = on ? 'Max Resolution' : 'Resolution'
   if (on) {
@@ -325,9 +430,15 @@ watch(ctrlMultiRes, (on) => {
   } else {
     if (ctrlResolution.value > 5) ctrlResolution.value = 5
   }
-  if (map) {
-    map.off('moveend', onMoveEnd)
-    if (on) map.on('moveend', onMoveEnd)
+  if (viewer) {
+    if (cameraMoveEndCb) {
+      viewer.camera.moveEnd.removeEventListener(cameraMoveEndCb)
+      cameraMoveEndCb = null
+    }
+    if (on) {
+      cameraMoveEndCb = onMoveEnd
+      viewer.camera.moveEnd.addEventListener(cameraMoveEndCb)
+    }
   }
   if (on && isReady.value && webdggrid) generateGrid()
 })
@@ -367,7 +478,20 @@ function selectCell(cellId, resolution) {
   selectedCellId.value = seqnum
   selectedCellRes.value = resolution
 
-  // Get hierarchical relationships
+  try {
+    const fc = sanitizeFc(webdggrid.sequenceNumToGridFeatureCollection([seqnum], resolution, false))
+    const geom = fc.features[0]?.geometry
+    console.log('[DggsGlobe] selected cell', {
+      seqnum: seqnum.toString(),
+      resolution,
+      indexLabel: getCellIndexLabel(seqnum, resolution),
+      geometry: geom,
+      geojson: JSON.stringify(geom),
+    })
+  } catch (e) {
+    console.warn('[DggsGlobe] could not log selected geometry:', e)
+  }
+
   try {
     hierarchyInfo.neighbors = webdggrid.sequenceNumNeighbors([seqnum], resolution)[0]
   } catch { hierarchyInfo.neighbors = [] }
@@ -394,20 +518,15 @@ function clearSelection() {
   hierarchyInfo.allParents = []
   hierarchyInfo.children = []
   hierarchyInfo.neighbors = []
-  removeHierarchyMapLayers()
+  removeHierarchyLayers()
 }
 
-// MapLibre source/layer IDs for hierarchy
-const HIER_SOURCES = ['hier-parent', 'hier-children', 'hier-selected', 'hier-labels-selected', 'hier-labels-parent', 'hier-labels-children']
-
-function removeHierarchyMapLayers() {
-  if (!map) return
-  for (const id of HIER_SOURCES) {
-    for (const suffix of ['-fill', '-line', '-text']) {
-      if (map.getLayer(id + suffix)) map.removeLayer(id + suffix)
-    }
-    if (map.getSource(id)) map.removeSource(id)
+function removeHierarchyLayers() {
+  if (!viewer) return
+  for (const ds of [parentDataSource, childrenDataSource, selectedDataSource]) {
+    if (ds) viewer.dataSources.remove(ds, true)
   }
+  parentDataSource = childrenDataSource = selectedDataSource = null
 }
 
 function sanitizeFc(fc) {
@@ -422,137 +541,125 @@ function sanitizeFc(fc) {
   return fc
 }
 
-function updateHierarchyLayers(seqnum, resolution) {
-  if (!map) return
-
-  // Restore base deck.gl grid layers
-  if (deckOverlay && lastFineFc) {
-    updateDeckLayers(lastFineFc, lastBaseFc)
-  }
+async function updateHierarchyLayers(seqnum, resolution) {
+  if (!viewer) return
 
-  // Remove previous MapLibre hierarchy layers
-  removeHierarchyMapLayers()
+  removeHierarchyLayers()
 
   // --- Parent polygons (all touching parents) ---
   if (hierarchyInfo.allParents.length > 0 && resolution > 0) {
     try {
-      const parentFc = sanitizeFc(webdggrid.sequenceNumToGridFeatureCollection(hierarchyInfo.allParents, resolution - 1))
-      // Tag primary vs secondary parents
-      parentFc.features.forEach((f, i) => {
-        f.properties._primary = i === 0
-      })
-      map.addSource('hier-parent', { type: 'geojson', data: parentFc })
-      map.addLayer({ id: 'hier-parent-fill', type: 'fill', source: 'hier-parent', paint: {
-        'fill-color': ['case', ['get', '_primary'], '#22cc55', '#66dd88'],
-        'fill-opacity': ['case', ['get', '_primary'], 0.35, 0.25],
-      } })
-      map.addLayer({ id: 'hier-parent-line', type: 'line', source: 'hier-parent', paint: {
-        'line-color': ['case', ['get', '_primary'], '#11aa33', '#44bb66'],
-        'line-width': ['case', ['get', '_primary'], 3.5, 2.5],
-        'line-dasharray': [3, 2],
-      } })
-
-      // Parent labels
-      const parentLabelFeatures = hierarchyInfo.allParents.map((p, i) => {
-        const geo = webdggrid.sequenceNumToGeo([p], resolution - 1)[0]
-        return {
-          type: 'Feature',
-          geometry: { type: 'Point', coordinates: [geo[0], geo[1]] },
-          properties: {
-            label: getCellIndexLabel(p, resolution - 1),
-            primary: i === 0,
-          },
-        }
+      const parentFc = prepareFc(sanitizeFc(
+        webdggrid.sequenceNumToGridFeatureCollection(hierarchyInfo.allParents, resolution - 1, false)
+      ))
+      parentFc.features.forEach((f, i) => { f.properties._primary = i === 0 })
+
+      parentDataSource = await Cesium.GeoJsonDataSource.load(parentFc, { clampToGround: false })
+      parentDataSource.entities.values.forEach((e) => {
+        if (!e.polygon) return
+        const isPrimary = !!e.properties?._primary?.getValue?.()
+        e.polygon.arcType  = Cesium.ArcType.GEODESIC
+        e.polygon.height   = 0
+        e.polygon.material = Cesium.Color.fromCssColorString(isPrimary ? 'rgba(34,204,85,0.35)' : 'rgba(102,221,136,0.25)')
+        e.polygon.outline  = true
+        e.polygon.outlineColor = Cesium.Color.fromCssColorString(isPrimary ? '#11aa33' : '#44bb66')
+        e.polygon.outlineWidth = isPrimary ? 3.5 : 2.5
       })
-      map.addSource('hier-labels-parent', { type: 'geojson', data: { type: 'FeatureCollection', features: parentLabelFeatures } })
-      map.addLayer({
-        id: 'hier-labels-parent-text',
-        type: 'symbol',
-        source: 'hier-labels-parent',
-        layout: {
-          'text-field': ['get', 'label'],
-          'text-font': ['Open Sans Bold', 'Arial Unicode MS Bold'],
-          'text-size': ['case', ['get', 'primary'], 13, 11],
-          'text-offset': [0, -2],
-          'text-allow-overlap': false,
-        },
-        paint: {
-          'text-color': ['case', ['get', 'primary'], '#1a8a1a', '#5a9a5a'],
-          'text-halo-color': 'rgba(255,255,255,0.95)',
-          'text-halo-width': 2,
-        },
+
+      // Parent labels at cell centers
+      hierarchyInfo.allParents.forEach((p, i) => {
+        try {
+          const geo = webdggrid.sequenceNumToGeo([p], resolution - 1)[0]
+          parentDataSource.entities.add({
+            position: Cesium.Cartesian3.fromDegrees(geo[0], geo[1]),
+            label: {
+              text: getCellIndexLabel(p, resolution - 1),
+              font: i === 0 ? 'bold 13px sans-serif' : 'bold 11px sans-serif',
+              fillColor: Cesium.Color.fromCssColorString(i === 0 ? '#1a8a1a' : '#5a9a5a'),
+              outlineColor: Cesium.Color.fromCssColorString('rgba(255,255,255,0.95)'),
+              outlineWidth: 2,
+              style: Cesium.LabelStyle.FILL_AND_OUTLINE,
+              pixelOffset: new Cesium.Cartesian2(0, -2),
+              disableDepthTestDistance: Number.POSITIVE_INFINITY,
+            },
+          })
+        } catch { /* skip */ }
       })
+
+      await viewer.dataSources.add(parentDataSource)
     } catch (err) { console.error('Parent geometry error:', err) }
   }
 
   // --- Children polygons ---
   if (hierarchyInfo.children.length > 0) {
     try {
-      const childFc = sanitizeFc(webdggrid.sequenceNumToGridFeatureCollection(hierarchyInfo.children, resolution + 1))
-      map.addSource('hier-children', { type: 'geojson', data: childFc })
-      map.addLayer({ id: 'hier-children-fill', type: 'fill', source: 'hier-children', paint: { 'fill-color': '#ffcc00', 'fill-opacity': 0.3 } })
-      map.addLayer({ id: 'hier-children-line', type: 'line', source: 'hier-children', paint: { 'line-color': '#cc9900', 'line-width': 2 } })
-
-      // Children labels — collision detection auto-hides overlapping ones
-      const childLabelFeatures = []
-      for (const child of hierarchyInfo.children) {
+      const childFc = prepareFc(sanitizeFc(
+        webdggrid.sequenceNumToGridFeatureCollection(hierarchyInfo.children, resolution + 1, false)
+      ))
+      childrenDataSource = await Cesium.GeoJsonDataSource.load(childFc, { clampToGround: false })
+      childrenDataSource.entities.values.forEach((e) => {
+        if (!e.polygon) return
+        e.polygon.arcType  = Cesium.ArcType.GEODESIC
+        e.polygon.height   = 0
+        e.polygon.material = Cesium.Color.fromCssColorString('rgba(255,204,0,0.3)')
+        e.polygon.outline  = true
+        e.polygon.outlineColor = Cesium.Color.fromCssColorString('#cc9900')
+        e.polygon.outlineWidth = 2
+      })
+
+      hierarchyInfo.children.forEach((c) => {
         try {
-          const geo = webdggrid.sequenceNumToGeo([child], resolution + 1)[0]
-          childLabelFeatures.push({
-            type: 'Feature',
-            geometry: { type: 'Point', coordinates: [geo[0], geo[1]] },
-            properties: { label: getCellIndexLabel(child, resolution + 1) },
+          const geo = webdggrid.sequenceNumToGeo([c], resolution + 1)[0]
+          childrenDataSource.entities.add({
+            position: Cesium.Cartesian3.fromDegrees(geo[0], geo[1]),
+            label: {
+              text: getCellIndexLabel(c, resolution + 1),
+              font: 'bold 10px sans-serif',
+              fillColor: Cesium.Color.fromCssColorString('#886600'),
+              outlineColor: Cesium.Color.fromCssColorString('rgba(255,255,255,0.95)'),
+              outlineWidth: 1.5,
+              style: Cesium.LabelStyle.FILL_AND_OUTLINE,
+              disableDepthTestDistance: Number.POSITIVE_INFINITY,
+            },
           })
         } catch { /* skip */ }
-      }
-      if (childLabelFeatures.length > 0) {
-        const childLabelFc = { type: 'FeatureCollection', features: childLabelFeatures }
-        map.addSource('hier-labels-children', { type: 'geojson', data: childLabelFc })
-        map.addLayer({
-          id: 'hier-labels-children-text',
-          type: 'symbol',
-          source: 'hier-labels-children',
-          layout: {
-            'text-field': ['get', 'label'],
-            'text-font': ['Open Sans Bold', 'Arial Unicode MS Bold'],
-            'text-size': 10,
-            'text-allow-overlap': false,
-            'text-optional': true,
-          },
-          paint: { 'text-color': '#886600', 'text-halo-color': 'rgba(255,255,255,0.95)', 'text-halo-width': 1.5 },
-        })
-      }
+      })
+
+      await viewer.dataSources.add(childrenDataSource)
     } catch { /* skip */ }
   }
 
   // --- Selected cell highlight (always on top) ---
   try {
-    const centerFc = sanitizeFc(webdggrid.sequenceNumToGridFeatureCollection([seqnum], resolution))
-    map.addSource('hier-selected', { type: 'geojson', data: centerFc })
-    map.addLayer({ id: 'hier-selected-fill', type: 'fill', source: 'hier-selected', paint: { 'fill-color': '#ff3333', 'fill-opacity': 0.25 } })
-    map.addLayer({ id: 'hier-selected-line', type: 'line', source: 'hier-selected', paint: { 'line-color': '#ff3333', 'line-width': 4 } })
+    const centerFc = prepareFc(sanitizeFc(
+      webdggrid.sequenceNumToGridFeatureCollection([seqnum], resolution, false)
+    ))
+    selectedDataSource = await Cesium.GeoJsonDataSource.load(centerFc, { clampToGround: false })
+    selectedDataSource.entities.values.forEach((e) => {
+      if (!e.polygon) return
+      e.polygon.arcType  = Cesium.ArcType.GEODESIC
+      e.polygon.height   = 0
+      e.polygon.material = Cesium.Color.fromCssColorString('rgba(255,51,51,0.25)')
+      e.polygon.outline  = true
+      e.polygon.outlineColor = Cesium.Color.fromCssColorString('#ff3333')
+      e.polygon.outlineWidth = 4
+    })
 
-    // Selected label — always visible, ignores collisions
     const geo = webdggrid.sequenceNumToGeo([seqnum], resolution)[0]
-    const selLabelFc = { type: 'FeatureCollection', features: [{
-      type: 'Feature',
-      geometry: { type: 'Point', coordinates: [geo[0], geo[1]] },
-      properties: { label: getCellIndexLabel(seqnum, resolution) },
-    }] }
-    map.addSource('hier-labels-selected', { type: 'geojson', data: selLabelFc })
-    map.addLayer({
-      id: 'hier-labels-selected-text',
-      type: 'symbol',
-      source: 'hier-labels-selected',
-      layout: {
-        'text-field': ['get', 'label'],
-        'text-font': ['Open Sans Bold', 'Arial Unicode MS Bold'],
-        'text-size': 14,
-        'text-allow-overlap': true,
-        'text-ignore-placement': true,
+    selectedDataSource.entities.add({
+      position: Cesium.Cartesian3.fromDegrees(geo[0], geo[1]),
+      label: {
+        text: getCellIndexLabel(seqnum, resolution),
+        font: 'bold 14px sans-serif',
+        fillColor: Cesium.Color.fromCssColorString('#ff3333'),
+        outlineColor: Cesium.Color.fromCssColorString('rgba(255,255,255,0.95)'),
+        outlineWidth: 2.5,
+        style: Cesium.LabelStyle.FILL_AND_OUTLINE,
+        disableDepthTestDistance: Number.POSITIVE_INFINITY,
       },
-      paint: { 'text-color': '#ff3333', 'text-halo-color': 'rgba(255,255,255,0.95)', 'text-halo-width': 2.5 },
     })
+
+    await viewer.dataSources.add(selectedDataSource)
   } catch { /* skip */ }
 }
 
@@ -568,89 +675,139 @@ onMounted(async () => {
     BigInt.prototype.toJSON = function () { return this.toString() }
   }
 
-  loadLink('https://unpkg.com/maplibre-gl@5.21.1/dist/maplibre-gl.css')
+  // CESIUM_BASE_URL must be set BEFORE Cesium.js is loaded
+  window.CESIUM_BASE_URL = 'https://cdn.jsdelivr.net/npm/cesium@1.122/Build/Cesium/'
+  loadLink('https://cdn.jsdelivr.net/npm/cesium@1.122/Build/Cesium/Widgets/widgets.css')
 
   try {
-    await Promise.all([
-      loadScript('https://unpkg.com/maplibre-gl@5.21.1/dist/maplibre-gl.js'),
-      loadScript('https://unpkg.com/deck.gl@9/dist.min.js'),
-    ])
-
+    await loadScript('https://cdn.jsdelivr.net/npm/cesium@1.122/Build/Cesium/Cesium.js')
     const Webdggrid = await loadWebdggrid()
 
-    const isDark = document.documentElement.classList.contains('dark')
-
-    // Read the page background colour so the sky matches the theme
-    const bgColor = getComputedStyle(document.documentElement)
-      .getPropertyValue('--vp-c-bg').trim() || (isDark ? '#1b1b1f' : '#ffffff')
-
-    const noBasemapStyle = {
-      version: 8,
-      projection: { type: 'globe' },
-      sources: {},
-      layers: [],
-      sky: {
-        'sky-color':         isDark ? '#0b1d3a' : bgColor,
-        'sky-horizon-blend':  0.5,
-        'horizon-color':     isDark ? '#1a3a6e' : bgColor,
-        'horizon-fog-blend':  0.3,
-        'fog-color':         isDark ? '#071224' : bgColor,
-        'fog-ground-blend':   0.5,
-        'atmosphere-blend': ['interpolate', ['linear'], ['zoom'], 0, 1, 7, 0],
-      },
-    }
+    viewer = new Cesium.Viewer(mapContainer.value, {
+      baseLayer: false,
+      baseLayerPicker: false,
+      geocoder: false,
+      homeButton: false,
+      sceneModePicker: false,
+      navigationHelpButton: false,
+      timeline: false,
+      animation: false,
+      fullscreenButton: false,
+      infoBox: false,
+      selectionIndicator: false,
+      terrainProvider: new Cesium.EllipsoidTerrainProvider(),
+    })
 
-    const basemapStyle = {
-      version: 8,
-      projection: { type: 'globe' },
-      sources: {
-        osm: {
-          type: 'raster',
-          tiles: ['https://tile.openstreetmap.org/{z}/{x}/{y}.png'],
-          tileSize: 256,
-          attribution: '© <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors',
-        },
-      },
-      layers: [{ id: 'osm', type: 'raster', source: 'osm' }],
-      sky: isDark ? {
-        'atmosphere-blend': ['interpolate', ['linear'], ['zoom'], 0, 1, 5, 1, 7, 0],
-      } : {
-        'sky-color':        bgColor,
-        'horizon-color':    bgColor,
-        'fog-color':        bgColor,
-        'atmosphere-blend': 0,
-      },
+    if (props.showBasemap) {
+      viewer.imageryLayers.addImageryProvider(new Cesium.OpenStreetMapImageryProvider({
+        url: 'https://tile.openstreetmap.org/',
+        credit: '© OpenStreetMap contributors',
+      }))
+    }
+    viewer.scene.globe.enableLighting = false
+
+    // Sharpen the rendering pipeline: Cesium's defaults run an HDR tonemap
+    // and an FXAA pass that together wash colors out and soften every cell
+    // outline. We want crisp, saturated cell colors over the basemap.
+    viewer.scene.highDynamicRange = false
+    if (viewer.scene.postProcessStages.fxaa) {
+      viewer.scene.postProcessStages.fxaa.enabled = false
+    }
+    // 4× MSAA gives clean polygon edges without the FXAA blur.
+    if ('msaaSamples' in viewer.scene) viewer.scene.msaaSamples = 4
+    // Atmosphere haze tints the basemap blue at low altitudes; off.
+    viewer.scene.globe.showGroundAtmosphere = false
+    viewer.scene.fog.enabled = false
+
+    // Re-paint scene chrome (background, globe base, sky) whenever VitePress
+    // toggles the `.dark` class on <html>. Stays in sync with the user's
+    // OS / docs theme switcher without remounting the Cesium viewer.
+    applyTheme(viewer, props.showBasemap)
+    themeObserver = new MutationObserver(() => applyTheme(viewer, props.showBasemap))
+    themeObserver.observe(document.documentElement, { attributes: true, attributeFilter: ['class'] })
+
+    if (!props.interactive) {
+      const c = viewer.scene.screenSpaceCameraController
+      c.enableRotate = c.enableTranslate = c.enableZoom = c.enableTilt = c.enableLook = false
+    } else {
+      // Default Cesium controls, just clamp the zoom-out so the user can't
+      // back the camera out into space (where the sun/sky would otherwise
+      // be visible if the theme paint hadn't already hidden them).
+      // ~7× Earth radius — comfortably outside any plausible "view the
+      // whole grid at once" use case but well short of solar-system scale.
+      viewer.scene.screenSpaceCameraController.maximumZoomDistance = 50_000_000
     }
 
-    const { Map, Marker } = window.maplibregl
-
-    map = new Map({
-      container: mapContainer.value,
-      style: props.showBasemap ? basemapStyle : noBasemapStyle,
-      center: props.initialCenter,
-      zoom: props.initialZoom,
-      interactive: props.interactive,
+    viewer.camera.setView({
+      destination: Cesium.Cartesian3.fromDegrees(
+        props.initialCenter[0],
+        props.initialCenter[1],
+        altitudeFromZoom(props.initialZoom),
+      ),
     })
 
     if (props.showControls) {
-      const poleEl = document.createElement('div')
-      poleEl.className = 'dggs-pole-marker'
-      poleEl.innerHTML = '<div class="dggs-pole-dot"></div><div class="dggs-pole-label">Pole</div>'
-      poleMarker = new Marker({ element: poleEl, anchor: 'left' })
-        .setLngLat([ctrlPoleLng.value, ctrlPoleLat.value])
-        .addTo(map)
+      poleEntity = viewer.entities.add({
+        position: Cesium.Cartesian3.fromDegrees(ctrlPoleLng.value, ctrlPoleLat.value),
+        point: {
+          color: Cesium.Color.fromCssColorString('#e53935'),
+          pixelSize: 11,
+          outlineColor: Cesium.Color.WHITE,
+          outlineWidth: 2,
+          disableDepthTestDistance: Number.POSITIVE_INFINITY,
+        },
+        label: {
+          text: 'Pole',
+          font: 'bold 11px sans-serif',
+          fillColor: Cesium.Color.fromCssColorString('#333'),
+          showBackground: true,
+          backgroundColor: Cesium.Color.fromCssColorString('rgba(255,255,255,0.92)'),
+          backgroundPadding: new Cesium.Cartesian2(6, 4),
+          pixelOffset: new Cesium.Cartesian2(14, 0),
+          horizontalOrigin: Cesium.HorizontalOrigin.LEFT,
+          style: Cesium.LabelStyle.FILL,
+          disableDepthTestDistance: Number.POSITIVE_INFINITY,
+        },
+      })
     }
 
-    deckOverlay = new window.deck.MapboxOverlay({ layers: [] })
+    if (props.showControls) {
+      pickHandler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas)
+
+      pickHandler.setInputAction((event) => {
+        const picked = viewer.scene.pick(event.endPosition)
+        const isCell = picked && picked.id && picked.id.entityCollection?.owner === gridDataSource && picked.id.polygon
+        if (isCell) {
+          if (tooltipEl.value) {
+            tooltipEl.value.style.display = 'block'
+            tooltipEl.value.style.left = `${event.endPosition.x + 12}px`
+            tooltipEl.value.style.top  = `${event.endPosition.y + 12}px`
+            const id = picked.id.properties?.id?.getValue?.() ?? picked.id.id
+            tooltipEl.value.innerHTML = `<b>Cell ID:</b> ${id}`
+          }
+          viewer.scene.canvas.style.cursor = 'pointer'
+        } else {
+          if (tooltipEl.value) tooltipEl.value.style.display = 'none'
+          viewer.scene.canvas.style.cursor = ''
+        }
+      }, Cesium.ScreenSpaceEventType.MOUSE_MOVE)
+
+      pickHandler.setInputAction((event) => {
+        const picked = viewer.scene.pick(event.position)
+        const isCell = picked && picked.id && picked.id.entityCollection?.owner === gridDataSource && picked.id.polygon
+        if (isCell) {
+          const cellId = picked.id.properties?.id?.getValue?.() ?? picked.id.id
+          if (cellId != null) {
+            const resolution = ctrlMultiRes.value
+              ? zoomToResolution(zoomFromAltitude(), ctrlResolution.value)
+              : ctrlResolution.value
+            selectCell(cellId, resolution)
+          }
+        }
+      }, Cesium.ScreenSpaceEventType.LEFT_CLICK)
+    }
 
-    const [,] = await Promise.all([
-      Webdggrid.load().then(w => { webdggrid = w }),
-      new Promise(resolve => map.on('load', () => {
-        try { map.setProjection({ type: 'globe' }) } catch (_) {}
-        map.addControl(deckOverlay)
-        resolve()
-      })),
-    ])
+    webdggrid = await Webdggrid.load()
 
     isReady.value = true
     status.value = props.showControls && !props.autoGenerate
@@ -658,7 +815,6 @@ onMounted(async () => {
       : ''
 
     if (props.showControls) {
-      // Re-enable max-res limit after initial load
       ctrlResolution.value = props.initialResolution
     }
 
@@ -673,11 +829,18 @@ onMounted(async () => {
 
 onUnmounted(() => {
   clearTimeout(multiResTimer)
-  if (map) { map.remove(); map = null }
+  if (themeObserver) { themeObserver.disconnect(); themeObserver = null }
+  if (viewer && cameraMoveEndCb) {
+    viewer.camera.moveEnd.removeEventListener(cameraMoveEndCb)
+    cameraMoveEndCb = null
+  }
+  if (pickHandler) { pickHandler.destroy(); pickHandler = null }
+  if (viewer) { viewer.destroy(); viewer = null }
 })
 
-// Allow parent components (e.g. DggsHeroBackground) to access the map instance.
-defineExpose({ getMap: () => map })
+// Allow parent components (e.g. DggsHeroBackground) to access the Cesium
+// viewer via the same getMap() handle the previous MapLibre version exposed.
+defineExpose({ getMap: () => viewer })
 </script>
 
 <template>
@@ -1183,33 +1346,4 @@ defineExpose({ getMap: () => map })
   font-style: italic;
   margin-top: 2px;
 }
-
-/* ---- pole marker (injected into MapLibre DOM) ---- */
-:global(.dggs-pole-marker) {
-  display: flex;
-  align-items: center;
-  gap: 6px;
-  cursor: default;
-}
-
-:global(.dggs-pole-dot) {
-  width: 11px;
-  height: 11px;
-  background: #e53935;
-  border-radius: 50%;
-  border: 2px solid #fff;
-  box-shadow: 0 1px 4px rgba(0, 0, 0, 0.5);
-  flex-shrink: 0;
-}
-
-:global(.dggs-pole-label) {
-  background: rgba(255, 255, 255, 0.92);
-  padding: 2px 6px;
-  border-radius: 3px;
-  font-size: 11px;
-  font-weight: 600;
-  color: #333;
-  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.25);
-  white-space: nowrap;
-}
 </style>
diff --git a/docs/.vitepress/theme/index.ts b/docs/.vitepress/theme/index.ts
index 34865ff..27f6b8a 100644
--- a/docs/.vitepress/theme/index.ts
+++ b/docs/.vitepress/theme/index.ts
@@ -6,6 +6,7 @@ import DggsHeroBackground from './components/DggsHeroBackground.vue'
 import DggsAddressTypesDemo from './components/DggsAddressTypesDemo.vue'
 import DggsD3HierarchyDemo from './components/DggsD3HierarchyDemo.vue'
 import Igeo7Demo from './components/Igeo7Demo.vue'
+import AuthalicDemo from './components/AuthalicDemo.vue'
 
 export default {
   extends: DefaultTheme,
@@ -17,6 +18,7 @@ export default {
     app.component('DggsAddressTypesDemo', DggsAddressTypesDemo)
     app.component('DggsD3HierarchyDemo', DggsD3HierarchyDemo)
     app.component('Igeo7Demo', Igeo7Demo)
+    app.component('AuthalicDemo', AuthalicDemo)
   },
 
   Layout() {
diff --git a/docs/api/classes/Webdggrid.md b/docs/api/classes/Webdggrid.md
index fa579a2..8a23e16 100644
--- a/docs/api/classes/Webdggrid.md
+++ b/docs/api/classes/Webdggrid.md
@@ -2,7 +2,7 @@
 
 # Class: Webdggrid
 
-Defined in: [webdggrid.ts:252](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L252)
+Defined in: [webdggrid.ts:262](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L262)
 
 Main entry point for the WebDggrid library.
 
@@ -45,7 +45,7 @@ the returned instance throughout your application. Call
 
 > `protected` **\_module**: `any`
 
-Defined in: [webdggrid.ts:275](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L275)
+Defined in: [webdggrid.ts:285](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L285)
 
 ***
 
@@ -53,7 +53,7 @@ Defined in: [webdggrid.ts:275](https://github.com/am2222/webDggrid/blob/6a20c6a6
 
 > **dggs**: [`IDGGSProps`](../interfaces/IDGGSProps.md) = `DEFAULT_DGGS`
 
-Defined in: [webdggrid.ts:261](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L261)
+Defined in: [webdggrid.ts:271](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L271)
 
 The active DGGS configuration used by all conversion and statistics
 methods. Change it at any time via [setDggs](#setdggs).
@@ -67,7 +67,7 @@ pole at 0° N 0° E, azimuth 0°).
 
 > **resolution**: `number` = `DEFAULT_RESOLUTION`
 
-Defined in: [webdggrid.ts:273](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L273)
+Defined in: [webdggrid.ts:283](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L283)
 
 The active grid resolution. Higher values produce finer, smaller cells.
 The valid range depends on the aperture — for aperture 4 the practical
@@ -84,7 +84,7 @@ Defaults to `1`.
 
 > `readonly` `static` **Z3\_BITS\_PER\_DIGIT**: `2n` = `2n`
 
-Defined in: [webdggrid.ts:1571](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1571)
+Defined in: [webdggrid.ts:1594](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1594)
 
 **`Internal`**
 
@@ -94,7 +94,7 @@ Defined in: [webdggrid.ts:1571](https://github.com/am2222/webDggrid/blob/6a20c6a
 
 > `readonly` `static` **Z3\_DIGIT\_MASK**: `3n` = `3n`
 
-Defined in: [webdggrid.ts:1572](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1572)
+Defined in: [webdggrid.ts:1595](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1595)
 
 **`Internal`**
 
@@ -104,7 +104,7 @@ Defined in: [webdggrid.ts:1572](https://github.com/am2222/webDggrid/blob/6a20c6a
 
 > `readonly` `static` **Z3\_MAX\_RES**: `30` = `30`
 
-Defined in: [webdggrid.ts:1570](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1570)
+Defined in: [webdggrid.ts:1593](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1593)
 
 **`Internal`**
 
@@ -114,7 +114,7 @@ Defined in: [webdggrid.ts:1570](https://github.com/am2222/webDggrid/blob/6a20c6a
 
 > `readonly` `static` **Z3\_QUAD\_MASK**: `17293822569102704640n` = `0xF000000000000000n`
 
-Defined in: [webdggrid.ts:1574](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1574)
+Defined in: [webdggrid.ts:1597](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1597)
 
 **`Internal`**
 
@@ -124,7 +124,7 @@ Defined in: [webdggrid.ts:1574](https://github.com/am2222/webDggrid/blob/6a20c6a
 
 > `readonly` `static` **Z3\_QUAD\_OFFSET**: `60n` = `60n`
 
-Defined in: [webdggrid.ts:1573](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1573)
+Defined in: [webdggrid.ts:1596](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1596)
 
 **`Internal`**
 
@@ -134,7 +134,7 @@ Defined in: [webdggrid.ts:1573](https://github.com/am2222/webDggrid/blob/6a20c6a
 
 > `readonly` `static` **Z7\_BITS\_PER\_DIGIT**: `3n` = `3n`
 
-Defined in: [webdggrid.ts:1564](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1564)
+Defined in: [webdggrid.ts:1587](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1587)
 
 **`Internal`**
 
@@ -144,7 +144,7 @@ Defined in: [webdggrid.ts:1564](https://github.com/am2222/webDggrid/blob/6a20c6a
 
 > `readonly` `static` **Z7\_DIGIT\_MASK**: `7n` = `7n`
 
-Defined in: [webdggrid.ts:1565](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1565)
+Defined in: [webdggrid.ts:1588](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1588)
 
 **`Internal`**
 
@@ -154,7 +154,7 @@ Defined in: [webdggrid.ts:1565](https://github.com/am2222/webDggrid/blob/6a20c6a
 
 > `readonly` `static` **Z7\_MAX\_RES**: `20` = `20`
 
-Defined in: [webdggrid.ts:1563](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1563)
+Defined in: [webdggrid.ts:1586](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1586)
 
 **`Internal`**
 
@@ -164,7 +164,7 @@ Defined in: [webdggrid.ts:1563](https://github.com/am2222/webDggrid/blob/6a20c6a
 
 > `readonly` `static` **Z7\_QUAD\_MASK**: `17293822569102704640n` = `0xF000000000000000n`
 
-Defined in: [webdggrid.ts:1567](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1567)
+Defined in: [webdggrid.ts:1590](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1590)
 
 **`Internal`**
 
@@ -174,7 +174,7 @@ Defined in: [webdggrid.ts:1567](https://github.com/am2222/webDggrid/blob/6a20c6a
 
 > `readonly` `static` **Z7\_QUAD\_OFFSET**: `60n` = `60n`
 
-Defined in: [webdggrid.ts:1566](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1566)
+Defined in: [webdggrid.ts:1589](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1589)
 
 **`Internal`**
 
@@ -184,7 +184,7 @@ Defined in: [webdggrid.ts:1566](https://github.com/am2222/webDggrid/blob/6a20c6a
 
 > `readonly` `static` **ZORDER\_BITS\_PER\_DIGIT**: `2n` = `2n`
 
-Defined in: [webdggrid.ts:1578](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1578)
+Defined in: [webdggrid.ts:1601](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1601)
 
 **`Internal`**
 
@@ -194,7 +194,7 @@ Defined in: [webdggrid.ts:1578](https://github.com/am2222/webDggrid/blob/6a20c6a
 
 > `readonly` `static` **ZORDER\_DIGIT\_MASK**: `3n` = `3n`
 
-Defined in: [webdggrid.ts:1579](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1579)
+Defined in: [webdggrid.ts:1602](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1602)
 
 **`Internal`**
 
@@ -204,7 +204,7 @@ Defined in: [webdggrid.ts:1579](https://github.com/am2222/webDggrid/blob/6a20c6a
 
 > `readonly` `static` **ZORDER\_MAX\_RES**: `30` = `30`
 
-Defined in: [webdggrid.ts:1577](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1577)
+Defined in: [webdggrid.ts:1600](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1600)
 
 **`Internal`**
 
@@ -214,7 +214,7 @@ Defined in: [webdggrid.ts:1577](https://github.com/am2222/webDggrid/blob/6a20c6a
 
 > `readonly` `static` **ZORDER\_QUAD\_MASK**: `17293822569102704640n` = `0xF000000000000000n`
 
-Defined in: [webdggrid.ts:1581](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1581)
+Defined in: [webdggrid.ts:1604](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1604)
 
 **`Internal`**
 
@@ -224,7 +224,7 @@ Defined in: [webdggrid.ts:1581](https://github.com/am2222/webDggrid/blob/6a20c6a
 
 > `readonly` `static` **ZORDER\_QUAD\_OFFSET**: `60n` = `60n`
 
-Defined in: [webdggrid.ts:1580](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1580)
+Defined in: [webdggrid.ts:1603](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1603)
 
 **`Internal`**
 
@@ -234,7 +234,7 @@ Defined in: [webdggrid.ts:1580](https://github.com/am2222/webDggrid/blob/6a20c6a
 
 > **\_main**(): `any`
 
-Defined in: [webdggrid.ts:386](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L386)
+Defined in: [webdggrid.ts:396](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L396)
 
 **`Internal`**
 
@@ -251,7 +251,7 @@ Not intended for production use.
 
 > **cellAreaKM**(`resolution?`): `number`
 
-Defined in: [webdggrid.ts:457](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L457)
+Defined in: [webdggrid.ts:467](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L467)
 
 Returns the average area of a single cell in square kilometres at the
 given resolution.
@@ -284,7 +284,7 @@ Average cell area in km².
 
 > **cellDistKM**(`resolution?`): `number`
 
-Defined in: [webdggrid.ts:500](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L500)
+Defined in: [webdggrid.ts:510](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L510)
 
 Returns the average centre-to-centre distance between neighbouring cells
 in kilometres at the given resolution.
@@ -317,7 +317,7 @@ Average cell spacing in km.
 
 > **geoToGeo**(`coordinates`, `resolution?`): `Position`[]
 
-Defined in: [webdggrid.ts:720](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L720)
+Defined in: [webdggrid.ts:730](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L730)
 
 Snaps an array of geographic coordinates to the centroid of the DGGS
 cell that contains each point.
@@ -367,7 +367,7 @@ Array of `[lng, lat]` cell centroid positions, one per input
 
 > **geoToPlane**(`coordinates`, `resolution?`): `object`[]
 
-Defined in: [webdggrid.ts:1845](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1845)
+Defined in: [webdggrid.ts:1868](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1868)
 
 Converts geographic coordinates to PLANE coordinates.
 
@@ -397,7 +397,7 @@ Array of `{x, y}` plane coordinates
 
 > **geoToProjtri**(`coordinates`, `resolution?`): `object`[]
 
-Defined in: [webdggrid.ts:1866](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1866)
+Defined in: [webdggrid.ts:1889](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1889)
 
 Converts geographic coordinates to PROJTRI coordinates.
 
@@ -427,7 +427,7 @@ Array of `{tnum, x, y}` projection triangle coordinates
 
 > **geoToQ2dd**(`coordinates`, `resolution?`): `object`[]
 
-Defined in: [webdggrid.ts:1891](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1891)
+Defined in: [webdggrid.ts:1914](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1914)
 
 Converts geographic coordinates to Q2DD coordinates.
 
@@ -457,7 +457,7 @@ Array of `{quad, x, y}` quad 2D double coordinates
 
 > **geoToQ2di**(`coordinates`, `resolution?`): `object`[]
 
-Defined in: [webdggrid.ts:1916](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1916)
+Defined in: [webdggrid.ts:1939](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1939)
 
 Converts geographic coordinates to Q2DI coordinates.
 
@@ -487,7 +487,7 @@ Array of `{quad, i, j}` quad 2D integer coordinates
 
 > **geoToSequenceNum**(`coordinates`, `resolution?`): `bigint`[]
 
-Defined in: [webdggrid.ts:601](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L601)
+Defined in: [webdggrid.ts:611](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L611)
 
 Converts an array of geographic coordinates to their corresponding DGGS
 cell sequence numbers (cell IDs) at the given resolution.
@@ -539,7 +539,7 @@ Array of `BigInt` sequence numbers, one per input coordinate,
 
 > **getResolution**(): `number`
 
-Defined in: [webdggrid.ts:362](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L362)
+Defined in: [webdggrid.ts:372](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L372)
 
 Returns the currently active grid resolution.
 
@@ -560,7 +560,7 @@ The current resolution level.
 
 > **gridStatCLS**(`resolution?`): `number`
 
-Defined in: [webdggrid.ts:544](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L544)
+Defined in: [webdggrid.ts:554](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L554)
 
 Returns the characteristic length scale (CLS) of the grid at the given
 resolution — defined as the square root of the average cell area.
@@ -590,11 +590,36 @@ Grid CLS value.
 
 ***
 
+### igeo7AuthalicToGeo()
+
+> **igeo7AuthalicToGeo**(`latDeg`): `number`
+
+Defined in: [webdggrid.ts:2641](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2641)
+
+Inverse of [igeo7GeoToAuthalic](#igeo7geotoauthalic) — convert an authalic latitude
+back to geodetic.
+
+#### Parameters
+
+##### latDeg
+
+`number`
+
+Authalic latitude in degrees.
+
+#### Returns
+
+`number`
+
+Geodetic latitude (WGS84) in degrees.
+
+***
+
 ### igeo7Encode()
 
 > **igeo7Encode**(`base`, `digits`): `bigint`
 
-Defined in: [webdggrid.ts:2458](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2458)
+Defined in: [webdggrid.ts:2481](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2481)
 
 Pack a base cell and exactly 20 digit slots into a 64-bit Z7 index.
 
@@ -639,7 +664,7 @@ If `digits.length !== 20`.
 
 > **igeo7FirstNonZero**(`index`): `number`
 
-Defined in: [webdggrid.ts:2583](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2583)
+Defined in: [webdggrid.ts:2606](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2606)
 
 Position (1-20) of the first non-zero digit slot in a Z7 index.
 Returns `0` when no non-zero digit exists (centre of the base cell).
@@ -664,7 +689,7 @@ Position of first non-zero digit, or 0.
 
 > **igeo7FromString**(`s`): `bigint`
 
-Defined in: [webdggrid.ts:2418](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2418)
+Defined in: [webdggrid.ts:2441](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2441)
 
 Parse a Z7 compact string into a packed 64-bit index.
 
@@ -689,11 +714,39 @@ Packed index as BigInt (unsigned).
 
 ***
 
+### igeo7GeoToAuthalic()
+
+> **igeo7GeoToAuthalic**(`latDeg`): `number`
+
+Defined in: [webdggrid.ts:2630](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2630)
+
+Convert a geodetic latitude (WGS84 ellipsoid) to its authalic latitude
+on the equal-area sphere. Implementation follows Karney (2022) — same
+polynomial used by the `igeo7_geo_to_authalic` DuckDB scalar function.
+
+Longitude is unaffected; only latitude is transformed.
+
+#### Parameters
+
+##### latDeg
+
+`number`
+
+Geodetic latitude in degrees, range `[-90, 90]`.
+
+#### Returns
+
+`number`
+
+Authalic latitude in degrees.
+
+***
+
 ### igeo7GetBaseCell()
 
 > **igeo7GetBaseCell**(`index`): `number`
 
-Defined in: [webdggrid.ts:2487](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2487)
+Defined in: [webdggrid.ts:2510](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2510)
 
 Extract the base cell (0-11) of a packed Z7 index.
 
@@ -717,7 +770,7 @@ Base cell ID.
 
 > **igeo7GetDigit**(`index`, `position`): `number`
 
-Defined in: [webdggrid.ts:2499](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2499)
+Defined in: [webdggrid.ts:2522](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2522)
 
 Extract the `i`-th digit (1-20) of a packed Z7 index.
 Positions outside `[1, 20]` return `7` (matches DuckDB extension).
@@ -748,7 +801,7 @@ Digit value (0-7).
 
 > **igeo7GetResolution**(`index`): `number`
 
-Defined in: [webdggrid.ts:2477](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2477)
+Defined in: [webdggrid.ts:2500](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2500)
 
 Extract the resolution (0-20) of a packed Z7 index.
 
@@ -772,7 +825,7 @@ Resolution level.
 
 > **igeo7IsValid**(`index`): `boolean`
 
-Defined in: [webdggrid.ts:2593](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2593)
+Defined in: [webdggrid.ts:2616](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2616)
 
 Whether a packed Z7 index is valid (i.e. not the `UINT64_MAX` sentinel).
 
@@ -796,7 +849,7 @@ Packed Z7 index.
 
 > **igeo7Neighbour**(`index`, `direction`): `bigint`
 
-Defined in: [webdggrid.ts:2572](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2572)
+Defined in: [webdggrid.ts:2595](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2595)
 
 Single neighbour of a Z7 cell by GBT direction (1-6).
 
@@ -829,7 +882,7 @@ Neighbour index as BigInt.
 
 > **igeo7Neighbours**(`index`): `bigint`[]
 
-Defined in: [webdggrid.ts:2557](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2557)
+Defined in: [webdggrid.ts:2580](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2580)
 
 Return all 6 neighbour indices of a Z7 cell, in GBT directions 1-6.
 
@@ -864,7 +917,7 @@ Array of exactly 6 BigInt neighbour indices.
 
 > **igeo7Parent**(`index`): `bigint`
 
-Defined in: [webdggrid.ts:2517](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2517)
+Defined in: [webdggrid.ts:2540](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2540)
 
 Parent of a Z7 cell — one hierarchy level up.
 
@@ -896,7 +949,7 @@ Parent index as BigInt.
 
 > **igeo7ParentAt**(`index`, `resolution`): `bigint`
 
-Defined in: [webdggrid.ts:2536](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2536)
+Defined in: [webdggrid.ts:2559](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2559)
 
 Ancestor of a Z7 cell at a specific resolution.
 
@@ -934,7 +987,7 @@ Ancestor index as BigInt.
 
 > **igeo7ToString**(`index`): `string`
 
-Defined in: [webdggrid.ts:2435](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2435)
+Defined in: [webdggrid.ts:2458](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2458)
 
 Render a packed Z7 index as its compact string form.
 
@@ -961,11 +1014,54 @@ Compact Z7 string.
 
 ***
 
+### igeo7TransformGeoJson()
+
+> **igeo7TransformGeoJson**\<`T`\>(`input`, `direction?`): `T`
+
+Defined in: [webdggrid.ts:2659](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2659)
+
+Apply [igeo7GeoToAuthalic](#igeo7geotoauthalic) (or its inverse) to every coordinate of
+a GeoJSON geometry, feature, or feature collection. Mirrors the
+`igeo7_geo_to_authalic` / `igeo7_authalic_to_geo` DuckDB functions
+(which take/return `GEOMETRY`); this is the WASM equivalent for
+GeoJSON-shaped inputs.
+
+The input is **deep-cloned** — the source object is not mutated.
+Geometries with `null` or unsupported types are returned unchanged.
+
+#### Type Parameters
+
+##### T
+
+`T` *extends* `GeoJSON`
+
+#### Parameters
+
+##### input
+
+`T`
+
+Any GeoJSON geometry, feature, or feature collection.
+
+##### direction?
+
+`"geoToAuthalic"` \| `"authalicToGeo"`
+
+`'geoToAuthalic'` (default) or `'authalicToGeo'`.
+
+#### Returns
+
+`T`
+
+A new GeoJSON object of the same shape with transformed lats.
+
+***
+
 ### nCells()
 
 > **nCells**(`resolution?`): `number`
 
-Defined in: [webdggrid.ts:414](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L414)
+Defined in: [webdggrid.ts:424](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L424)
 
 Returns the total number of cells that tile the entire globe at the
 given resolution under the current DGGS configuration.
@@ -1007,7 +1103,7 @@ Total number of cells at the given resolution.
 
 > **projtriToGeo**(`coords`, `resolution?`): `Position`[]
 
-Defined in: [webdggrid.ts:2263](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2263)
+Defined in: [webdggrid.ts:2286](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2286)
 
 Converts PROJTRI coordinates to geographic coordinates.
 
@@ -1037,7 +1133,7 @@ Array of `[lng, lat]` positions
 
 > **projtriToPlane**(`coords`, `resolution?`): `object`[]
 
-Defined in: [webdggrid.ts:2300](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2300)
+Defined in: [webdggrid.ts:2323](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2323)
 
 Converts PROJTRI coordinates to PLANE coordinates.
 
@@ -1067,7 +1163,7 @@ Array of `{x, y}` plane coordinates
 
 > **projtriToQ2dd**(`coords`, `resolution?`): `object`[]
 
-Defined in: [webdggrid.ts:2322](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2322)
+Defined in: [webdggrid.ts:2345](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2345)
 
 Converts PROJTRI coordinates to Q2DD coordinates.
 
@@ -1097,7 +1193,7 @@ Array of `{quad, x, y}` quad 2D double coordinates
 
 > **projtriToQ2di**(`coords`, `resolution?`): `object`[]
 
-Defined in: [webdggrid.ts:2348](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2348)
+Defined in: [webdggrid.ts:2371](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2371)
 
 Converts PROJTRI coordinates to Q2DI coordinates.
 
@@ -1127,7 +1223,7 @@ Array of `{quad, i, j}` quad 2D integer coordinates
 
 > **projtriToSequenceNum**(`coords`, `resolution?`): `bigint`[]
 
-Defined in: [webdggrid.ts:2285](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2285)
+Defined in: [webdggrid.ts:2308](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2308)
 
 Converts PROJTRI coordinates to sequence numbers.
 
@@ -1157,7 +1253,7 @@ Array of cell IDs
 
 > **q2ddToGeo**(`coords`, `resolution?`): `Position`[]
 
-Defined in: [webdggrid.ts:2148](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2148)
+Defined in: [webdggrid.ts:2171](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2171)
 
 Converts Q2DD coordinates to geographic coordinates.
 
@@ -1187,7 +1283,7 @@ Array of `[lng, lat]` positions
 
 > **q2ddToPlane**(`coords`, `resolution?`): `object`[]
 
-Defined in: [webdggrid.ts:2185](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2185)
+Defined in: [webdggrid.ts:2208](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2208)
 
 Converts Q2DD coordinates to PLANE coordinates.
 
@@ -1217,7 +1313,7 @@ Array of `{x, y}` plane coordinates
 
 > **q2ddToProjtri**(`coords`, `resolution?`): `object`[]
 
-Defined in: [webdggrid.ts:2207](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2207)
+Defined in: [webdggrid.ts:2230](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2230)
 
 Converts Q2DD coordinates to PROJTRI coordinates.
 
@@ -1247,7 +1343,7 @@ Array of `{tnum, x, y}` projection triangle coordinates
 
 > **q2ddToQ2di**(`coords`, `resolution?`): `object`[]
 
-Defined in: [webdggrid.ts:2233](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2233)
+Defined in: [webdggrid.ts:2256](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2256)
 
 Converts Q2DD coordinates to Q2DI coordinates.
 
@@ -1277,7 +1373,7 @@ Array of `{quad, i, j}` quad 2D integer coordinates
 
 > **q2ddToSequenceNum**(`coords`, `resolution?`): `bigint`[]
 
-Defined in: [webdggrid.ts:2170](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2170)
+Defined in: [webdggrid.ts:2193](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2193)
 
 Converts Q2DD coordinates to sequence numbers.
 
@@ -1307,7 +1403,7 @@ Array of cell IDs
 
 > **q2diToGeo**(`coords`, `resolution?`): `Position`[]
 
-Defined in: [webdggrid.ts:2033](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2033)
+Defined in: [webdggrid.ts:2056](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2056)
 
 Converts Q2DI coordinates to geographic coordinates.
 
@@ -1337,7 +1433,7 @@ Array of `[lng, lat]` positions
 
 > **q2diToPlane**(`coords`, `resolution?`): `object`[]
 
-Defined in: [webdggrid.ts:2070](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2070)
+Defined in: [webdggrid.ts:2093](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2093)
 
 Converts Q2DI coordinates to PLANE coordinates.
 
@@ -1367,7 +1463,7 @@ Array of `{x, y}` plane coordinates
 
 > **q2diToProjtri**(`coords`, `resolution?`): `object`[]
 
-Defined in: [webdggrid.ts:2092](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2092)
+Defined in: [webdggrid.ts:2115](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2115)
 
 Converts Q2DI coordinates to PROJTRI coordinates.
 
@@ -1397,7 +1493,7 @@ Array of `{tnum, x, y}` projection triangle coordinates
 
 > **q2diToQ2dd**(`coords`, `resolution?`): `object`[]
 
-Defined in: [webdggrid.ts:2118](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2118)
+Defined in: [webdggrid.ts:2141](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2141)
 
 Converts Q2DI coordinates to Q2DD coordinates.
 
@@ -1427,7 +1523,7 @@ Array of `{quad, x, y}` quad 2D double coordinates
 
 > **q2diToSequenceNum**(`coords`, `resolution?`): `bigint`[]
 
-Defined in: [webdggrid.ts:2055](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2055)
+Defined in: [webdggrid.ts:2078](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2078)
 
 Converts Q2DI coordinates to sequence numbers.
 
@@ -1457,7 +1553,7 @@ Array of cell IDs
 
 > **sequenceNumAllParents**(`sequenceNum`, `resolution?`): `bigint`[][]
 
-Defined in: [webdggrid.ts:1082](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1082)
+Defined in: [webdggrid.ts:1105](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1105)
 
 Returns **all** parent cells that touch each input cell at the coarser
 resolution (resolution - 1).
@@ -1510,7 +1606,7 @@ If `resolution` is 0 or negative, or if an invalid cell ID is
 
 > **sequenceNumChildren**(`sequenceNum`, `resolution?`): `bigint`[][]
 
-Defined in: [webdggrid.ts:1142](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1142)
+Defined in: [webdggrid.ts:1165](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1165)
 
 Returns all child cells at the next finer resolution (resolution + 1)
 for each input cell.
@@ -1566,7 +1662,7 @@ If an invalid cell ID is provided or if the maximum resolution
 
 > **sequenceNumNeighbors**(`sequenceNum`, `resolution?`): `bigint`[][]
 
-Defined in: [webdggrid.ts:935](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L935)
+Defined in: [webdggrid.ts:958](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L958)
 
 Returns all neighboring cells (sharing an edge) for each input cell.
 
@@ -1619,7 +1715,7 @@ If Triangle topology is used or if an invalid cell ID is provided.
 
 > **sequenceNumParent**(`sequenceNum`, `resolution?`): `bigint`[]
 
-Defined in: [webdggrid.ts:1014](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1014)
+Defined in: [webdggrid.ts:1037](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1037)
 
 Returns the parent cell at the next coarser resolution (resolution - 1)
 for each input cell.
@@ -1670,7 +1766,7 @@ If resolution is 0 or if an invalid cell ID is provided.
 
 > **sequenceNumToGeo**(`sequenceNum`, `resolution?`): `Position`[]
 
-Defined in: [webdggrid.ts:655](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L655)
+Defined in: [webdggrid.ts:665](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L665)
 
 Converts an array of DGGS cell sequence numbers to the geographic
 coordinates of their centroids.
@@ -1709,9 +1805,9 @@ Array of `[lng, lat]` centroid positions, one per input ID, in
 
 ### sequenceNumToGrid()
 
-> **sequenceNumToGrid**(`sequenceNum`, `resolution?`): `Position`[][]
+> **sequenceNumToGrid**(`sequenceNum`, `resolution?`, `unwrap?`): `Position`[][]
 
-Defined in: [webdggrid.ts:785](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L785)
+Defined in: [webdggrid.ts:803](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L803)
 
 Returns the polygon boundary vertices for each cell in `sequenceNum`.
 
@@ -1743,6 +1839,19 @@ Array of `BigInt` cell IDs whose boundaries to
 Resolution at which the IDs were generated. Defaults
   to the instance's current [resolution](#sequencenumtogrid).
 
+##### unwrap?
+
+`boolean` = `true`
+
+When `true` (default), antimeridian-crossing rings are
+  passed through [unwrapAntimeridianRing](../functions/unwrapAntimeridianRing.md) so longitudes stay
+  contiguous (lons may exceed 180°). Required by MapLibre GL / Mapbox
+  GL globe projection. Set to `false` to receive the raw DGGRID output
+  in `[-180, 180]` — required by Cesium's `GeoJsonDataSource` (which
+  internally normalises lons and breaks polar caps under unwrap), and
+  by any sphere-aware renderer that interpolates edges as great-circle
+  arcs.
+
 #### Returns
 
 `Position`[][]
@@ -1758,9 +1867,9 @@ If the WASM module encounters an invalid cell ID.
 
 ### sequenceNumToGridFeatureCollection()
 
-> **sequenceNumToGridFeatureCollection**(`sequenceNum`, `resolution?`): `FeatureCollection`\<`Polygon`, `object` & `object`\>
+> **sequenceNumToGridFeatureCollection**(`sequenceNum`, `resolution?`, `unwrap?`): `FeatureCollection`\<`Polygon`, `object` & `object`\>
 
-Defined in: [webdggrid.ts:880](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L880)
+Defined in: [webdggrid.ts:902](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L902)
 
 Converts an array of DGGS cell IDs into a GeoJSON `FeatureCollection`
 where each `Feature` is a `Polygon` representing the cell boundary.
@@ -1803,6 +1912,14 @@ Array of `BigInt` cell IDs to convert.
 Resolution at which the IDs were generated. Defaults
   to the instance's current [resolution](#sequencenumtogridfeaturecollection).
 
+##### unwrap?
+
+`boolean` = `true`
+
+Forwarded to [sequenceNumToGrid](#sequencenumtogrid). Defaults to
+  `true` (MapLibre-style unwrap). Pass `false` for Cesium and other
+  great-circle-arc renderers.
+
 #### Returns
 
 `FeatureCollection`\<`Polygon`, `object` & `object`\>
@@ -1816,7 +1933,7 @@ A GeoJSON `FeatureCollection` of `Polygon` features, one per
 
 > **sequenceNumToPlane**(`sequenceNum`, `resolution?`): `object`[]
 
-Defined in: [webdggrid.ts:1945](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1945)
+Defined in: [webdggrid.ts:1968](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1968)
 
 Converts sequence numbers to PLANE coordinates.
 
@@ -1846,7 +1963,7 @@ Array of `{x, y}` plane coordinates
 
 > **sequenceNumToProjtri**(`sequenceNum`, `resolution?`): `object`[]
 
-Defined in: [webdggrid.ts:1963](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1963)
+Defined in: [webdggrid.ts:1986](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1986)
 
 Converts sequence numbers to PROJTRI coordinates.
 
@@ -1876,7 +1993,7 @@ Array of `{tnum, x, y}` projection triangle coordinates
 
 > **sequenceNumToQ2dd**(`sequenceNum`, `resolution?`): `object`[]
 
-Defined in: [webdggrid.ts:1985](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1985)
+Defined in: [webdggrid.ts:2008](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2008)
 
 Converts sequence numbers to Q2DD coordinates.
 
@@ -1906,7 +2023,7 @@ Array of `{quad, x, y}` quad 2D double coordinates
 
 > **sequenceNumToQ2di**(`sequenceNum`, `resolution?`): `object`[]
 
-Defined in: [webdggrid.ts:2007](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L2007)
+Defined in: [webdggrid.ts:2030](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L2030)
 
 Converts sequence numbers to Q2DI coordinates.
 
@@ -1936,7 +2053,7 @@ Array of `{quad, i, j}` quad 2D integer coordinates
 
 > **sequenceNumToVertex2DD**(`sequenceNum`, `resolution?`): [`Vertex2DDCoordinate`](../interfaces/Vertex2DDCoordinate.md)
 
-Defined in: [webdggrid.ts:1214](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1214)
+Defined in: [webdggrid.ts:1237](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1237)
 
 Convert a SEQNUM cell ID to VERTEX2DD (icosahedral vertex) coordinates.
 
@@ -1976,7 +2093,7 @@ An object with `{keep, vertNum, triNum, x, y}` representing
 
 > **sequenceNumToZ3**(`sequenceNum`, `resolution?`): `bigint`
 
-Defined in: [webdggrid.ts:1386](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1386)
+Defined in: [webdggrid.ts:1409](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1409)
 
 Convert a SEQNUM cell ID to Z3 (base-3 Central Place Indexing) coordinate.
 
@@ -2022,7 +2139,7 @@ If used with an incompatible aperture (not 3) or topology.
 
 > **sequenceNumToZ7**(`sequenceNum`, `resolution?`): `bigint`
 
-Defined in: [webdggrid.ts:1481](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1481)
+Defined in: [webdggrid.ts:1504](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1504)
 
 Convert a SEQNUM cell ID to Z7 (base-7 Central Place Indexing) coordinate.
 
@@ -2069,7 +2186,7 @@ If used with an incompatible aperture (not 7) or topology.
 
 > **sequenceNumToZOrder**(`sequenceNum`, `resolution?`): `bigint`
 
-Defined in: [webdggrid.ts:1291](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1291)
+Defined in: [webdggrid.ts:1314](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1314)
 
 Convert a SEQNUM cell ID to ZORDER (Z-order curve) coordinate.
 
@@ -2116,7 +2233,7 @@ If used with an incompatible aperture (7) or topology.
 
 > **setDggs**(`dggs?`, `resolution?`): `void`
 
-Defined in: [webdggrid.ts:347](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L347)
+Defined in: [webdggrid.ts:357](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L357)
 
 Sets both the DGGS configuration and the resolution in one call.
 
@@ -2157,7 +2274,7 @@ The new resolution level. Defaults to `1`.
 
 > **setResolution**(`resolution`): `void`
 
-Defined in: [webdggrid.ts:377](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L377)
+Defined in: [webdggrid.ts:387](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L387)
 
 Sets the grid resolution used by default in all conversion and
 statistics methods.
@@ -2185,7 +2302,7 @@ The new resolution level. Must be a positive integer.
 
 > **version**(): `string`
 
-Defined in: [webdggrid.ts:324](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L324)
+Defined in: [webdggrid.ts:334](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L334)
 
 Returns the version string of the underlying DGGRID C++ library.
 
@@ -2205,7 +2322,7 @@ The DGGRID C++ library version string.
 
 > **vertex2DDToSequenceNum**(`keep`, `vertNum`, `triNum`, `x`, `y`, `resolution?`): `bigint`
 
-Defined in: [webdggrid.ts:1247](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1247)
+Defined in: [webdggrid.ts:1270](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1270)
 
 Convert VERTEX2DD (icosahedral vertex) coordinates to a SEQNUM cell ID.
 
@@ -2265,7 +2382,7 @@ The sequence number (BigInt) of the cell containing this coordinate.
 
 > **z3ExtractDigits**(`z3Value`, `resolution`): `object`
 
-Defined in: [webdggrid.ts:1720](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1720)
+Defined in: [webdggrid.ts:1743](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1743)
 
 Extract all digits from a Z3 index up to a given resolution.
 
@@ -2308,7 +2425,7 @@ Object with `quad` (number) and `digits` (number array).
 
 > **z3GetDigit**(`z3Value`, `res`): `number`
 
-Defined in: [webdggrid.ts:1686](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1686)
+Defined in: [webdggrid.ts:1709](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1709)
 
 Get the digit at a specific resolution level from a Z3 index.
 
@@ -2345,7 +2462,7 @@ The digit value (0–3).
 
 > **z3GetQuad**(`z3Value`): `number`
 
-Defined in: [webdggrid.ts:1668](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1668)
+Defined in: [webdggrid.ts:1691](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1691)
 
 Get the quad (icosahedron face) number from a Z3 index.
 
@@ -2373,7 +2490,7 @@ The quad number (0–11).
 
 > **z3SetDigit**(`z3Value`, `res`, `digit`): `bigint`
 
-Defined in: [webdggrid.ts:1703](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1703)
+Defined in: [webdggrid.ts:1726](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1726)
 
 Set the digit at a specific resolution level in a Z3 index.
 
@@ -2413,7 +2530,7 @@ A new Z3 value with the digit replaced.
 
 > **z3ToSequenceNum**(`z3Value`, `resolution?`): `bigint`
 
-Defined in: [webdggrid.ts:1430](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1430)
+Defined in: [webdggrid.ts:1453](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1453)
 
 Convert a Z3 (base-3 Central Place Indexing) coordinate to a SEQNUM cell ID.
 
@@ -2453,7 +2570,7 @@ If used with an incompatible aperture (not 3) or topology.
 
 > **z7ExtractDigits**(`z7Value`, `resolution`): `object`
 
-Defined in: [webdggrid.ts:1649](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1649)
+Defined in: [webdggrid.ts:1672](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1672)
 
 Extract all digits from a Z7 index up to a given resolution.
 
@@ -2496,7 +2613,7 @@ Object with `quad` (number) and `digits` (number array).
 
 > **z7GetDigit**(`z7Value`, `res`): `number`
 
-Defined in: [webdggrid.ts:1613](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1613)
+Defined in: [webdggrid.ts:1636](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1636)
 
 Get the digit at a specific resolution level from a Z7 index.
 
@@ -2533,7 +2650,7 @@ The digit value (0–7).
 
 > **z7GetQuad**(`z7Value`): `number`
 
-Defined in: [webdggrid.ts:1595](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1595)
+Defined in: [webdggrid.ts:1618](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1618)
 
 Get the quad (icosahedron face) number from a Z7 index.
 
@@ -2563,7 +2680,7 @@ The quad number (0–11).
 
 > **z7SetDigit**(`z7Value`, `res`, `digit`): `bigint`
 
-Defined in: [webdggrid.ts:1632](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1632)
+Defined in: [webdggrid.ts:1655](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1655)
 
 Set the digit at a specific resolution level in a Z7 index.
 
@@ -2605,7 +2722,7 @@ A new Z7 value with the digit replaced.
 
 > **z7ToSequenceNum**(`z7Value`, `resolution?`): `bigint`
 
-Defined in: [webdggrid.ts:1525](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1525)
+Defined in: [webdggrid.ts:1548](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1548)
 
 Convert a Z7 (base-7 Central Place Indexing) coordinate to a SEQNUM cell ID.
 
@@ -2645,7 +2762,7 @@ If used with an incompatible aperture (not 7) or topology.
 
 > **zOrderExtractDigits**(`zorderValue`, `resolution`): `object`
 
-Defined in: [webdggrid.ts:1790](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1790)
+Defined in: [webdggrid.ts:1813](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1813)
 
 Extract all digits from a ZORDER index up to a given resolution.
 
@@ -2688,7 +2805,7 @@ Object with `quad` (number) and `digits` (number array).
 
 > **zOrderGetDigit**(`zorderValue`, `res`): `number`
 
-Defined in: [webdggrid.ts:1756](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1756)
+Defined in: [webdggrid.ts:1779](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1779)
 
 Get the digit at a specific resolution level from a ZORDER index.
 
@@ -2724,7 +2841,7 @@ The digit value (0–3).
 
 > **zOrderGetQuad**(`zorderValue`): `number`
 
-Defined in: [webdggrid.ts:1739](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1739)
+Defined in: [webdggrid.ts:1762](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1762)
 
 Get the quad (icosahedron face) number from a ZORDER index.
 
@@ -2752,7 +2869,7 @@ The quad number (0–11).
 
 > **zOrderSetDigit**(`zorderValue`, `res`, `digit`): `bigint`
 
-Defined in: [webdggrid.ts:1773](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1773)
+Defined in: [webdggrid.ts:1796](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1796)
 
 Set the digit at a specific resolution level in a ZORDER index.
 
@@ -2792,7 +2909,7 @@ A new ZORDER value with the digit replaced.
 
 > **zOrderToSequenceNum**(`zorderValue`, `resolution?`): `bigint`
 
-Defined in: [webdggrid.ts:1336](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L1336)
+Defined in: [webdggrid.ts:1359](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L1359)
 
 Convert a ZORDER (Z-order curve) coordinate to a SEQNUM cell ID.
 
@@ -2832,7 +2949,7 @@ If used with an incompatible aperture (7) or topology.
 
 > `static` **load**(): `Promise`\<*typeof* `Webdggrid`\>
 
-Defined in: [webdggrid.ts:298](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L298)
+Defined in: [webdggrid.ts:308](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L308)
 
 Compiles and instantiates the DGGRID WebAssembly module.
 
@@ -2862,7 +2979,7 @@ A promise that resolves to a fully initialised `Webdggrid` instance.
 
 > `static` **unload**(): `void`
 
-Defined in: [webdggrid.ts:311](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L311)
+Defined in: [webdggrid.ts:321](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L321)
 
 Releases the compiled WASM instance and frees its memory.
 
diff --git a/docs/api/enumerations/Projection.md b/docs/api/enumerations/Projection.md
index 249a97b..85d2d87 100644
--- a/docs/api/enumerations/Projection.md
+++ b/docs/api/enumerations/Projection.md
@@ -2,7 +2,7 @@
 
 # Enumeration: Projection
 
-Defined in: [webdggrid.ts:49](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L49)
+Defined in: [webdggrid.ts:49](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L49)
 
 The map projection used to place the polyhedron faces onto the sphere.
 
@@ -27,7 +27,7 @@ dggs.setDggs({ projection: Projection.ISEA, ... }, 4);
 
 > **FULLER**: `"FULLER"`
 
-Defined in: [webdggrid.ts:53](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L53)
+Defined in: [webdggrid.ts:53](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L53)
 
 Fuller/Dymaxion projection — shape-preserving cells.
 
@@ -37,6 +37,6 @@ Fuller/Dymaxion projection — shape-preserving cells.
 
 > **ISEA**: `"ISEA"`
 
-Defined in: [webdggrid.ts:51](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L51)
+Defined in: [webdggrid.ts:51](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L51)
 
 Icosahedral Snyder Equal Area projection — equal-area cells.
diff --git a/docs/api/enumerations/Topology.md b/docs/api/enumerations/Topology.md
index 853bbd8..7110a88 100644
--- a/docs/api/enumerations/Topology.md
+++ b/docs/api/enumerations/Topology.md
@@ -2,7 +2,7 @@
 
 # Enumeration: Topology
 
-Defined in: [webdggrid.ts:22](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L22)
+Defined in: [webdggrid.ts:22](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L22)
 
 The shape of each cell in the Discrete Global Grid System.
 
@@ -26,7 +26,7 @@ dggs.setDggs({ topology: Topology.HEXAGON, ... }, 4);
 
 > **DIAMOND**: `"DIAMOND"`
 
-Defined in: [webdggrid.ts:28](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L28)
+Defined in: [webdggrid.ts:28](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L28)
 
 Four-sided diamond cells (squares rotated 45°).
 
@@ -36,7 +36,7 @@ Four-sided diamond cells (squares rotated 45°).
 
 > **HEXAGON**: `"HEXAGON"`
 
-Defined in: [webdggrid.ts:24](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L24)
+Defined in: [webdggrid.ts:24](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L24)
 
 Six-sided cells — the default and most widely used topology.
 
@@ -46,6 +46,6 @@ Six-sided cells — the default and most widely used topology.
 
 > **TRIANGLE**: `"TRIANGLE"`
 
-Defined in: [webdggrid.ts:26](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L26)
+Defined in: [webdggrid.ts:26](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L26)
 
 Three-sided cells.
diff --git a/docs/api/functions/unwrapAntimeridianRing.md b/docs/api/functions/unwrapAntimeridianRing.md
index 1ff6bb8..e04410b 100644
--- a/docs/api/functions/unwrapAntimeridianRing.md
+++ b/docs/api/functions/unwrapAntimeridianRing.md
@@ -4,13 +4,20 @@
 
 > **unwrapAntimeridianRing**(`ring`): `Position`[]
 
-Defined in: [webdggrid.ts:195](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L195)
+Defined in: [webdggrid.ts:202](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L202)
 
 Rewraps a polygon ring that crosses the antimeridian so that all longitudes
-are in a contiguous range (some may exceed 180°).  This is the format
-expected by MapLibre GL / Mapbox GL globe projection for antimeridian cells.
-For renderers that require standard [-180, 180] coordinates, use the raw
-output from [Webdggrid.sequenceNumToGrid](../classes/Webdggrid.md#sequencenumtogrid) directly.
+are in a contiguous range. The output longitudes may fall outside
+[-180, 180] — that's intentional, and is the format expected by MapLibre
+GL / Mapbox GL globe projection for antimeridian cells. For renderers that
+require standard [-180, 180] coordinates, run a final modulo step
+downstream.
+
+Walks consecutive vertices and accumulates a ±360 offset whenever the
+longitude delta between neighbours exceeds 180° (the only meaningful sign
+of an antimeridian crossing). This keeps the traversal direction faithful
+even for polar caps, which span a full 360° in lon and were broken by the
+previous "negative-to-positive" rewrite.
 
 ## Parameters
 
diff --git a/docs/api/interfaces/Coordinate.md b/docs/api/interfaces/Coordinate.md
index 3cf503d..eccea79 100644
--- a/docs/api/interfaces/Coordinate.md
+++ b/docs/api/interfaces/Coordinate.md
@@ -2,7 +2,7 @@
 
 # Interface: Coordinate
 
-Defined in: [webdggrid.ts:65](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L65)
+Defined in: [webdggrid.ts:65](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L65)
 
 A simple geographic coordinate expressed as latitude and longitude in
 decimal degrees (WGS-84).
@@ -19,7 +19,7 @@ const coord: Coordinate = { lat: 51.5, lng: -0.1 };
 
 > **lat**: `number`
 
-Defined in: [webdggrid.ts:67](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L67)
+Defined in: [webdggrid.ts:67](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L67)
 
 Latitude in decimal degrees. Range: −90 to 90.
 
@@ -29,6 +29,6 @@ Latitude in decimal degrees. Range: −90 to 90.
 
 > **lng**: `number`
 
-Defined in: [webdggrid.ts:69](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L69)
+Defined in: [webdggrid.ts:69](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L69)
 
 Longitude in decimal degrees. Range: −180 to 180.
diff --git a/docs/api/interfaces/IDGGSProps.md b/docs/api/interfaces/IDGGSProps.md
index 4163792..23189bd 100644
--- a/docs/api/interfaces/IDGGSProps.md
+++ b/docs/api/interfaces/IDGGSProps.md
@@ -2,7 +2,7 @@
 
 # Interface: IDGGSProps
 
-Defined in: [webdggrid.ts:136](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L136)
+Defined in: [webdggrid.ts:136](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L136)
 
 Full configuration of a Discrete Global Grid System.
 
@@ -32,7 +32,7 @@ dggs.setDggs(myDggs, 5);
 
 > `optional` **aperture?**: `7` \| `3` \| `4` \| `5`
 
-Defined in: [webdggrid.ts:162](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L162)
+Defined in: [webdggrid.ts:162](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L162)
 
 Subdivision aperture — the number of child cells each parent cell is
 divided into when moving to the next finer resolution.
@@ -52,7 +52,7 @@ Ignored if `apertureSequence` is specified.
 
 > `optional` **apertureSequence?**: `string`
 
-Defined in: [webdggrid.ts:181](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L181)
+Defined in: [webdggrid.ts:181](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L181)
 
 Mixed aperture sequence (e.g., `"434747"`).
 
@@ -78,7 +78,7 @@ apertureSequence: "434747"
 
 > **azimuth**: `number`
 
-Defined in: [webdggrid.ts:148](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L148)
+Defined in: [webdggrid.ts:148](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L148)
 
 Azimuth of the icosahedron pole in decimal degrees.
 Rotates the grid around the pole axis. Defaults to `0`.
@@ -89,7 +89,7 @@ Rotates the grid around the pole axis. Defaults to `0`.
 
 > **poleCoordinates**: [`Coordinate`](Coordinate.md)
 
-Defined in: [webdggrid.ts:143](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L143)
+Defined in: [webdggrid.ts:143](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L143)
 
 Geographic location of the icosahedron pole used to orient the grid.
 Changing this rotates the entire grid on the globe, which can be used
@@ -102,7 +102,7 @@ Defaults to `{ lat: 0, lng: 0 }`.
 
 > **projection**: [`Projection`](../enumerations/Projection.md)
 
-Defined in: [webdggrid.ts:185](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L185)
+Defined in: [webdggrid.ts:185](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L185)
 
 Projection used to map the polyhedron faces onto the sphere. See [Projection](../enumerations/Projection.md).
 
@@ -112,6 +112,6 @@ Projection used to map the polyhedron faces onto the sphere. See [Projection](..
 
 > **topology**: [`Topology`](../enumerations/Topology.md)
 
-Defined in: [webdggrid.ts:183](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L183)
+Defined in: [webdggrid.ts:183](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L183)
 
 Shape of each cell. See [Topology](../enumerations/Topology.md).
diff --git a/docs/api/interfaces/Vertex2DDCoordinate.md b/docs/api/interfaces/Vertex2DDCoordinate.md
index 130de94..d606eff 100644
--- a/docs/api/interfaces/Vertex2DDCoordinate.md
+++ b/docs/api/interfaces/Vertex2DDCoordinate.md
@@ -2,7 +2,7 @@
 
 # Interface: Vertex2DDCoordinate
 
-Defined in: [webdggrid.ts:78](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L78)
+Defined in: [webdggrid.ts:78](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L78)
 
 VERTEX2DD coordinate representation.
 
@@ -15,7 +15,7 @@ faces in DGGRID's coordinate system.
 
 > **keep**: `boolean`
 
-Defined in: [webdggrid.ts:80](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L80)
+Defined in: [webdggrid.ts:80](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L80)
 
 Whether to keep this vertex.
 
@@ -25,7 +25,7 @@ Whether to keep this vertex.
 
 > **triNum**: `number`
 
-Defined in: [webdggrid.ts:84](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L84)
+Defined in: [webdggrid.ts:84](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L84)
 
 Triangle number on the icosahedron.
 
@@ -35,7 +35,7 @@ Triangle number on the icosahedron.
 
 > **vertNum**: `number`
 
-Defined in: [webdggrid.ts:82](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L82)
+Defined in: [webdggrid.ts:82](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L82)
 
 Vertex number (0-11 for icosahedron).
 
@@ -45,7 +45,7 @@ Vertex number (0-11 for icosahedron).
 
 > **x**: `number`
 
-Defined in: [webdggrid.ts:86](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L86)
+Defined in: [webdggrid.ts:86](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L86)
 
 X coordinate within the triangle.
 
@@ -55,6 +55,6 @@ X coordinate within the triangle.
 
 > **y**: `number`
 
-Defined in: [webdggrid.ts:88](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L88)
+Defined in: [webdggrid.ts:88](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L88)
 
 Y coordinate within the triangle.
diff --git a/docs/api/type-aliases/DGGSGeoJsonProperty.md b/docs/api/type-aliases/DGGSGeoJsonProperty.md
index 38558ac..921b16d 100644
--- a/docs/api/type-aliases/DGGSGeoJsonProperty.md
+++ b/docs/api/type-aliases/DGGSGeoJsonProperty.md
@@ -4,7 +4,7 @@
 
 > **DGGSGeoJsonProperty** = `GeoJsonProperties` & `object`
 
-Defined in: [webdggrid.ts:102](https://github.com/am2222/webDggrid/blob/6a20c6a662c56fec4ef89c53e60cb9df7b144cb1/src-ts/webdggrid.ts#L102)
+Defined in: [webdggrid.ts:102](https://github.com/am2222/webDggrid/blob/62544b244ecf036037149f81bc90e0fa7718511e/src-ts/webdggrid.ts#L102)
 
 GeoJSON `properties` object attached to every cell feature returned by
 [Webdggrid.sequenceNumToGridFeatureCollection](../classes/Webdggrid.md#sequencenumtogridfeaturecollection).
diff --git a/docs/authalic.md b/docs/authalic.md
new file mode 100644
index 0000000..36a50b8
--- /dev/null
+++ b/docs/authalic.md
@@ -0,0 +1,126 @@
+# Authalic latitude conversion
+
+WGS84 is an oblate ellipsoid. Most DGGS theory and equal-area projections
+prefer to work on a sphere with the **same surface area** as the ellipsoid —
+the *authalic* sphere. Mapping a geodetic latitude `φ` to its authalic
+counterpart `ξ` is a small (≤0.19°) shift that's zero at the equator and
+poles and peaks near ±45°.
+
+WebDggrid exposes the conversion as both a scalar primitive and a
+GeoJSON-walking helper. They mirror the
+[`igeo7_geo_to_authalic` / `igeo7_authalic_to_geo`](https://github.com/allixender/igeo7_duckdb#authalic-latitude-conversion)
+DuckDB extension functions; the JS versions cover the cases the DuckDB
+`(GEOMETRY) → GEOMETRY` signature can't reach (DuckDB `GEOMETRY` doesn't
+exist in the WASM environment).
+
+```ts
+import { Webdggrid } from 'webdggrid'
+const dggs = await Webdggrid.load()
+
+dggs.igeo7GeoToAuthalic(45)                 // ~44.8717
+dggs.igeo7AuthalicToGeo(44.87170287)        // ~45.0
+dggs.igeo7TransformGeoJson(featureCollection) // deep-clones, applies to every coord
+```
+
+The math follows Karney (2022)'s polynomial expansion — the same
+implementation the DuckDB extension uses on `GEOMETRY` columns.
+
+## When to use it
+
+The authalic conversion does **not** belong in your display pipeline.
+Mapping libraries (Cesium, MapLibre, Leaflet, deck.gl) all interpret
+incoming coordinates as WGS84 geodetic; if you feed them authalic
+latitudes the cells will drift relative to the basemap. Reach for it in
+the three places below instead.
+
+### 1. Computing equal-area cell area on the sphere
+
+DGGRID's `cellAreaKM` returns the cell area on the *authalic* sphere of
+radius `R = 6371.0072 km`. If you compute area yourself from the cell's
+lat/lng vertices using a formula that assumes a uniform sphere — e.g.
+spherical excess (Girard's theorem) on the raw geodetic vertices — you'll
+get a slightly different number, because those vertices live on the
+ellipsoid, not the authalic sphere. Apply `igeo7GeoToAuthalic` to the
+latitudes first and the equality returns:
+
+```ts
+import { Webdggrid } from 'webdggrid'
+const dggs = await Webdggrid.load()
+
+const seq = dggs.geoToSequenceNum([[0, 45]], 5)[0]
+const ring = dggs.sequenceNumToGrid([seq], 5, /*unwrap=*/false)[0]
+
+// Authalic-shifted ring (lat only):
+const ringA = ring.map(([lng, lat]) => [lng, dggs.igeo7GeoToAuthalic(lat)])
+
+// Apply spherical excess on each:
+const RA = 6371007.181 // authalic-sphere radius (m), WGS84
+const areaGeo  = sphericalExcess(ring)  * RA * RA / 1e6  // km²
+const areaAuth = sphericalExcess(ringA) * RA * RA / 1e6
+
+console.log(areaGeo, areaAuth, dggs.cellAreaKM(5))
+// areaAuth ≈ dggs.cellAreaKM(5) — the equal-area property holds on
+// the authalic sphere; areaGeo is biased.
+```
+
+Same story for any planar hit-testing or distance math you do directly on
+cell vertices: convert the latitudes first, then assume a uniform sphere
+and the numbers come out matching DGGRID's intent.
+
+### 2. Routing data through the DuckDB extension
+
+If you compute on cells in DuckDB using `igeo7_geo_to_authalic` and pull
+the resulting `GEOMETRY` back into the browser as GeoJSON, you'll receive
+authalic-latitude coordinates. To display them on a Cesium / MapLibre /
+Leaflet basemap, round-trip them with `igeo7TransformGeoJson(fc, 'authalicToGeo')`
+before feeding the layer.
+
+```ts
+const fcFromDuck = JSON.parse(await fetchAuthalicGeometryFromDuckDB())
+const fcForDisplay = dggs.igeo7TransformGeoJson(fcFromDuck, 'authalicToGeo')
+geoJsonLayer.setData(fcForDisplay)
+```
+
+### 3. Showing the difference visually
+
+The shift is small but well-defined. Below, pick a latitude and resolution
+to see how a real DGGS cell at that latitude moves under the conversion.
+The "DGGRID claimed area" is `cellAreaKM` (authalic); the two computed
+areas are spherical excess applied to the geodetic and authalic vertex
+rings on a uniform sphere of the WGS84 authalic radius.
+
+#### Does it change shape, or just position?
+
+Both — but mostly the latter. The transform is `(lng, lat) → (lng, ξ(lat))`
+with longitude untouched, so for a cell that spans only a small latitude
+range every vertex shifts by *almost* the same amount → near-pure
+translation in lat, no visible shape change. Cells that span a wider lat
+range (polar caps, low-resolution cells) see vertices at different lats
+shift by slightly different amounts because `dξ/dφ` is non-constant —
+that's the shape distortion. It's typically <0.001° across one cell.
+
+The interactive below has an "Amplify shape diff" slider so you can crank
+the residual (per-vertex shift minus the mean) up to 2000× and *see* the
+otherwise-imperceptible distortion. The edge-length table beneath confirms
+the same effect numerically — if the conversion were a rigid translation,
+every edge's percent change would be identical; the variation tells you
+the cell is actually being deformed.
+
+<ClientOnly>
+  <AuthalicDemo />
+</ClientOnly>
+
+## Implementation notes
+
+- **Algorithm**: Karney (2022) sixth-order polynomial. Round-trip error is
+  well under `1e-9°` across the full latitude range.
+- **Symmetry**: `f(-φ) === -f(φ)` — the transform is odd. The equator and
+  both poles are fixed points (within `1e-9°` for the poles).
+- **Mutation**: `igeo7TransformGeoJson` deep-clones its input. Geometries
+  with `null` or unsupported `type` strings are returned unchanged.
+- **DuckDB parity**: scalar values match the upstream `igeo7_geo_to_authalic`
+  / `igeo7_authalic_to_geo` SQL functions to floating-point precision.
+
+`sphericalExcess` is a short helper that's the same in both code samples
+above — see [`docs/.vitepress/theme/components/AuthalicDemo.vue`](https://github.com/am2222/webDggrid/blob/main/docs/.vitepress/theme/components/AuthalicDemo.vue)
+for a copy-pasteable implementation.
diff --git a/docs/igeo7.md b/docs/igeo7.md
index f6b6db0..fe0eeeb 100644
--- a/docs/igeo7.md
+++ b/docs/igeo7.md
@@ -56,6 +56,19 @@ Click `→ inspect` on any related cell to drill into it.
 | `igeo7Neighbour` | `(index: bigint, direction: number) → bigint` | Single neighbour by direction (1-6) |
 | `igeo7FirstNonZero` | `(index: bigint) → number` | Position of first non-zero digit slot |
 | `igeo7IsValid` | `(index: bigint) → boolean` | `false` when index equals the invalid sentinel |
+| `igeo7GeoToAuthalic` | `(latDeg: number) → number` | Geodetic → authalic latitude on the WGS84 ellipsoid (Karney 2022) |
+| `igeo7AuthalicToGeo` | `(latDeg: number) → number` | Authalic → geodetic latitude (inverse of above) |
+| `igeo7TransformGeoJson` | `(geo, direction?) → geo` | Apply the latitude conversion to every coordinate of a GeoJSON geometry / feature / FC. Mirrors the `(GEOMETRY) → GEOMETRY` DuckDB scalar functions for use in JS. Accepts `'geoToAuthalic'` (default) or `'authalicToGeo'`. Source object is not mutated. |
+
+::: tip DuckDB extension parity
+The two scalar functions correspond to the upstream extension's
+`igeo7_geo_to_authalic` / `igeo7_authalic_to_geo` `(GEOMETRY) → GEOMETRY`
+SQL functions. `igeo7TransformGeoJson` is the JS-side equivalent — DuckDB's
+`GEOMETRY` type isn't available in WASM, so the wrapper walks GeoJSON
+coordinates instead. See the
+[upstream igeo7_duckdb README](https://github.com/allixender/igeo7_duckdb#authalic-latitude-conversion)
+for the SQL signatures.
+:::
 
 ## Examples
 
@@ -148,6 +161,35 @@ const ns = dggs.igeo7Neighbours(pent);
 ns.filter(n => !dggs.igeo7IsValid(n)).length; // exactly 1
 ```
 
+### Authalic latitude conversion
+
+WGS84 is an oblate ellipsoid; many DGGS calculations and equal-area
+projections want the *authalic* sphere instead — a sphere with the same
+surface area as the ellipsoid. `igeo7GeoToAuthalic` and `igeo7AuthalicToGeo`
+implement the round-trip via Karney (2022)'s polynomial expansion (the same
+math the DuckDB extension applies to `GEOMETRY` columns).
+
+```typescript
+// Scalar use — single latitude in degrees.
+dggs.igeo7GeoToAuthalic(45);                 // ~44.8717
+dggs.igeo7AuthalicToGeo(dggs.igeo7GeoToAuthalic(45)); // 45 within 1e-9°
+```
+
+For GeoJSON inputs, `igeo7TransformGeoJson` walks the geometry and applies
+the conversion to every position's latitude (longitude is untouched). The
+input is deep-cloned, so the original is left intact:
+
+```typescript
+const fc = dggs.sequenceNumToGridFeatureCollection([1n, 2n, 3n], 5);
+const equalArea = dggs.igeo7TransformGeoJson(fc);
+// equalArea is a new FeatureCollection with each cell's vertices
+// projected onto the WGS84 authalic sphere — useful when feeding cells
+// into an equal-area visual or computing on-sphere areas.
+
+// Round-trip back to geodetic for display:
+const back = dggs.igeo7TransformGeoJson(equalArea, 'authalicToGeo');
+```
+
 ## Relationship to DGGRID's built-in Z7
 
 DGGRID ships its own Z7 implementation accessible via `sequenceNumToZ7` /
diff --git a/examples/cesium-pole-test.html b/examples/cesium-pole-test.html
new file mode 100644
index 0000000..5f98783
--- /dev/null
+++ b/examples/cesium-pole-test.html
@@ -0,0 +1,241 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>CesiumJS + webDggrid — Pole Rendering Test</title>
+<style>
+  html, body { margin: 0; height: 100%; background: #000; color: #eee; font-family: system-ui, sans-serif; overflow: hidden; }
+  #cesiumContainer { position: absolute; inset: 0; }
+  .cesium-viewer-bottom { display: none !important; }
+  .panel {
+    position: absolute; top: 12px; left: 12px; z-index: 10;
+    background: rgba(20, 20, 28, 0.88);
+    padding: 12px 14px; border-radius: 8px;
+    width: 270px; box-shadow: 0 2px 12px rgba(0,0,0,0.4);
+  }
+  .panel h2 { margin: 0 0 8px; font-size: 11px; letter-spacing: 0.06em; text-transform: uppercase; color: #9ec5fe; }
+  .panel .row { margin-top: 8px; }
+  .panel button {
+    margin: 2px 4px 2px 0; padding: 4px 10px;
+    background: #2b6cb0; color: white; border: none; border-radius: 4px;
+    font-size: 12px; cursor: pointer;
+  }
+  .panel button:hover { background: #3182ce; }
+  .panel button:disabled { background: #4a5568; cursor: default; }
+  .panel label { font-size: 12px; color: #cbd5e0; display: inline-flex; align-items: center; gap: 6px; }
+  .panel select {
+    background: #1a202c; color: #eee; border: 1px solid #2d3748; border-radius: 3px;
+    padding: 2px 4px; font-size: 12px;
+  }
+  .status {
+    margin-top: 10px; padding-top: 8px; border-top: 1px solid #2d3748;
+    font-size: 11px; color: #9ec5fe; line-height: 1.4; white-space: pre-wrap;
+  }
+  .legend { font-size: 11px; color: #a0aec0; margin-top: 6px; }
+  .legend .swatch {
+    display: inline-block; width: 10px; height: 10px; vertical-align: middle;
+    border: 1px solid #fff; margin-right: 4px;
+  }
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/cesium@1.122/Build/Cesium/Widgets/widgets.css" />
+</head>
+<body>
+<div id="cesiumContainer"></div>
+
+<div class="panel">
+  <h2>DGGRID on CesiumJS — Pole Test</h2>
+
+  <div class="row">
+    <label>Resolution
+      <select id="res">
+        <option value="2">2</option>
+        <option value="3" selected>3</option>
+        <option value="4">4</option>
+        <option value="5">5</option>
+      </select>
+    </label>
+    <button id="regen">Regenerate</button>
+  </div>
+
+  <div class="row">
+    <label><input type="checkbox" id="extrude" /> Extrude cells (3D)</label>
+  </div>
+
+  <div class="row">
+    <strong style="font-size:11px; color:#cbd5e0;">FLY TO</strong><br/>
+    <button data-lng="0"   data-lat="90"  data-alt="16000000">North Pole</button>
+    <button data-lng="0"   data-lat="-90" data-alt="16000000">South Pole</button>
+    <button data-lng="180" data-lat="0"   data-alt="16000000">Antimeridian</button>
+    <button data-lng="0"   data-lat="0"   data-alt="16000000">Globe</button>
+  </div>
+
+  <div class="row">
+    <strong style="font-size:11px; color:#cbd5e0;">ZOOM</strong>
+    <button data-lng="0" data-lat="90" data-alt="3000000">Pole close-up</button>
+  </div>
+
+  <div class="legend">
+    <span class="swatch" style="background:#3388ff"></span>DGGS cells (vector polygons on globe)
+  </div>
+
+  <div class="status" id="status">Loading…</div>
+</div>
+
+<script>
+  window.CESIUM_BASE_URL = 'https://cdn.jsdelivr.net/npm/cesium@1.122/Build/Cesium/';
+</script>
+<script src="https://cdn.jsdelivr.net/npm/cesium@1.122/Build/Cesium/Cesium.js"></script>
+<script type="module">
+  const statusEl = document.getElementById('status');
+  const setStatus = (m) => { statusEl.textContent = m; };
+
+  setStatus('Loading webDggrid WASM…');
+  const wmod = await import('https://cdn.jsdelivr.net/npm/webdggrid/dist/webdggrid.js');
+  const webdggrid = await wmod.Webdggrid.load();
+
+  setStatus('Initializing CesiumJS…');
+  const viewer = new Cesium.Viewer('cesiumContainer', {
+    baseLayer: false,
+    baseLayerPicker: false,
+    geocoder: false,
+    homeButton: false,
+    sceneModePicker: false,
+    navigationHelpButton: false,
+    timeline: false,
+    animation: false,
+    fullscreenButton: false,
+    infoBox: false,
+    selectionIndicator: false,
+    terrainProvider: new Cesium.EllipsoidTerrainProvider(),
+  });
+  viewer.imageryLayers.addImageryProvider(new Cesium.OpenStreetMapImageryProvider({
+    url: 'https://tile.openstreetmap.org/',
+    credit: '© OpenStreetMap contributors',
+  }));
+  viewer.scene.globe.enableLighting = false;
+
+  viewer.camera.flyTo({
+    destination: Cesium.Cartesian3.fromDegrees(0, 90, 16000000),
+    duration: 0,
+  });
+
+  let currentDataSource = null;
+
+  function buildFeatureCollection(resolution) {
+    webdggrid.setDggs({
+      topology: 'HEXAGON',
+      projection: 'ISEA',
+      aperture: 4,
+      azimuth: 0,
+      poleCoordinates: { lat: 0, lng: 0 },
+    }, resolution);
+    const total = webdggrid.nCells(resolution);
+    const seqNums = Array.from({ length: total }, (_, i) => BigInt(i + 1));
+    const fc = webdggrid.sequenceNumToGridFeatureCollection(seqNums, resolution);
+
+    fc.features.forEach((f) => {
+      if (typeof f.id === 'bigint') f.id = f.id.toString();
+      const p = f.properties;
+      if (p) {
+        for (const k of Object.keys(p)) {
+          if (typeof p[k] === 'bigint') p[k] = p[k].toString();
+        }
+      }
+    });
+
+    // webDggrid runs every ring through unwrapAntimeridianRing() for MapLibre's
+    // globe projection. Cesium expects standard [-180, 180] longitudes and does
+    // its own geodesic interpolation, so we reverse the unwrap here.
+    fc.features.forEach((f) => {
+      if (f.geometry?.type === 'Polygon') {
+        f.geometry.coordinates = f.geometry.coordinates.map(rewrapRing);
+      } else if (f.geometry?.type === 'MultiPolygon') {
+        f.geometry.coordinates = f.geometry.coordinates.map((poly) => poly.map(rewrapRing));
+      }
+    });
+
+    return { fc, count: total };
+  }
+
+  function rewrapRing(ring) {
+    return ring.map(([lon, lat]) => {
+      let l = lon;
+      while (l > 180) l -= 360;
+      while (l < -180) l += 360;
+      return [l, lat];
+    });
+  }
+
+  async function renderFeatures(fc, extrude) {
+    if (currentDataSource) {
+      viewer.dataSources.remove(currentDataSource, true);
+      currentDataSource = null;
+    }
+
+    const ds = await Cesium.GeoJsonDataSource.load(fc, {
+      stroke: Cesium.Color.fromCssColorString('rgba(0, 85, 204, 0.95)'),
+      fill: Cesium.Color.fromCssColorString('rgba(51, 136, 255, 0.45)'),
+      strokeWidth: extrude ? 2 : 1,
+      clampToGround: false,
+    });
+
+    // Force geodesic arcs on every polygon. clampToGround: true would use
+    // rhumb-line subdivision under the hood, which is degenerate at the poles
+    // ("Too many properties to enumerate" inside computeRhumbLineSubdivision).
+    ds.entities.values.forEach((e) => {
+      if (e.polygon) {
+        e.polygon.arcType = Cesium.ArcType.GEODESIC;
+        e.polygon.height = 0;
+        if (extrude) {
+          e.polygon.extrudedHeight = 80000;
+          e.polygon.outline = true;
+        }
+      }
+      if (e.polyline) {
+        e.polyline.arcType = Cesium.ArcType.GEODESIC;
+      }
+    });
+
+    await viewer.dataSources.add(ds);
+    currentDataSource = ds;
+  }
+
+  async function regenerate() {
+    const res = parseInt(document.getElementById('res').value, 10);
+    const extrude = document.getElementById('extrude').checked;
+
+    setStatus(`Generating HEXAGON res ${res}…`);
+
+    const t0 = performance.now();
+    const { fc, count } = buildFeatureCollection(res);
+    const tBuild = performance.now() - t0;
+
+    const t1 = performance.now();
+    await renderFeatures(fc, extrude);
+    const tDraw = performance.now() - t1;
+
+    setStatus(`Loaded ${count} cells at res ${res}.
+Built in ${tBuild.toFixed(0)} ms, drew in ${tDraw.toFixed(0)} ms.
+Use FLY TO buttons to inspect the poles.`);
+  }
+
+  function flyTo(lng, lat, altitude) {
+    viewer.camera.flyTo({
+      destination: Cesium.Cartesian3.fromDegrees(lng, lat, altitude),
+      duration: 1.5,
+    });
+  }
+
+  document.getElementById('regen').addEventListener('click', regenerate);
+  document.getElementById('extrude').addEventListener('change', regenerate);
+  document.querySelectorAll('button[data-lng]').forEach((b) => {
+    b.addEventListener('click', () => {
+      flyTo(parseFloat(b.dataset.lng), parseFloat(b.dataset.lat), parseFloat(b.dataset.alt));
+    });
+  });
+
+  regenerate();
+</script>
+</body>
+</html>
diff --git a/src-cpp/dggrid_transform.cpp b/src-cpp/dggrid_transform.cpp
index b54ce20..a02165f 100644
--- a/src-cpp/dggrid_transform.cpp
+++ b/src-cpp/dggrid_transform.cpp
@@ -521,29 +521,12 @@ static unsigned int computeCellVertices(
                             static_cast<double>(c->latDegs()) });
     }
 
-    // Antimeridian: if lon span > 180° shift negatives by +360° for sort
-    bool antimeridian = false;
-    {
-        double lo = scratch[0].first, hi = scratch[0].first;
-        for (auto &p : scratch) { lo = std::min(lo, p.first); hi = std::max(hi, p.first); }
-        if (hi - lo > 180.0) {
-            antimeridian = true;
-            for (auto &p : scratch) if (p.first < 0.0) p.first += 360.0;
-        }
-    }
-
-    double cx = 0.0, cy = 0.0;
-    for (auto &p : scratch) { cx += p.first; cy += p.second; }
-    cx /= n; cy /= n;
-
-    std::sort(scratch.begin(), scratch.end(),
-        [cx, cy](const std::pair<double,double> &a, const std::pair<double,double> &b) {
-            return std::atan2(a.second - cy, a.first - cx) <
-                   std::atan2(b.second - cy, b.first - cx);
-        });
-
-    if (antimeridian)
-        for (auto &p : scratch) if (p.first > 180.0) p.first -= 360.0;
+    // DGGRID emits boundary vertices in correct traversal order around the
+    // spherical polygon. We previously re-sorted by atan2 around the
+    // arithmetic (lon, lat) centroid as a "safety net," but that centroid is
+    // meaningless for any cell whose vertices straddle a pole — it produced
+    // the wrong order for polar caps (e.g. cell 47 @ res 2). Trust DGGRID's
+    // ordering as-is.
 
     for (int i = 0; i < n; i++) { out_x.push_back(scratch[i].first); out_y.push_back(scratch[i].second); }
     out_x.push_back(scratch[0].first); out_y.push_back(scratch[0].second);
diff --git a/src-cpp/igeo7_bindings.cpp b/src-cpp/igeo7_bindings.cpp
index 9813425..11d0d2f 100644
--- a/src-cpp/igeo7_bindings.cpp
+++ b/src-cpp/igeo7_bindings.cpp
@@ -17,6 +17,7 @@
 #include <emscripten/bind.h>
 
 #include "z7/library.h"
+#include "auth/authalic.hpp"
 
 #include <array>
 #include <cstdint>
@@ -176,6 +177,20 @@ static uint64_t igeo7_encode(
     return packed;
 }
 
+// ---------------------------------------------------------------------------
+// igeo7_geo_to_authalic(double) → double  — geodetic latitude → authalic
+// igeo7_authalic_to_geo(double) → double  — authalic latitude → geodetic
+// (DuckDB extension exposes a GEOMETRY-walking variant; in WASM we bind the
+//  scalar core and let JS callers walk GeoJSON.)
+// ---------------------------------------------------------------------------
+static double igeo7_geo_to_authalic(double phi_deg) {
+    return auth::geodetic_to_authalic(phi_deg);
+}
+
+static double igeo7_authalic_to_geo(double xi_deg) {
+    return auth::authalic_to_geodetic(xi_deg);
+}
+
 // ---------------------------------------------------------------------------
 // Bindings
 // ---------------------------------------------------------------------------
@@ -192,4 +207,6 @@ EMSCRIPTEN_BINDINGS(igeo7_module) {
     emscripten::function("igeo7_first_non_zero", &igeo7_first_non_zero);
     emscripten::function("igeo7_is_valid",       &igeo7_is_valid);
     emscripten::function("igeo7_encode",         &igeo7_encode);
+    emscripten::function("igeo7_geo_to_authalic", &igeo7_geo_to_authalic);
+    emscripten::function("igeo7_authalic_to_geo", &igeo7_authalic_to_geo);
 }
diff --git a/src-ts/webdggrid.ts b/src-ts/webdggrid.ts
index 510567a..c67375a 100644
--- a/src-ts/webdggrid.ts
+++ b/src-ts/webdggrid.ts
@@ -1,6 +1,6 @@
 // @ts-ignore
 import { loadWasm, unloadWasm } from './libdggrid.wasm.js';
-import { Feature, FeatureCollection, GeoJsonProperties, Polygon, Position } from 'geojson';
+import { Feature, FeatureCollection, GeoJSON, GeoJsonProperties, Polygon, Position } from 'geojson';
 
 /**
  * The shape of each cell in the Discrete Global Grid System.
@@ -187,21 +187,31 @@ export interface IDGGSProps {
 
 /**
  * Rewraps a polygon ring that crosses the antimeridian so that all longitudes
- * are in a contiguous range (some may exceed 180°).  This is the format
- * expected by MapLibre GL / Mapbox GL globe projection for antimeridian cells.
- * For renderers that require standard [-180, 180] coordinates, use the raw
- * output from {@link Webdggrid.sequenceNumToGrid} directly.
+ * are in a contiguous range. The output longitudes may fall outside
+ * [-180, 180] — that's intentional, and is the format expected by MapLibre
+ * GL / Mapbox GL globe projection for antimeridian cells. For renderers that
+ * require standard [-180, 180] coordinates, run a final modulo step
+ * downstream.
+ *
+ * Walks consecutive vertices and accumulates a ±360 offset whenever the
+ * longitude delta between neighbours exceeds 180° (the only meaningful sign
+ * of an antimeridian crossing). This keeps the traversal direction faithful
+ * even for polar caps, which span a full 360° in lon and were broken by the
+ * previous "negative-to-positive" rewrite.
  */
 export function unwrapAntimeridianRing(ring: Position[]): Position[] {
-    let minLon = ring[0][0];
-    let maxLon = ring[0][0];
+    if (ring.length === 0) return ring;
+    const out: Position[] = [[ring[0][0], ring[0][1]]];
+    let offset = 0;
     for (let i = 1; i < ring.length; i++) {
-        const lon = ring[i][0];
-        if (lon < minLon) minLon = lon;
-        else if (lon > maxLon) maxLon = lon;
-    }
-    if (maxLon - minLon <= 180) return ring;
-    return ring.map(([lon, lat]) => [lon < 0 ? lon + 360 : lon, lat]);
+        const prev = ring[i - 1][0];
+        const curr = ring[i][0];
+        const delta = curr - prev;
+        if (delta >  180) offset -= 360;
+        else if (delta < -180) offset += 360;
+        out.push([curr + offset, ring[i][1]]);
+    }
+    return out;
 }
 
 const DEFAULT_RESOLUTION = 1;
@@ -778,13 +788,22 @@ export class Webdggrid {
      *   retrieve.
      * @param resolution - Resolution at which the IDs were generated. Defaults
      *   to the instance's current {@link resolution}.
+     * @param unwrap - When `true` (default), antimeridian-crossing rings are
+     *   passed through {@link unwrapAntimeridianRing} so longitudes stay
+     *   contiguous (lons may exceed 180°). Required by MapLibre GL / Mapbox
+     *   GL globe projection. Set to `false` to receive the raw DGGRID output
+     *   in `[-180, 180]` — required by Cesium's `GeoJsonDataSource` (which
+     *   internally normalises lons and breaks polar caps under unwrap), and
+     *   by any sphere-aware renderer that interpolates edges as great-circle
+     *   arcs.
      * @returns A 2-D array: `result[i]` is the vertex ring of `sequenceNum[i]`.
      *   Each vertex is a `[lng, lat]` position.
      * @throws If the WASM module encounters an invalid cell ID.
      */
     sequenceNumToGrid(
         sequenceNum: bigint[],
-        resolution: number = DEFAULT_RESOLUTION
+        resolution: number = DEFAULT_RESOLUTION,
+        unwrap: boolean = true
     ): Position[][] {
         const {
             poleCoordinates: { lat, lng },
@@ -836,7 +855,7 @@ export class Webdggrid {
             for (let j = 0; j < numVertexes; j += 1) {
                 coordinates.push([resultArray[xOffset + j], resultArray[yOffset + j]]);
             }
-            featureSet.push(unwrapAntimeridianRing(coordinates));
+            featureSet.push(unwrap ? unwrapAntimeridianRing(coordinates) : coordinates);
             xOffset += numVertexes;
             yOffset += numVertexes;
         }
@@ -874,15 +893,19 @@ export class Webdggrid {
      * @param sequenceNum - Array of `BigInt` cell IDs to convert.
      * @param resolution - Resolution at which the IDs were generated. Defaults
      *   to the instance's current {@link resolution}.
+     * @param unwrap - Forwarded to {@link sequenceNumToGrid}. Defaults to
+     *   `true` (MapLibre-style unwrap). Pass `false` for Cesium and other
+     *   great-circle-arc renderers.
      * @returns A GeoJSON `FeatureCollection` of `Polygon` features, one per
      *   input cell ID.
      */
     sequenceNumToGridFeatureCollection(
         sequenceNum: bigint[],
-        resolution: number = DEFAULT_RESOLUTION
+        resolution: number = DEFAULT_RESOLUTION,
+        unwrap: boolean = true
     ): FeatureCollection<Polygon, DGGSGeoJsonProperty> {
 
-        const coordinatesArray = this.sequenceNumToGrid(sequenceNum, resolution);
+        const coordinatesArray = this.sequenceNumToGrid(sequenceNum, resolution, unwrap);
 
         const features = coordinatesArray.map((coordinates, index) => {
             const seqNum = sequenceNum[index];
@@ -2593,4 +2616,110 @@ export class Webdggrid {
     igeo7IsValid(index: bigint): boolean {
         return this._module.igeo7_is_valid(index);
     }
+
+    /**
+     * Convert a geodetic latitude (WGS84 ellipsoid) to its authalic latitude
+     * on the equal-area sphere. Implementation follows Karney (2022) — same
+     * polynomial used by the `igeo7_geo_to_authalic` DuckDB scalar function.
+     *
+     * Longitude is unaffected; only latitude is transformed.
+     *
+     * @param latDeg - Geodetic latitude in degrees, range `[-90, 90]`.
+     * @returns Authalic latitude in degrees.
+     */
+    igeo7GeoToAuthalic(latDeg: number): number {
+        return this._module.igeo7_geo_to_authalic(latDeg);
+    }
+
+    /**
+     * Inverse of {@link igeo7GeoToAuthalic} — convert an authalic latitude
+     * back to geodetic.
+     *
+     * @param latDeg - Authalic latitude in degrees.
+     * @returns Geodetic latitude (WGS84) in degrees.
+     */
+    igeo7AuthalicToGeo(latDeg: number): number {
+        return this._module.igeo7_authalic_to_geo(latDeg);
+    }
+
+    /**
+     * Apply {@link igeo7GeoToAuthalic} (or its inverse) to every coordinate of
+     * a GeoJSON geometry, feature, or feature collection. Mirrors the
+     * `igeo7_geo_to_authalic` / `igeo7_authalic_to_geo` DuckDB functions
+     * (which take/return `GEOMETRY`); this is the WASM equivalent for
+     * GeoJSON-shaped inputs.
+     *
+     * The input is **deep-cloned** — the source object is not mutated.
+     * Geometries with `null` or unsupported types are returned unchanged.
+     *
+     * @param input - Any GeoJSON geometry, feature, or feature collection.
+     * @param direction - `'geoToAuthalic'` (default) or `'authalicToGeo'`.
+     * @returns A new GeoJSON object of the same shape with transformed lats.
+     */
+    igeo7TransformGeoJson<T extends GeoJSON>(
+        input: T,
+        direction: 'geoToAuthalic' | 'authalicToGeo' = 'geoToAuthalic',
+    ): T {
+        const fn = direction === 'authalicToGeo'
+            ? (lat: number) => this._module.igeo7_authalic_to_geo(lat)
+            : (lat: number) => this._module.igeo7_geo_to_authalic(lat);
+        return transformGeoJsonLatitudes(input, fn);
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// GeoJSON latitude transform helper (used by igeo7TransformGeoJson)
+// ─────────────────────────────────────────────────────────────────────────────
+
+type Pos = number[];
+
+function transformPos(pos: Pos, fn: (lat: number) => number): Pos {
+    // GeoJSON positions are [lng, lat, ...]; only lat (index 1) is touched,
+    // any z/m values trail through untouched.
+    const out = pos.slice();
+    if (out.length >= 2) out[1] = fn(out[1]);
+    return out;
+}
+
+function transformCoords(coords: any, depth: number, fn: (lat: number) => number): any {
+    if (depth === 0) return transformPos(coords as Pos, fn);
+    return (coords as any[]).map(c => transformCoords(c, depth - 1, fn));
+}
+
+const COORD_DEPTH: Record<string, number> = {
+    Point: 0,
+    LineString: 1,
+    MultiPoint: 1,
+    Polygon: 2,
+    MultiLineString: 2,
+    MultiPolygon: 3,
+};
+
+function transformGeometry(geom: any, fn: (lat: number) => number): any {
+    if (!geom || typeof geom.type !== 'string') return geom;
+    if (geom.type === 'GeometryCollection') {
+        return {
+            ...geom,
+            geometries: (geom.geometries || []).map((g: any) => transformGeometry(g, fn)),
+        };
+    }
+    const depth = COORD_DEPTH[geom.type];
+    if (depth === undefined || !geom.coordinates) return geom;
+    return { ...geom, coordinates: transformCoords(geom.coordinates, depth, fn) };
+}
+
+function transformGeoJsonLatitudes<T>(input: T, fn: (lat: number) => number): T {
+    const node = input as any;
+    if (!node || typeof node.type !== 'string') return input;
+    switch (node.type) {
+        case 'FeatureCollection':
+            return {
+                ...node,
+                features: (node.features || []).map((f: any) => transformGeoJsonLatitudes(f, fn)),
+            } as T;
+        case 'Feature':
+            return { ...node, geometry: transformGeometry(node.geometry, fn) } as T;
+        default:
+            return transformGeometry(node, fn) as T;
+    }
 }
diff --git a/submodules/igeo7_duckdb b/submodules/igeo7_duckdb
index a177dcf..6cc6880 160000
--- a/submodules/igeo7_duckdb
+++ b/submodules/igeo7_duckdb
@@ -1 +1 @@
-Subproject commit a177dcf87ceadcf1bd94f266cbd8736f95eae60d
+Subproject commit 6cc6880b6657a2184a5b6e54866a98f8a9166192
diff --git a/tests/unit/geo.test.ts b/tests/unit/geo.test.ts
index e815664..488eceb 100644
--- a/tests/unit/geo.test.ts
+++ b/tests/unit/geo.test.ts
@@ -49,14 +49,15 @@ describe('test sequenceNumToGrid function', async () => {
     const coords = dggs.sequenceNumToGrid([1n, 2n, 6n, 10n]);
     expect(coords.length).toBe(4);
     expect(coords[0][1].length).toBe(2);
-    expect(coords[3][2][0]).toBe(-22.605417994555836);
+    // Vertex order is DGGRID's native CCW emission. Pinned for regression.
+    expect(coords[3][2][0]).toBe(-66.68514068908306);
   });
 
   test('should return a set of cells for 4 dggids as geojson', () => {
     const featureCollection = dggs.sequenceNumToGridFeatureCollection([1n, 2n, 3n, 10n]);
     expect(featureCollection.features.length).toBe(4);
     expect(featureCollection.features[0].geometry.coordinates[0][1].length).toBe(2);
-    expect(featureCollection.features[3].geometry.coordinates[0][2][0]).toBe(-22.605417994555836);
+    expect(featureCollection.features[3].geometry.coordinates[0][2][0]).toBe(-66.68514068908306);
   });
 
   test('should return a set of cells for 9 dggids as geojson', () => {
diff --git a/tests/unit/igeo7-authalic.test.ts b/tests/unit/igeo7-authalic.test.ts
new file mode 100644
index 0000000..e2e43d0
--- /dev/null
+++ b/tests/unit/igeo7-authalic.test.ts
@@ -0,0 +1,205 @@
+import { describe, test, beforeAll, expect } from 'vitest';
+import type { Feature, FeatureCollection, Point, Polygon, MultiPolygon, GeometryCollection } from 'geojson';
+import { Webdggrid } from '../../lib-esm/webdggrid';
+
+// Reference values from submodules/igeo7_duckdb/test/test_auth.cpp.
+// Tolerance matches the upstream C++ check (1e-7 deg).
+const REFERENCE: Array<[number, number]> = [
+    [-90.0, -90.0],
+    [-45.0, -44.87170287],
+    [0.0, 0.0],
+    [30.0, 29.88899703],
+    [58.39714590, 58.28252559],
+    [60.0, 59.88878556],
+    [89.9999, 89.99989955],
+    [90.0, 90.0],
+];
+
+describe('IGEO7 authalic latitude conversion', () => {
+    let dggs: Webdggrid;
+
+    beforeAll(async () => {
+        dggs = await Webdggrid.load();
+    });
+
+    describe('scalar geo ↔ authalic', () => {
+        test.each(REFERENCE)('geodetic %f° → authalic %f°', (phi, expected) => {
+            expect(dggs.igeo7GeoToAuthalic(phi)).toBeCloseTo(expected, 6);
+        });
+
+        test.each(REFERENCE)('authalic %f° (xi) → geodetic %f° (phi)', (phi, xi) => {
+            expect(dggs.igeo7AuthalicToGeo(xi)).toBeCloseTo(phi, 6);
+        });
+
+        test('round-trip recovers input within 1e-9°', () => {
+            for (const [phi] of REFERENCE) {
+                const xi = dggs.igeo7GeoToAuthalic(phi);
+                const back = dggs.igeo7AuthalicToGeo(xi);
+                expect(Math.abs(back - phi)).toBeLessThan(1e-9);
+            }
+        });
+
+        test('odd symmetry: f(-x) === -f(x)', () => {
+            for (const phi of [10, 30, 45, 60, 75, 89.5]) {
+                expect(dggs.igeo7GeoToAuthalic(-phi)).toBeCloseTo(-dggs.igeo7GeoToAuthalic(phi), 12);
+            }
+        });
+
+        test('poles and equator are fixed points', () => {
+            expect(dggs.igeo7GeoToAuthalic(0)).toBeCloseTo(0, 12);
+            expect(dggs.igeo7GeoToAuthalic(90)).toBeCloseTo(90, 9);
+            expect(dggs.igeo7GeoToAuthalic(-90)).toBeCloseTo(-90, 9);
+            expect(dggs.igeo7AuthalicToGeo(0)).toBeCloseTo(0, 12);
+            expect(dggs.igeo7AuthalicToGeo(90)).toBeCloseTo(90, 9);
+            expect(dggs.igeo7AuthalicToGeo(-90)).toBeCloseTo(-90, 9);
+        });
+    });
+
+    describe('GeoJSON transform (igeo7TransformGeoJson)', () => {
+        test('Point: transforms lat, leaves lng untouched', () => {
+            const point: Point = { type: 'Point', coordinates: [12.5, 45] };
+            const out = dggs.igeo7TransformGeoJson(point);
+            expect(out.type).toBe('Point');
+            expect(out.coordinates[0]).toBe(12.5);
+            expect(out.coordinates[1]).toBeCloseTo(dggs.igeo7GeoToAuthalic(45), 12);
+        });
+
+        test('Point with z/m trailing dimensions: trailing values pass through', () => {
+            const point = { type: 'Point' as const, coordinates: [12.5, 45, 100, 7] };
+            const out = dggs.igeo7TransformGeoJson(point);
+            expect(out.coordinates[0]).toBe(12.5);
+            expect(out.coordinates[1]).toBeCloseTo(dggs.igeo7GeoToAuthalic(45), 12);
+            expect(out.coordinates[2]).toBe(100);
+            expect(out.coordinates[3]).toBe(7);
+        });
+
+        test('Polygon with hole: every ring vertex transformed, hole preserved', () => {
+            const poly: Polygon = {
+                type: 'Polygon',
+                coordinates: [
+                    [[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]],
+                    [[2, 2], [8, 2], [8, 8], [2, 8], [2, 2]],
+                ],
+            };
+            const out = dggs.igeo7TransformGeoJson(poly);
+            expect(out.coordinates.length).toBe(2);
+            expect(out.coordinates[0].length).toBe(5);
+            expect(out.coordinates[1].length).toBe(5);
+            // Spot-check a non-equator vertex
+            expect(out.coordinates[0][2][0]).toBe(10);
+            expect(out.coordinates[0][2][1]).toBeCloseTo(dggs.igeo7GeoToAuthalic(10), 12);
+            // Lat 0 stays at 0
+            expect(out.coordinates[0][0][1]).toBeCloseTo(0, 12);
+        });
+
+        test('MultiPolygon: walks all polygons and rings', () => {
+            const mp: MultiPolygon = {
+                type: 'MultiPolygon',
+                coordinates: [
+                    [[[0, 30], [5, 30], [5, 35], [0, 30]]],
+                    [[[20, -45], [25, -45], [25, -40], [20, -45]]],
+                ],
+            };
+            const out = dggs.igeo7TransformGeoJson(mp);
+            expect(out.coordinates[0][0][0][1]).toBeCloseTo(dggs.igeo7GeoToAuthalic(30), 12);
+            expect(out.coordinates[1][0][0][1]).toBeCloseTo(dggs.igeo7GeoToAuthalic(-45), 12);
+        });
+
+        test('Feature: preserves id and properties, transforms geometry', () => {
+            const feat: Feature<Point> = {
+                type: 'Feature',
+                id: 'cell-42',
+                properties: { name: 'sample', id: 42 },
+                geometry: { type: 'Point', coordinates: [3, 60] },
+            };
+            const out = dggs.igeo7TransformGeoJson(feat);
+            expect(out.id).toBe('cell-42');
+            expect(out.properties).toEqual({ name: 'sample', id: 42 });
+            expect(out.geometry?.coordinates[1]).toBeCloseTo(dggs.igeo7GeoToAuthalic(60), 12);
+        });
+
+        test('FeatureCollection: walks every feature', () => {
+            const fc: FeatureCollection<Point> = {
+                type: 'FeatureCollection',
+                features: [
+                    { type: 'Feature', properties: null, geometry: { type: 'Point', coordinates: [0, 30] } },
+                    { type: 'Feature', properties: null, geometry: { type: 'Point', coordinates: [0, -45] } },
+                ],
+            };
+            const out = dggs.igeo7TransformGeoJson(fc);
+            expect(out.features).toHaveLength(2);
+            expect(out.features[0].geometry?.coordinates[1]).toBeCloseTo(dggs.igeo7GeoToAuthalic(30), 12);
+            expect(out.features[1].geometry?.coordinates[1]).toBeCloseTo(dggs.igeo7GeoToAuthalic(-45), 12);
+        });
+
+        test('GeometryCollection: walks nested geometries', () => {
+            const gc: GeometryCollection = {
+                type: 'GeometryCollection',
+                geometries: [
+                    { type: 'Point', coordinates: [0, 30] },
+                    { type: 'LineString', coordinates: [[0, 0], [10, 45]] },
+                ],
+            };
+            const out = dggs.igeo7TransformGeoJson(gc);
+            expect((out.geometries[0] as Point).coordinates[1])
+                .toBeCloseTo(dggs.igeo7GeoToAuthalic(30), 12);
+            expect((out.geometries[1] as any).coordinates[1][1])
+                .toBeCloseTo(dggs.igeo7GeoToAuthalic(45), 12);
+        });
+
+        test('null geometry on Feature: feature returned, geometry stays null', () => {
+            // The GeoJSON spec allows null geometries on Features even though
+            // @types/geojson types Feature.geometry as Geometry.
+            const feat = {
+                type: 'Feature' as const,
+                properties: { foo: 'bar' },
+                geometry: null,
+            };
+            const out = dggs.igeo7TransformGeoJson(feat as unknown as Feature);
+            expect(out.type).toBe('Feature');
+            expect(out.geometry).toBeNull();
+            expect(out.properties).toEqual({ foo: 'bar' });
+        });
+
+        test('does NOT mutate input', () => {
+            const point: Point = { type: 'Point', coordinates: [12.5, 45] };
+            const snapshot = JSON.stringify(point);
+            dggs.igeo7TransformGeoJson(point);
+            expect(JSON.stringify(point)).toBe(snapshot);
+        });
+
+        test('round-trip on a Feature recovers original within 1e-9°', () => {
+            const fc: FeatureCollection<Polygon> = {
+                type: 'FeatureCollection',
+                features: [{
+                    type: 'Feature',
+                    properties: null,
+                    geometry: {
+                        type: 'Polygon',
+                        coordinates: [[
+                            [-122.4, 37.7],
+                            [-122.3, 37.7],
+                            [-122.3, 37.8],
+                            [-122.4, 37.8],
+                            [-122.4, 37.7],
+                        ]],
+                    },
+                }],
+            };
+            const forward = dggs.igeo7TransformGeoJson(fc, 'geoToAuthalic');
+            const back = dggs.igeo7TransformGeoJson(forward, 'authalicToGeo');
+            const orig = fc.features[0].geometry.coordinates[0];
+            const recovered = back.features[0].geometry.coordinates[0];
+            for (let i = 0; i < orig.length; i++) {
+                expect(recovered[i][0]).toBe(orig[i][0]);          // lng untouched
+                expect(Math.abs(recovered[i][1] - orig[i][1])).toBeLessThan(1e-9);
+            }
+        });
+
+        test('unsupported geometry type passes through unchanged', () => {
+            const weird: any = { type: 'NotAType', coordinates: [[0, 30]] };
+            const out = dggs.igeo7TransformGeoJson(weird);
+            expect(out).toEqual(weird);
+        });
+    });
+});