[myleshorton]

The Unbounded globe drew no marker for the volunteer at all. It plotted only the people being helped, and the camera parked on them — so with a peer in China the view sat between China and Japan, and the screen read as though it were showing the volunteer somewhere they had never been. Reported from a US machine that appeared to be in Japan.

The reference doesn't work that way: every arc runs peer → the volunteer's own looked-up coordinates. That's the piece spark was missing, and the reason the map had no answer to "where am I".

Where the location comes from

The geo service itself. /lookup with no address geolocates the caller (/lookup/<ip> a specific one), so this needs no knowledge of our external address and no STUN round trip — one more path on a host the sharing pool already talks to.

Three deliberate choices about when and whether to ask:

Choice	Why
Only while sharing	Asking where we are is an outbound request that shows the geo service our address. It happens because the user turned the feature on, never because they opened the tab. Dropped when the session ends, so a later start re-resolves instead of pinning us where we used to be.
Off the critical path, in its own task	The sharing loop keeps peer accounting, the tray label and the UI moving. A dead geo host must not delay the first peer join by its timeout. The screen's existing 2s poll picks the answer up.
Cached on success only	The opposite of peer lookups, deliberately. Remembering a failure is right there — it stops a dead host costing a round trip per join — but there is exactly one of these per process, and a transient failure at startup would otherwise leave the volunteer off their own map for the entire session.

On the globe

Arcs run peer → us, with us drawn as a cyan dot a size up from the peers' green, so the two ends of a connection are never confused. The reference draws its own end nearly transparent; ours is solid, because this is precisely the question the screen kept failing to answer.

Two bugs that only surfaced once it was wired

The camera could blank the globe. It averaged latitudes arithmetically and longitudes on the unit circle, separately. For points spread across half the globe — Denver plus peers from Turkey to China — that lands almost anywhere, and it put the aim far enough from our end that every arc failed the limb cull and the globe went empty. It now averages 3D unit vectors (the true spherical centre) and weights our end by the peer count, since our end is one foot of every arc while each peer is one foot of one.

A geo failure blanked it too. The dots were computed from the arcs, so a pending or failed self lookup left a bare sphere while the user was actively helping people. Peers are now drawn whether or not we know where we are; only the arcs wait.

Verification

• spark-sharing: 52 tests pass, including two new ones — that the self lookup passes no address, and that it caches success but retries failure
• tauri-plugin-spark-vpn: 53 tests pass; the payload contract tests now cover origin present and null
• svelte-check 419 files clean; vitest 38 tests; vite build clean
• cargo fmt --check and cargo clippy --all-targets -D warnings clean on all three crates
• Rendered both paths in a browser: normally one arc with a green peer dot and a cyan dot on us; with the self lookup forced to fail, no arcs but all three peers still on the map

Note

The self lookup answers where our traffic appears to come from. With a tunnel up that is the exit, not the desk — inherent to asking a remote service, and true of the reference too. For a volunteer, which is when this runs, there is no tunnel in the way.

🤖 Generated with Claude Code

https://claude.ai/code/session_01P4uMnvGU3dM11aXJbLc9hk

[Copilot]

Pull request overview

Adds “self/origin” geolocation to the Unbounded globe so the volunteer is represented on the map (arcs run peer → volunteer), and adjusts the UI/contract to carry this origin through the Tauri plugin to the Svelte globe renderer.

Changes:

• Extend GeoResolver to support “lookup caller” (None IP) and add resolve_own() with success-only caching semantics.
• Add origin to the spark://unbounded snapshot payload and plumb it through the backend types and Unbounded page into the globe component.
• Update the globe rendering logic to draw peers even when origin is missing and to reframe the camera using a spherical/vector mean including the origin.

Reviewed changes

Copilot reviewed 6 out of 6 changed files in this pull request and generated 1 comment.

Show a summary per file

File	Description
spark-sharing/src/geo.rs	Adds resolve_own() and updates fetch path handling to support /lookup (caller geolocation).
gui-tauri/tauri-plugin-spark-vpn/src/unbounded.rs	Stores origin in plugin state, includes it in snapshot/status payloads, and spawns origin lookup during sharing.
gui-tauri/src/routes/unbounded/+page.svelte	Initializes status.origin and passes it into <Globe>.
gui-tauri/src/lib/spark_backend.ts	Extends the UnboundedStatus contract with origin and updates the mock backend behavior.
gui-tauri/src/lib/spark_backend.test.ts	Updates mock-backend unbounded test expectations to include origin: null.
gui-tauri/src/lib/Globe.svelte	Renders a distinct “own” dot and draws arcs peer → origin; updates camera framing logic.

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.

[coderabbitai]

Warning

Review limit reached

@myleshorton, you've reached your PR review limit, so we couldn't start this review.

Next review available in: 43 minutes

Limit details: You’ve used the included review currently available.

You've used all free OSS reviews for now. Wait for the free limit to reset to keep reviewing this public repository.

How can I continue?

Wait for the limit to reset, then comment @coderabbitai review or push new commits to the PR.

An organization admin can change what happens after included review limits in Billing.

How do review limits work?

CodeRabbit enforces per-developer PR review limits within each organization.

For paid Pro and Pro+ reviews, CodeRabbit uses a developer's included PR review attempts over the past 7 days to set the current hourly allowance. At typical activity levels, the full plan allowance applies. Higher sustained activity can lower the allowance until earlier attempts leave the 7-day window.

Please refer docs for additional details.

Review details

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro Plus

Run ID: ac65d53d-6f23-4860-8407-9e1d8061b02a

📥 Commits

Reviewing files that changed from the base of the PR and between 7804547 and 3e5f2da.

📒 Files selected for processing (6)

• gui-tauri/src/lib/Globe.svelte
• gui-tauri/src/lib/spark_backend.test.ts
• gui-tauri/src/lib/spark_backend.ts
• gui-tauri/src/routes/unbounded/+page.svelte
• gui-tauri/tauri-plugin-spark-vpn/src/unbounded.rs
• spark-sharing/src/geo.rs

✨ Finishing Touches

📝 Generate docstrings

• Create stacked PR
• Commit on current branch

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch fisk/unbounded-own-location

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[Copilot]

Pull request overview

Copilot reviewed 6 out of 6 changed files in this pull request and generated no new comments.

Suppressed comments (2)

Previously missed (1) — in code that hasn't changed since the last review.

gui-tauri/src/lib/Globe.svelte:48

• origin can arrive after the initial peer set (async geo lookup), but this component only re-runs its reactive work on peers changes. If the backend returns the same peers array instance across polls/events, origin updates won’t trigger layoutArcs() / parkCamera(), so the volunteer dot and peer→origin arcs can remain missing until an unrelated camera/peer change.

This issue also appears on line 172 of the same file.

  let {
    peers = [],
    origin = null,
  }: {
    peers: UnboundedPeer[];

gui-tauri/src/lib/Globe.svelte:176

• layoutArcs() returns early when arcs.length === 0, which prevents rendering the volunteer’s own dot when sharing is on but there are no peers yet (or no peers with geo). Since the goal is to show “where am I”, the origin dot should be able to render even with zero arcs.

  function layoutArcs() {
    if (!globe || !el || arcs.length === 0) {
      paths = [];
      peerDots = [];
      ownDot = null;

[Copilot]

Pull request overview

Copilot reviewed 6 out of 6 changed files in this pull request and generated 1 comment.

Suppressed comments (1)

gui-tauri/src/lib/Globe.svelte:387

• parkCamera's doc comment still refers to framing HOME and mentions HOME being pushed to the limb, but the implementation now frames peers plus the resolved origin using a 3D vector mean. Updating the comment will prevent confusion about what the camera is actually targeting and why.

  function parkCamera(animateMs: number) {
    if (!globe || arcs.length === 0) return;
    // The origin is part of the signature: it arrives AFTER the first peers (a network round trip),
    // and the camera has to re-frame when it does or our end stays off the visible face.
    const sig = [...arcs.map((a) => a.id), origin ? `${origin.lat},${origin.lon}` : "-"].join("|");
    if (sig === parkedOn) return;

[Copilot]

Pull request overview

Copilot reviewed 6 out of 6 changed files in this pull request and generated no new comments.

Suppressed comments (2)

Previously missed (2) — in code that hasn't changed since the last review.

gui-tauri/src/lib/Globe.svelte:238

• layoutArcs() returns early when arcs.length === 0, which prevents drawing the volunteer’s own dot even when origin is already resolved (e.g. sharing is on but no peers yet, or peers exist but are temporarily geo-less). Since ownDot is derived from origin, this early return makes the “where am I” marker disappear unless at least one arc exists.

  function layoutArcs() {
    if (!globe || !el || arcs.length === 0) {
      paths = [];
      peerDots = [];
      ownDot = null;
      return;

gui-tauri/src/lib/Globe.svelte:273

• This comment says that with “no origin … the arc is still emitted, just not drawable”, but the code immediately does if (!far) continue;, which omits the arc path entirely until origin exists. This mismatch makes the culling logic harder to reason about (especially now that ArcPath.visible is used to keep DOM elements alive for animations).

      // Both feet have to be on the face — an arc with one foot past the limb draws as a hairpin off
      // the edge — so no origin, or an origin round the back, means dots without arcs. The arc is
      // still emitted, just not drawable: see `ArcPath.visible`.
      if (!far) continue;

[Copilot]

Pull request overview

Copilot reviewed 6 out of 6 changed files in this pull request and generated 2 comments.

Suppressed comments (1)

gui-tauri/src/lib/Globe.svelte:335

• This in-function comment refers to ARC_LIFT, but the constant being applied is ARC_RIDE (and no ARC_LIFT exists). That mismatch makes the explanation hard to follow when revisiting this math.

      // Lifted by `ARC_LIFT` radii. Perspective does most of the work: a point this far out is much
      // closer to the camera than the surface is, so a modest angular offset from the view axis
      // projects a long way from the disc's centre — which is how the reference's crest reaches ~1.15
      // radii while both feet sit inside half a radius of the middle.

[Copilot]

Pull request overview

Copilot reviewed 6 out of 6 changed files in this pull request and generated no new comments.

Suppressed comments (1)

Previously missed (1) — in code that hasn't changed since the last review.

gui-tauri/src/lib/Globe.svelte:281

• layoutArcs() bails out when arcs.length === 0, which prevents projecting ownDot even when origin is already resolved. This means the volunteer marker can disappear whenever there are no peers with geo (including the common “sharing on but no peers yet” state). Remove the arcs.length === 0 guard so the origin dot can still be drawn.

    if (!globe || !el || arcs.length === 0) {
      paths = [];
      peerDots = [];
      ownDot = null;
      return;