1.29.1

Reviewed-on: #81

.agents/skills/ember-best-practices/SKILL.md

@@ -149,7 +149,7 @@ Each rule file contains:
 Ember has excellent accessibility support through community addons:
 
 - **ember-a11y-testing** - Automated accessibility testing in your test suite
-- **ember-a11y** - Route announcements and focus management
+- **ember-a11y-refocus** - Route announcements and focus management
 - **ember-focus-trap** - Focus trapping for modals and dialogs
 - **ember-page-title** - Accessible page title management
 - **Platform-native validation** - Use browser's Constraint Validation API for accessible form validation

.agents/skills/ember-best-practices/rules/a11y-automated-testing.md

@@ -69,6 +69,14 @@ import { setupGlobalA11yHooks } from 'ember-a11y-testing/test-support';
 setupGlobalA11yHooks(); // Runs on every test automatically
 ```
 
+### Leave All Rules Enabled
+
+Keep the default ember-a11y-testing and axe-core rules turned on. Avoid disabling rules globally or excluding specific rules to bypass failures without a documented remediation plan.
+
+When teams suppress accessibility rules without a time-boxed remediation plan, they hide real defects, accumulate technical debt, and make regressions harder to detect. A skipped rule can allow a serious accessibility defect to ship to production, especially for problems involving forms, keyboard access, focus management, semantics, or ARIA usage.
+
+If you must suppress a rule temporarily, treat it as an exception: document why it is needed, scope it as narrowly as possible, and create follow-up work to restore the rule quickly.
+
 ember-a11y-testing catches issues like missing labels, insufficient color contrast, invalid ARIA, and keyboard navigation problems automatically.
 
 Reference: [ember-a11y-testing](https://github.com/ember-a11y/ember-a11y-testing)

.agents/skills/ember-best-practices/rules/a11y-form-labels.md

@@ -35,9 +35,7 @@ All form inputs must have associated labels, and validation errors should be ann
     <div>
       <label for="email-input">
         Email Address
-        {{#if this.isEmailRequired}}
+        <span aria-hidden="true">*</span>
-          <span aria-label="required">*</span>
-        {{/if}}
       </label>
 
       <input

.agents/skills/ember-best-practices/rules/a11y-route-announcements.md

@@ -19,49 +19,86 @@ export default class Router extends EmberRouter {
 }
 ```
 
-**Correct (using a11y-announcer library - recommended):**
+**Correct (using ember-a11y-refocus library - recommended):**
 
-Use the [a11y-announcer](https://github.com/ember-a11y/a11y-announcer) library for robust route announcements:
+Use the [ember-a11y-refocus](https://github.com/ember-a11y/ember-a11y-refocus) library for robust route announcements, route transition focus management, and a bypass block (aka skip link).
 
 ```bash
-ember install @ember-a11y/a11y-announcer
+pnpm add ember-a11y-refocus
 ```
 
-```javascript
+Or with npm:
-// app/router.js
-import EmberRouter from '@ember/routing/router';
-import config from './config/environment';
 
-export default class Router extends EmberRouter {
+```bash
-  location = config.locationType;
+npm install ember-a11y-refocus
-  rootURL = config.rootURL;
-}
-
-Router.map(function () {
-  this.route('about');
-  this.route('dashboard');
-  this.route('posts', function () {
-    this.route('post', { path: '/:post_id' });
-  });
-});
 ```
 
-The a11y-announcer library automatically handles route announcements. For custom announcements in your routes:
+Use the addon by rendering `NavigationNarrator` in your application layout and ensuring your primary content has `id="main"`.
+
+```handlebars
+{{! app/templates/application.hbs }}
+<header>
+  <NavigationNarrator />
+  {{! other header content }}
+</header>
+
+<main id='main'>
+  {{outlet}}
+</main>
+```
+
+If you are using GJS or GTS, import the component directly:
+
+```glimmer-js
+import { NavigationNarrator } from 'ember-a11y-refocus';
+
+<template>
+  <header>
+    <NavigationNarrator />
+  </header>
+
+  <main id="main">
+    {{outlet}}
+  </main>
+</template>
+```
+
+The addon ships minimal styles for the skip link and navigation message:
 
 ```javascript
-// app/routes/dashboard.js
+// app/app.js or app/app.ts
-import Route from '@ember/routing/route';
+import 'ember-a11y-refocus/styles/navigation-narrator.css';
-import { service } from '@ember/service';
+```
 
-export default class DashboardRoute extends Route {
+If you need to customize which transitions count as a route change, pass a validator function to `NavigationNarrator`:
-  @service announcer;
 
-  afterModel() {
+```javascript
-    this.announcer.announce('Loaded dashboard with latest data');
+// app/controllers/application.js
+import Controller from '@ember/controller';
+import { defaultValidator } from 'ember-a11y-refocus';
+
+export default class ApplicationController extends Controller {
+  myCustomValidator(transition) {
+    if (transition.from?.name === 'special') {
+      return false;
+    }
+
+    return defaultValidator(transition);
   }
 }
 ```
 
+```handlebars
+{{! app/templates/application.hbs }}
+<header>
+  <NavigationNarrator @routeChangeValidator={{this.myCustomValidator}} />
+</header>
+
+<main id='main'>
+  {{outlet}}
+</main>
+```
+
 **Alternative: DIY approach with ARIA live regions:**
 
 If you prefer not to use a library, you can implement route announcements yourself:
@@ -150,25 +187,6 @@ export default class ApplicationRoute extends Route {
 }
 ```
 
-**Alternative: Use ember-page-title with announcements:**
-
-```bash
-ember install ember-page-title
-```
-
-```glimmer-js
-// app/routes/dashboard.gjs
-import { pageTitle } from 'ember-page-title';
-
-<template>
-  {{pageTitle "Dashboard"}}
-
-  <div class="dashboard">
-    {{outlet}}
-  </div>
-</template>
-```
-
 Route announcements ensure screen reader users know when navigation occurs, improving the overall accessibility experience.
 
 Reference: [Ember Accessibility - Page Titles](https://guides.emberjs.com/release/accessibility/page-template-considerations/)

.agents/skills/ember-best-practices/rules/route-model-caching.md

@@ -11,8 +11,8 @@ Implement intelligent model caching strategies to reduce redundant API calls and
 
 **Incorrect (always fetches fresh data):**
 
-```glimmer-js
+```javascript
-// app/routes/post.gjs
+// app/routes/post.js
 import Route from '@ember/routing/route';
 import { service } from '@ember/service';
 
@@ -23,21 +23,24 @@ export default class PostRoute extends Route {
     // Always makes API call, even if we just loaded this post
     return this.store.request({ url: `/posts/${params.post_id}` });
   }
+}
+```
 
-  <template>
+```glimmer-js
+// app/templates/post.gjs
+<template>
   <article>
     <h1>{{@model.title}}</h1>
     <div>{{@model.content}}</div>
   </article>
   {{outlet}}
-  </template>
+</template>
-}
 ```
 
 **Correct (with smart caching):**
 
-```glimmer-js
+```javascript
-// app/routes/post.gjs
+// app/routes/post.js
 import Route from '@ember/routing/route';
 import { service } from '@ember/service';
 
@@ -68,15 +71,18 @@ export default class PostRoute extends Route {
     const fiveMinutes = 5 * 60 * 1000;
     return Date.now() - cacheTime < fiveMinutes;
   }
+}
+```
 
-  <template>
+```glimmer-js
+// app/templates/post.gjs
+<template>
   <article>
     <h1>{{@model.title}}</h1>
     <div>{{@model.content}}</div>
   </article>
   {{outlet}}
-  </template>
+</template>
-}
 ```
 
 **Service-based caching layer:**
@@ -123,8 +129,8 @@ export default class PostCacheService extends Service {
 }
 ```
 
-```glimmer-js
+```javascript
-// app/routes/post.gjs
+// app/routes/post.js
 import Route from '@ember/routing/route';
 import { service } from '@ember/service';
 
@@ -141,21 +147,24 @@ export default class PostRoute extends Route {
     const params = this.paramsFor('post');
     await this.postCache.getPost(params.post_id, { forceRefresh: true });
   }
+}
+```
 
-  <template>
+```glimmer-js
+// app/templates/post.gjs
+<template>
   <article>
     <h1>{{@model.title}}</h1>
     <div>{{@model.content}}</div>
   </article>
   {{outlet}}
-  </template>
+</template>
-}
 ```
 
 **Using query params for cache control:**
 
-```glimmer-js
+```javascript
-// app/routes/posts.gjs
+// app/routes/posts.js
 import Route from '@ember/routing/route';
 import { service } from '@ember/service';
 
@@ -174,8 +183,12 @@ export default class PostsRoute extends Route {
       options,
     });
   }
+}
+```
 
-  <template>
+```glimmer-js
+// app/templates/posts.gjs
+<template>
   <div class="posts">
     <button {{on "click" (fn this.refresh)}}>
       Refresh
@@ -188,14 +201,13 @@ export default class PostsRoute extends Route {
     </ul>
   </div>
   {{outlet}}
-  </template>
+</template>
-}
 ```
 
 **Background refresh pattern:**
 
-```glimmer-js
+```javascript
-// app/routes/dashboard.gjs
+// app/routes/dashboard.js
 import Route from '@ember/routing/route';
 import { service } from '@ember/service';
 
@@ -214,15 +226,18 @@ export default class DashboardRoute extends Route {
 
     return cached || this.store.request({ url: '/dashboard' });
   }
+}
+```
 
-  <template>
+```glimmer-js
+// app/templates/dashboard.gjs
+<template>
   <div class="dashboard">
     <h1>Dashboard</h1>
     <div>Stats: {{@model.stats}}</div>
   </div>
   {{outlet}}
-  </template>
+</template>
-}
 ```
 
 Smart caching reduces server load, improves perceived performance, and provides better offline support while keeping data fresh.

.agents/skills/ember-best-practices/rules/route-templates.md

@@ -1,38 +1,15 @@
 ---
-title: Use Route Templates with Co-located Syntax
+title: Use Separate Route and Template Files
 impact: MEDIUM-HIGH
 impactDescription: Better code organization and maintainability
-tags: routes, templates, gjs, co-location
+tags: routes, templates, gjs, file-conventions
 ---
 
-## Use Route Templates with Co-located Syntax
+## Use Separate Route and Template Files
 
-Use co-located route templates with modern gjs syntax for better organization and maintainability.
+Keep route logic in `app/routes/*.js` and route templates in `app/templates/*.gjs`. Route classes imported from `@ember/routing/route` do not support inline `<template>` blocks.
 
-**Incorrect (separate template file - old pattern):**
+**Incorrect (inline template inside a route class):**
-
-```glimmer-js
-// app/routes/posts.js (separate file)
-import Route from '@ember/routing/route';
-
-export default class PostsRoute extends Route {
-  model() {
-    return this.store.request({ url: '/posts' });
-  }
-}
-
-// app/templates/posts.gjs (separate template file)
-<template>
-  <h1>Posts</h1>
-  <ul>
-    {{#each @model as |post|}}
-      <li>{{post.title}}</li>
-    {{/each}}
-  </ul>
-</template>
-```
-
-**Correct (co-located route template):**
 
 ```glimmer-js
 // app/routes/posts.gjs
@@ -56,10 +33,37 @@ export default class PostsRoute extends Route {
 }
 ```
 
-**With loading and error states:**
+**Correct (separate route module and template file):**
+
+```javascript
+// app/routes/posts.js
+import Route from '@ember/routing/route';
+
+export default class PostsRoute extends Route {
+  model() {
+    return this.store.request({ url: '/posts' });
+  }
+}
+```
 
 ```glimmer-js
-// app/routes/posts.gjs
+// app/templates/posts.gjs
+<template>
+  <h1>Posts</h1>
+  <ul>
+    {{#each @model as |post|}}
+      <li>{{post.title}}</li>
+    {{/each}}
+  </ul>
+
+  {{outlet}}
+</template>
+```
+
+**With a separate template file for route UI:**
+
+```javascript
+// app/routes/posts.js
 import Route from '@ember/routing/route';
 import { service } from '@ember/service';
 
@@ -69,8 +73,12 @@ export default class PostsRoute extends Route {
   model() {
     return this.store.request({ url: '/posts' });
   }
+}
+```
 
-  <template>
+```glimmer-js
+// app/templates/posts.gjs
+<template>
   <div class="posts-page">
     <h1>Posts</h1>
 
@@ -84,14 +92,13 @@ export default class PostsRoute extends Route {
 
     {{outlet}}
   </div>
-  </template>
+</template>
-}
 ```
 
 **Template-only routes:**
 
 ```glimmer-js
-// app/routes/about.gjs
+// app/templates/about.gjs
 <template>
   <div class="about-page">
     <h1>About Us</h1>
@@ -100,6 +107,6 @@ export default class PostsRoute extends Route {
 </template>
 ```
 
-Co-located route templates keep route logic and presentation together, making the codebase easier to navigate and maintain.
+Keeping route classes and route templates in their conventional files matches Ember's supported routing model and makes examples easier to apply in real apps.
 
 Reference: [Ember Routes](https://guides.emberjs.com/release/routing/)

.agents/skills/nostr-zap-integration/SKILL.md

@@ -0,0 +1,279 @@
+---
+name: nostr-zap-integration
+description: Implement or debug NIP-57 zaps or NIP-61 nutzaps when the task involves zap requests, receipts, LNURL-pay, zap splits, Cashu tokens, or recipient payment configuration.
+---
+
+# Nostr Zap Integration
+
+## Overview
+
+Build correct Lightning Zap and Nutzap flows for Nostr applications. This skill
+covers the full NIP-57 lifecycle (LNURL discovery, zap request construction,
+invoice handling, zap receipt validation) and the NIP-61 Cashu alternative
+(nutzap configuration, P2PK token minting, nutzap publishing and redemption).
+
+## When to Use
+
+- The task involves NIP-57 zaps or NIP-61 nutzaps in a Nostr application.
+- The user needs zap requests, receipts, LNURL-pay integration, zap splits, recipient config, or Cashu token flow tied to Nostr events.
+- The problem is payment interoperability between Nostr and Lightning/Cashu, not general wallet construction.
+- The request is about end-to-end zap behavior or zap validation.
+
+**Do NOT use when:**
+
+- The task is generic Lightning, LNURL, or Cashu work with no Nostr zap context.
+- The work is relay protocol or general Nostr event creation.
+- The request is bech32 encoding or other peripheral concerns unrelated to zap flows.
+
+
+## Response format
+
+Always structure the final response with these top-level sections, in this order:
+
+1. **Summary** — state the task, scope, and main conclusion in 1-3 sentences.
+2. **Decision / Approach** — state the key classification, assumptions, or chosen path.
+3. **Artifacts** — provide the primary deliverable(s) for this skill. Use clear subheadings for multiple files, commands, JSON payloads, queries, or documents.
+4. **Validation** — state checks performed, important risks, caveats, or unresolved questions.
+5. **Next steps** — list concrete follow-up actions, or write `None` if nothing remains.
+
+Rules:
+- Do not omit a section; write `None` when a section does not apply.
+- If files are produced, list each file path under **Artifacts** before its contents.
+- If commands, JSON, SQL, YAML, or code are produced, put each artifact in fenced code blocks with the correct language tag when possible.
+- Keep section names exactly as written above so output stays predictable across skills.
+
+## Workflow
+
+### 1. Determine the Payment Path
+
+Ask: "Is this a Lightning Zap (NIP-57) or a Nutzap (NIP-61)?"
+
+| Path           | When to Use                             | Key Kinds   |
+| -------------- | --------------------------------------- | ----------- |
+| Lightning Zap  | Recipient has lud16/lud06, LNURL server | 9734, 9735  |
+| Nutzap (Cashu) | Recipient has kind:10019, trusted mints | 10019, 9321 |
+
+If unsure, check the recipient's profile (kind:0) for `lud16`/`lud06` fields
+(Lightning path) or query for their kind:10019 event (Nutzap path).
+
+### 2. Lightning Zap Flow (NIP-57)
+
+Follow the steps in [references/zap-flow.md](references/zap-flow.md) for the
+complete implementation. Summary:
+
+#### Step 2a: Discover the LNURL Endpoint
+
+```typescript
+// From lud16 (e.g., "bob@example.com")
+const [name, domain] = lud16.split("@");
+const url = `https://${domain}/.well-known/lnurlp/${name}`;
+const res = await fetch(url);
+const lnurlPayData = await res.json();
+
+// Verify Nostr support
+if (!lnurlPayData.allowsNostr || !lnurlPayData.nostrPubkey) {
+  throw new Error("Recipient does not support Nostr zaps");
+}
+```
+
+**Critical checks on the LNURL response:**
+
+- `allowsNostr` MUST be `true`
+- `nostrPubkey` MUST be a valid 32-byte hex public key
+- Save `callback`, `minSendable`, `maxSendable` for later use
+
+#### Step 2b: Construct the Zap Request (kind:9734)
+
+```json
+{
+  "kind": 9734,
+  "content": "Optional zap comment",
+  "tags": [
+    ["relays", "wss://relay1.example.com", "wss://relay2.example.com"],
+    ["amount", "21000"],
+    ["lnurl", "lnurl1dp68gurn8ghj7..."],
+    ["p", "<recipient-pubkey-hex>"],
+    ["e", "<event-id-hex>"],
+    ["k", "<event-kind-string>"]
+  ]
+}
+```
+
+**Required tags:** `relays` (list of relay URLs), `p` (recipient pubkey).
+**Recommended tags:** `amount` (millisats as string), `lnurl` (bech32-encoded).
+**Optional tags:** `e` (event being zapped), `a` (addressable event coordinate),
+`k` (kind of zapped event as string).
+
+**Critical:** The zap request is NOT published to relays. It is sent to the
+LNURL callback URL.
+
+#### Step 2c: Send to Callback and Get Invoice
+
+```typescript
+const zapRequestEncoded = encodeURIComponent(JSON.stringify(signedZapRequest));
+const url =
+  `${callback}?amount=${amountMsats}&nostr=${zapRequestEncoded}&lnurl=${lnurlBech32}`;
+const { pr: invoice } = await fetch(url).then((r) => r.json());
+```
+
+#### Step 2d: Pay the Invoice
+
+Pass the bolt11 invoice to a Lightning wallet for payment. After payment, the
+recipient's LNURL server creates and publishes the zap receipt (kind:9735).
+
+#### Step 2e: Validate Zap Receipts
+
+See [references/zap-flow.md](references/zap-flow.md) for full validation logic.
+The three critical checks:
+
+1. Receipt `pubkey` MUST match the recipient's LNURL `nostrPubkey`
+2. Invoice amount in `bolt11` tag MUST match `amount` in the zap request
+3. `SHA256(description)` SHOULD match the bolt11 description hash
+
+### 3. Nutzap Flow (NIP-61)
+
+Follow the steps in [references/nutzap-flow.md](references/nutzap-flow.md) for
+the complete implementation. Summary:
+
+#### Step 3a: Fetch Recipient's Nutzap Configuration (kind:10019)
+
+```json
+{
+  "kind": 10019,
+  "tags": [
+    ["relay", "wss://relay1.example.com"],
+    ["relay", "wss://relay2.example.com"],
+    ["mint", "https://mint.example.com", "sat"],
+    ["mint", "https://othermint.example.com", "usd", "sat"],
+    ["pubkey", "<p2pk-pubkey-hex>"]
+  ]
+}
+```
+
+**Critical:** The `pubkey` tag value MUST NOT be the user's main Nostr pubkey.
+It is a separate key used exclusively for P2PK locking.
+
+#### Step 3b: Mint P2PK-Locked Tokens
+
+1. Choose a mint from the recipient's `mint` tags
+2. Mint or swap tokens P2PK-locked to the recipient's `pubkey` value
+3. Prefix the pubkey with `"02"` for nostr-cashu compatibility
+4. Include DLEQ proofs (NUT-12)
+
+#### Step 3c: Publish the Nutzap (kind:9321)
+
+```json
+{
+  "kind": 9321,
+  "content": "Optional comment",
+  "tags": [
+    ["proof", "<cashu-proof-json>"],
+    ["unit", "sat"],
+    ["u", "https://mint.example.com"],
+    ["e", "<zapped-event-id>", "<relay-hint>"],
+    ["k", "<zapped-event-kind>"],
+    ["p", "<recipient-nostr-pubkey>"]
+  ]
+}
+```
+
+Publish to the relays listed in the recipient's kind:10019 `relay` tags.
+
+#### Step 3d: Receiving Nutzaps
+
+Recipients query for kind:9321 events p-tagging them, filtered by trusted mint
+URLs (`#u`). Upon receiving, swap the tokens into their wallet and publish a
+kind:7376 redemption event.
+
+### 4. Zap Splits
+
+When an event has `zap` tags, distribute the zap across recipients:
+
+```json
+["zap", "<pubkey>", "<relay>", "<weight>"]
+```
+
+Weights are relative. Calculate percentages:
+
+```typescript
+const totalWeight = zapTags.reduce((sum, t) => sum + Number(t[3] || 0), 0);
+for (const tag of zapTags) {
+  const weight = Number(tag[3] || 0);
+  const pct = weight / totalWeight;
+  const recipientAmount = Math.floor(totalAmount * pct);
+  // Create separate zap request for each recipient
+}
+```
+
+Recipients without a weight value get weight 0 (no zap). If no weights are
+present on any tag, divide equally.
+
+## Checklist
+
+- [ ] Identified payment path (Lightning vs Nutzap)
+- [ ] For Lightning: LNURL endpoint discovered and verified (`allowsNostr`,
+      `nostrPubkey`)
+- [ ] For Lightning: Zap request (kind:9734) has required tags (`relays`, `p`)
+- [ ] For Lightning: Zap request sent to callback URL, NOT published to relays
+- [ ] For Lightning: Amount in millisats, within `minSendable`/`maxSendable`
+- [ ] For Lightning: Zap receipt validation checks all three criteria
+- [ ] For Nutzap: Recipient's kind:10019 fetched and parsed
+- [ ] For Nutzap: Tokens minted at one of recipient's listed mints
+- [ ] For Nutzap: P2PK pubkey prefixed with "02" and is NOT the main Nostr key
+- [ ] For Nutzap: kind:9321 published to recipient's specified relays
+- [ ] For splits: Weights calculated correctly, separate zap per recipient
+
+## Common Mistakes
+
+| Mistake                                  | Why It Breaks                                            | Fix                                                    |
+| ---------------------------------------- | -------------------------------------------------------- | ------------------------------------------------------ |
+| Publishing kind:9734 to relays           | Zap requests are sent to LNURL callback, never published | Send via HTTP GET to callback URL                      |
+| Amount in satoshis instead of millisats  | NIP-57 uses millisats (1 sat = 1000 msats)               | Multiply sats by 1000 for the `amount` tag             |
+| Using recipient's Nostr pubkey for P2PK  | NIP-61 requires a SEPARATE key for P2PK locking          | Use the `pubkey` from kind:10019, never the main key   |
+| Missing `relays` tag on zap request      | LNURL server won't know where to publish the receipt     | Always include at least one relay in `relays` tag      |
+| Not validating receipt pubkey            | Fake zap receipts from wrong keys accepted               | Receipt pubkey MUST match LNURL `nostrPubkey`          |
+| Sending nutzap to unlisted mint          | Recipient may never see it; tokens could be lost         | Only use mints from recipient's kind:10019 `mint` tags |
+| Missing "02" prefix on P2PK pubkey       | Cashu P2PK expects compressed pubkey format              | Always prefix with "02" for nostr-cashu compat         |
+| Not checking `allowsNostr` on LNURL      | Server may not support Nostr zaps at all                 | Verify `allowsNostr: true` before constructing zap     |
+| Treating zap receipt as proof of payment | Receipts can be forged by rogue LNURL servers            | Trust the receipt author, not the receipt itself       |
+
+## Quick Reference
+
+| Operation     | Kind  | Key Tags                               | Published?            |
+| ------------- | ----- | -------------------------------------- | --------------------- |
+| Zap request   | 9734  | `relays`, `p`, `amount`, `lnurl`, `e`  | NO (HTTP only)        |
+| Zap receipt   | 9735  | `p`, `P`, `bolt11`, `description`, `e` | YES (by LNURL server) |
+| Nutzap config | 10019 | `relay`, `mint`, `pubkey`              | YES (replaceable)     |
+| Nutzap send   | 9321  | `proof`, `u`, `unit`, `p`, `e`         | YES                   |
+| Nutzap redeem | 7376  | `e` (9321 ref), `p` (sender)           | YES (encrypted)       |
+
+## Key Principles
+
+1. **Zap requests are HTTP-only** — Kind:9734 events are NEVER published to
+   relays. They are signed, JSON-encoded, URI-encoded, and sent as a query
+   parameter to the LNURL callback URL. This is the most common mistake.
+
+2. **Validate the full chain** — A valid zap receipt requires matching the
+   receipt pubkey to the LNURL `nostrPubkey`, matching the invoice amount to the
+   request amount, and verifying the description hash. Skipping any check allows
+   forged zaps.
+
+3. **Nutzap keys are separate** — The P2PK pubkey in kind:10019 MUST be a
+   different key from the user's main Nostr identity key. Using the same key
+   would allow anyone to spend received tokens. Always prefix with "02".
+
+4. **Amounts are in millisatoshis** — NIP-57 uses millisats everywhere (1 sat =
+   1000 msats). The `amount` tag, `minSendable`, `maxSendable`, and invoice
+   amounts are all in millisats.
+
+5. **Trust boundaries matter** — Zap receipts are NOT cryptographic proofs of
+   payment. They prove that a LNURL server claims payment was received. The
+   trust is in the LNURL server operator, not in the protocol itself.
+
+## Optimization Notes
+
+- Preserve the user's requested output shape exactly and do not substitute generic advice for concrete artifacts.
+- Include exact commands, code structures, protocol fields, tags, parameters, file paths, or deliverable sections when the task asks for them.
+- Make safety gates explicit before irreversible, destructive, externally visible, or compliance-sensitive actions.
+- For multi-step work, present steps in execution order and include validation or rollback checks where relevant.
+- Avoid overfitting to a single eval example: express lessons as reusable rules, not as task-specific answers.

.agents/skills/nostr-zap-integration/evals/evals.json

@@ -0,0 +1,56 @@
+{
+  "skill_name": "nostr-zap-integration",
+  "evals": [
+    {
+      "id": 1,
+      "name": "send-lightning-zap",
+      "prompt": "I'm building a Nostr client and need to implement sending a zap to a user. The recipient's profile has lud16 set to 'alice@getalby.com'. I want to zap 21 sats on their latest note (event id: 'abc123def456...', kind 1). My pubkey is '97c70a44366a6535c145b333f973ea86dfdc2d7a99da618c40c64705ad98e322' and the recipient's pubkey is '32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245'. Show me the complete implementation including LNURL discovery, zap request construction, and sending to the callback.",
+      "expected_output": "A complete implementation showing: LNURL endpoint discovery from lud16, verification of allowsNostr and nostrPubkey, construction of a kind:9734 zap request with correct tags (relays, amount in millisats, p, e, lnurl), sending the signed event to the callback URL as a query parameter (NOT publishing to relays), and receiving the bolt11 invoice.",
+      "files": [],
+      "assertions": [
+        "Output contains 'kind: 9734' or 'kind:9734' or '9734' for the zap request event",
+        "Output contains 'allowsNostr' to check that the LNURL endpoint supports Nostr zaps",
+        "Output contains 'nostrPubkey' to verify the LNURL endpoint's signing key",
+        "Output contains '21000' (21 sats converted to millisats) in the amount tag",
+        "Output sends the zap request to the 'callback' URL (not publishing to relays)",
+        "The zap request event tags array has a 'relays' entry with relay URLs",
+        "Output sends zap request via HTTP GET to the callback URL with query parameters",
+        "Output constructs the LNURL discovery URL using '.well-known/lnurlp'"
+      ]
+    },
+    {
+      "id": 2,
+      "name": "validate-zap-receipts",
+      "prompt": "I need to implement zap receipt validation for my Nostr client. When I fetch kind:9735 events, I need to verify they are legitimate. Write me a validation function that takes a zap receipt event and the expected LNURL nostrPubkey, and returns whether the zap is valid along with any errors. Cover all the validation checks from NIP-57 including pubkey matching, amount verification, and description hash checking. Also show me how to extract the sender pubkey and zap comment from a valid receipt.",
+      "expected_output": "A comprehensive validation function that checks: (1) receipt pubkey matches LNURL nostrPubkey, (2) parses the description tag as JSON to get the embedded zap request, (3) verifies the zap request is kind 9734, (4) checks invoice amount matches request amount, (5) verifies SHA256 of description matches bolt11 description hash. Also extracts sender pubkey from the embedded zap request's pubkey field and comment from its content field.",
+      "files": [],
+      "assertions": [
+        "Output works with 'kind: 9735' or 'kind:9735' zap receipt events",
+        "Output validates that the receipt pubkey matches the LNURL nostrPubkey",
+        "Output parses the 'description' tag as JSON to get the embedded zap request",
+        "Output checks the 'bolt11' tag for invoice amount verification",
+        "Output verifies amount in bolt11 matches amount in the zap request",
+        "Output contains 'SHA256' or 'sha256' for hashing the description to verify against bolt11 description hash",
+        "Output verifies the embedded zap request is kind 9734",
+        "Output extracts the sender pubkey from the embedded zap request event"
+      ]
+    },
+    {
+      "id": 3,
+      "name": "nutzap-sending",
+      "prompt": "I want to implement Nutzap (NIP-61) sending in my Nostr client as an alternative to Lightning zaps. The recipient has published a kind:10019 event. Show me the complete flow: fetching their nutzap config, minting P2PK-locked Cashu tokens at one of their trusted mints, and publishing the kind:9321 nutzap event. Also explain how the recipient would verify and redeem the nutzap. Make sure to handle the P2PK pubkey correctly for nostr-cashu compatibility.",
+      "expected_output": "Complete implementation showing: (1) fetching and parsing kind:10019 with relay, mint, and pubkey tags, (2) verifying the P2PK pubkey is NOT the user's main Nostr key, (3) minting tokens P2PK-locked with '02' prefix on the pubkey, (4) constructing kind:9321 with proof, u, unit, p tags, (5) publishing to the relays from kind:10019, (6) recipient verification checking mint is trusted and proofs are locked to correct key, (7) redemption via token swap and kind:7376 event.",
+      "files": [],
+      "assertions": [
+        "Output fetches 'kind: 10019' or 'kind:10019' for the nutzap configuration",
+        "Output constructs 'kind: 9321' or 'kind:9321' nutzap events",
+        "Output contains 'P2PK' for locking the Cashu tokens",
+        "Output contains '02' prefix for the P2PK pubkey (compressed public key format)",
+        "Output warns that the P2PK pubkey must NOT be the user's main Nostr pubkey",
+        "The nutzap event has 'proof' tags carrying Cashu token data",
+        "The mint URL is fetched from the recipient's kind:10019 event",
+        "Output explains redemption including 'kind: 7376' or 'kind:7376' or token swap"
+      ]
+    }
+  ]
+}

.agents/skills/nostr-zap-integration/references/nutzap-flow.md

@@ -0,0 +1,332 @@
+# NIP-61 Nutzap Flow
+
+Complete step-by-step reference for implementing Cashu-based Nutzaps in Nostr
+applications.
+
+## Overview
+
+Nutzaps are an alternative to Lightning Zaps that use Cashu ecash tokens. The
+payment itself is the receipt — no LNURL server needed. Tokens are P2PK-locked
+to a recipient-specified public key and published as Nostr events.
+
+## Protocol Flow
+
+```
+Sender                    Cashu Mint              Relays
+  |                           |                      |
+  |-- Fetch kind:10019 -------|--------------------->|
+  |<-- {mints, pubkey, relays}|                      |
+  |                           |                      |
+  |-- Mint P2PK token ------->|                      |
+  |<-- {proofs} --------------|                      |
+  |                           |                      |
+  |-- Publish kind:9321 ------|--------------------->|
+  |                           |                      |
+  |                    Recipient                     |
+  |                       |-- Fetch kind:9321 ------>|
+  |                       |<-- {proofs} -------------|
+  |                       |                          |
+  |                       |-- Swap token ----------->|
+  |                       |<-- {new proofs} ---------|
+  |                       |                          |
+  |                       |-- Publish kind:7376 ---->|
+```
+
+## Step 1: Fetch Recipient's Configuration (kind:10019)
+
+Query for the recipient's nutzap informational event:
+
+```typescript
+const filter = {
+  kinds: [10019],
+  authors: [recipientPubkey],
+};
+```
+
+### Parse the Configuration
+
+```typescript
+interface NutzapConfig {
+  relays: string[];
+  mints: { url: string; units: string[] }[];
+  p2pkPubkey: string;
+}
+
+function parseNutzapConfig(event: NostrEvent): NutzapConfig {
+  const relays = event.tags
+    .filter((t) => t[0] === "relay")
+    .map((t) => t[1]);
+
+  const mints = event.tags
+    .filter((t) => t[0] === "mint")
+    .map((t) => ({
+      url: t[1],
+      units: t.slice(2), // Additional elements are supported units
+    }));
+
+  const pubkeyTag = event.tags.find((t) => t[0] === "pubkey");
+  if (!pubkeyTag) throw new Error("No pubkey tag in kind:10019");
+
+  return {
+    relays,
+    mints,
+    p2pkPubkey: pubkeyTag[1],
+  };
+}
+```
+
+### Validation Checks
+
+- At least one `relay` tag must be present
+- At least one `mint` tag must be present
+- `pubkey` tag MUST be present
+- `pubkey` value MUST NOT equal the event's `.pubkey` (the user's main key)
+- Mints SHOULD support NUT-11 (P2PK) and NUT-12 (DLEQ proofs)
+
+## Step 2: Mint P2PK-Locked Tokens
+
+### Choose a Mint
+
+Select a mint from the recipient's `mint` tags. Check that it supports the
+desired unit (e.g., "sat"):
+
+```typescript
+function selectMint(config: NutzapConfig, unit: string = "sat"): string {
+  const compatible = config.mints.filter(
+    (m) => m.units.length === 0 || m.units.includes(unit),
+  );
+  if (compatible.length === 0) {
+    throw new Error(`No mints support unit: ${unit}`);
+  }
+  return compatible[0].url;
+}
+```
+
+### Mint or Swap Tokens
+
+Use a Cashu library (e.g., `@cashu/cashu-ts`) to mint tokens P2PK-locked to the
+recipient's pubkey:
+
+```typescript
+import { CashuMint, CashuWallet } from "@cashu/cashu-ts";
+
+async function mintNutzapTokens(
+  mintUrl: string,
+  amountSats: number,
+  recipientP2pkPubkey: string,
+): Promise<CashuProof[]> {
+  const mint = new CashuMint(mintUrl);
+  const wallet = new CashuWallet(mint);
+
+  // CRITICAL: Prefix pubkey with "02" for nostr<>cashu compatibility
+  const lockPubkey = recipientP2pkPubkey.startsWith("02")
+    ? recipientP2pkPubkey
+    : `02${recipientP2pkPubkey}`;
+
+  // Mint tokens with P2PK lock
+  const { proofs } = await wallet.mintTokens(amountSats, {
+    p2pkPubkey: lockPubkey,
+    includeDleq: true, // NUT-12: Include DLEQ proofs
+  });
+
+  return proofs;
+}
+```
+
+**Critical rules:**
+
+- Always prefix the P2PK pubkey with `"02"` (compressed key format)
+- Always request DLEQ proofs (NUT-12) for verifiability
+- Only use mints listed in the recipient's kind:10019
+- The mint URL in the nutzap MUST match EXACTLY as listed in kind:10019
+
+## Step 3: Construct and Publish the Nutzap (kind:9321)
+
+```typescript
+function buildNutzap(params: {
+  senderPubkey: string;
+  recipientPubkey: string; // Nostr identity pubkey, NOT P2PK key
+  proofs: CashuProof[];
+  mintUrl: string;
+  unit?: string;
+  eventId?: string;
+  eventKind?: number;
+  relayHint?: string;
+  comment?: string;
+}): Omit<NostrEvent, "id" | "sig"> {
+  const tags: string[][] = [];
+
+  // Add each proof as a separate tag
+  for (const proof of params.proofs) {
+    tags.push(["proof", JSON.stringify(proof)]);
+  }
+
+  tags.push(["u", params.mintUrl]);
+  tags.push(["unit", params.unit || "sat"]);
+  tags.push(["p", params.recipientPubkey]);
+
+  if (params.eventId) {
+    const eTag = ["e", params.eventId];
+    if (params.relayHint) eTag.push(params.relayHint);
+    tags.push(eTag);
+  }
+
+  if (params.eventKind !== undefined) {
+    tags.push(["k", params.eventKind.toString()]);
+  }
+
+  return {
+    kind: 9321,
+    content: params.comment || "",
+    tags,
+    pubkey: params.senderPubkey,
+    created_at: Math.floor(Date.now() / 1000),
+  };
+}
+```
+
+### Tag Reference for kind:9321
+
+| Tag     | Required | Format                           | Notes                          |
+| ------- | -------- | -------------------------------- | ------------------------------ |
+| `proof` | YES      | `["proof", "<json>"]`            | One or more proof tags         |
+| `u`     | YES      | `["u", "<mint-url>"]`            | EXACT match to kind:10019      |
+| `unit`  | NO       | `["unit", "sat"]`                | Default: "sat" if omitted      |
+| `p`     | YES      | `["p", "<nostr-pubkey>"]`        | Recipient's Nostr identity key |
+| `e`     | NO       | `["e", "<event-id>", "<relay>"]` | Event being nutzapped          |
+| `k`     | NO       | `["k", "<kind>"]`                | Kind of nutzapped event        |
+
+### Publish to Correct Relays
+
+Publish the kind:9321 event to the relays listed in the recipient's kind:10019
+`relay` tags. Failure to publish to these relays means the recipient may never
+see the nutzap.
+
+## Step 4: Receiving Nutzaps
+
+### Query for Incoming Nutzaps
+
+```typescript
+function buildNutzapFilter(
+  myPubkey: string,
+  trustedMints: string[],
+  since?: number,
+): NostrFilter {
+  return {
+    kinds: [9321],
+    "#p": [myPubkey],
+    "#u": trustedMints, // Only from mints we trust
+    ...(since ? { since } : {}),
+  };
+}
+```
+
+### Process and Redeem
+
+```typescript
+async function redeemNutzap(
+  nutzapEvent: NostrEvent,
+  wallet: CashuWallet,
+): Promise<CashuProof[]> {
+  // Extract proofs from the event
+  const proofTags = nutzapEvent.tags.filter((t) => t[0] === "proof");
+  const proofs = proofTags.map((t) => JSON.parse(t[1]));
+
+  // Verify mint URL matches a trusted mint
+  const mintUrl = nutzapEvent.tags.find((t) => t[0] === "u")?.[1];
+  if (!mintUrl) throw new Error("Missing mint URL");
+
+  // Swap tokens into our wallet (this claims them)
+  const newProofs = await wallet.receive(proofs);
+
+  return newProofs;
+}
+```
+
+### Record Redemption (kind:7376)
+
+After successfully swapping tokens, publish a kind:7376 event to record the
+redemption:
+
+```typescript
+function buildRedemptionRecord(params: {
+  nutzapEventId: string;
+  nutzapRelayHint?: string;
+  senderPubkey: string;
+  amount: string;
+  unit: string;
+  newTokenEventId?: string;
+  newTokenRelayHint?: string;
+}): Omit<NostrEvent, "id" | "sig" | "pubkey" | "created_at"> {
+  // Content is NIP-44 encrypted
+  const contentTags = [
+    ["direction", "in"],
+    ["amount", params.amount],
+    ["unit", params.unit],
+  ];
+
+  if (params.newTokenEventId) {
+    const tag = ["e", params.newTokenEventId];
+    if (params.newTokenRelayHint) tag.push(params.newTokenRelayHint);
+    tag.push("created");
+    contentTags.push(tag);
+  }
+
+  return {
+    kind: 7376,
+    content: nip44Encrypt(JSON.stringify(contentTags)), // NIP-44 encrypted
+    tags: [
+      ["e", params.nutzapEventId, params.nutzapRelayHint || "", "redeemed"],
+      ["p", params.senderPubkey],
+    ],
+  };
+}
+```
+
+## Step 5: Verifying Nutzaps (Observer)
+
+Clients displaying nutzap counts or amounts should verify:
+
+```typescript
+function verifyNutzap(
+  nutzap: NostrEvent,
+  recipientConfig: NostrEvent, // kind:10019
+): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+  const config = parseNutzapConfig(recipientConfig);
+
+  // 1. Check mint is in recipient's trusted list
+  const mintUrl = nutzap.tags.find((t) => t[0] === "u")?.[1];
+  if (!mintUrl || !config.mints.some((m) => m.url === mintUrl)) {
+    errors.push("Mint not in recipient's trusted mint list");
+  }
+
+  // 2. Check proofs are locked to the correct pubkey
+  const proofTags = nutzap.tags.filter((t) => t[0] === "proof");
+  for (const proofTag of proofTags) {
+    try {
+      const proof = JSON.parse(proofTag[1]);
+      const secret = JSON.parse(proof.secret);
+      if (secret[0] === "P2PK") {
+        const lockedTo = secret[1].data;
+        const expectedKey = config.p2pkPubkey.startsWith("02")
+          ? config.p2pkPubkey
+          : `02${config.p2pkPubkey}`;
+        if (lockedTo !== expectedKey) {
+          errors.push("Proof not locked to recipient's P2PK pubkey");
+        }
+      }
+    } catch {
+      errors.push("Invalid proof format");
+    }
+  }
+
+  // 3. Verify DLEQ proofs (offline verification)
+  // This requires the mint's keyset - implementation depends on Cashu library
+
+  return { valid: errors.length === 0, errors };
+}
+```
+
+All verification can be done offline (given the mint's keyset and the
+recipient's kind:10019), making it fast and scalable.

.agents/skills/nostr-zap-integration/references/zap-flow.md

@@ -0,0 +1,370 @@
+# NIP-57 Lightning Zap Flow
+
+Complete step-by-step reference for implementing Lightning Zaps in Nostr
+applications.
+
+## Protocol Flow Overview
+
+```
+Sender Client          LNURL Server          Relays          Lightning
+    |                       |                   |                |
+    |-- GET lnurlp/user --->|                   |                |
+    |<-- {allowsNostr, ...}-|                   |                |
+    |                       |                   |                |
+    |-- Sign kind:9734 ---->|                   |                |
+    |   (zap request)       |                   |                |
+    |                       |                   |                |
+    |-- GET callback?nostr= |                   |                |
+    |<-- {pr: bolt11} ------|                   |                |
+    |                       |                   |                |
+    |-- Pay invoice --------|-------------------|------>         |
+    |                       |                   |                |
+    |                       |-- kind:9735 ----->|                |
+    |                       |   (zap receipt)   |                |
+    |                       |                   |                |
+    |<-- Fetch kind:9735 ---|-------------------|                |
+```
+
+## Step 1: Discover the LNURL Endpoint
+
+### From lud16 (Lightning Address)
+
+```typescript
+function getLnurlPayUrl(lud16: string): string {
+  const [name, domain] = lud16.split("@");
+  return `https://${domain}/.well-known/lnurlp/${name}`;
+}
+
+// Example: "bob@walletofsatoshi.com"
+// → "https://walletofsatoshi.com/.well-known/lnurlp/bob"
+```
+
+### From zap tag on an event
+
+If the event has `zap` tags, use those instead of the author's profile:
+
+```typescript
+function getZapRecipients(event: NostrEvent): ZapRecipient[] {
+  const zapTags = event.tags.filter((t) => t[0] === "zap");
+  if (zapTags.length === 0) return []; // Fall back to event author
+
+  const totalWeight = zapTags.reduce((sum, t) => sum + Number(t[3] || 0), 0);
+
+  return zapTags.map((tag) => ({
+    pubkey: tag[1],
+    relay: tag[2],
+    weight: Number(tag[3] || 0),
+    percentage: totalWeight > 0 ? Number(tag[3] || 0) / totalWeight : 0,
+  }));
+}
+```
+
+### Verify Nostr Support
+
+```typescript
+interface LnurlPayResponse {
+  callback: string;
+  maxSendable: number; // millisats
+  minSendable: number; // millisats
+  metadata: string;
+  allowsNostr?: boolean;
+  nostrPubkey?: string; // 32-byte hex
+}
+
+async function verifyNostrZapSupport(
+  lnurlPayUrl: string,
+): Promise<LnurlPayResponse> {
+  const res = await fetch(lnurlPayUrl);
+  const data: LnurlPayResponse = await res.json();
+
+  if (!data.allowsNostr) {
+    throw new Error("LNURL endpoint does not support Nostr zaps");
+  }
+  if (!data.nostrPubkey || data.nostrPubkey.length !== 64) {
+    throw new Error("Invalid or missing nostrPubkey");
+  }
+
+  return data;
+}
+```
+
+## Step 2: Construct the Zap Request (kind:9734)
+
+### Required Structure
+
+```typescript
+interface ZapRequest {
+  kind: 9734;
+  content: string; // Optional message
+  tags: string[][];
+  pubkey: string; // Sender's pubkey
+  created_at: number;
+  id: string;
+  sig: string;
+}
+
+function buildZapRequest(params: {
+  senderPubkey: string;
+  recipientPubkey: string;
+  amountMsats: number;
+  relays: string[];
+  lnurl?: string;
+  eventId?: string;
+  eventKind?: number;
+  addressableCoord?: string; // "kind:pubkey:d-tag"
+  comment?: string;
+}): Omit<ZapRequest, "id" | "sig"> {
+  const tags: string[][] = [
+    ["relays", ...params.relays],
+    ["amount", params.amountMsats.toString()],
+    ["p", params.recipientPubkey],
+  ];
+
+  if (params.lnurl) tags.push(["lnurl", params.lnurl]);
+  if (params.eventId) tags.push(["e", params.eventId]);
+  if (params.addressableCoord) tags.push(["a", params.addressableCoord]);
+  if (params.eventKind !== undefined) {
+    tags.push(["k", params.eventKind.toString()]);
+  }
+
+  return {
+    kind: 9734,
+    content: params.comment || "",
+    tags,
+    pubkey: params.senderPubkey,
+    created_at: Math.floor(Date.now() / 1000),
+  };
+}
+```
+
+### Tag Reference
+
+| Tag      | Required    | Format                               | Notes                 |
+| -------- | ----------- | ------------------------------------ | --------------------- |
+| `relays` | YES         | `["relays", "wss://r1", "wss://r2"]` | NOT nested arrays     |
+| `p`      | YES         | `["p", "<hex-pubkey>"]`              | Exactly one           |
+| `amount` | Recommended | `["amount", "21000"]`                | Millisats as string   |
+| `lnurl`  | Recommended | `["lnurl", "lnurl1..."]`             | Bech32-encoded        |
+| `e`      | Optional    | `["e", "<hex-event-id>"]`            | When zapping an event |
+| `a`      | Optional    | `["a", "30023:pubkey:d-tag"]`        | Addressable events    |
+| `k`      | Optional    | `["k", "1"]`                         | Kind of zapped event  |
+
+### Validation Rules for Zap Requests
+
+The LNURL server validates incoming zap requests:
+
+1. Valid Nostr signature
+2. Has tags
+3. Exactly one `p` tag
+4. Zero or one `e` tags
+5. Has a `relays` tag
+6. If `amount` tag exists, it MUST equal the `amount` query parameter
+7. If `a` tag exists, it MUST be a valid event coordinate
+8. Zero or one `P` tags
+
+## Step 3: Send to Callback URL
+
+```typescript
+async function requestInvoice(
+  callback: string,
+  signedZapRequest: ZapRequest,
+  amountMsats: number,
+  lnurl?: string,
+): Promise<string> {
+  const params = new URLSearchParams({
+    amount: amountMsats.toString(),
+    nostr: JSON.stringify(signedZapRequest),
+  });
+
+  if (lnurl) params.set("lnurl", lnurl);
+
+  const res = await fetch(`${callback}?${params.toString()}`);
+  const data = await res.json();
+
+  if (data.status === "ERROR") {
+    throw new Error(`LNURL error: ${data.reason}`);
+  }
+
+  return data.pr; // bolt11 invoice
+}
+```
+
+**Critical:** The zap request is JSON-encoded, then sent as a query parameter.
+It is NOT published to any relay.
+
+## Step 4: Pay the Invoice
+
+Pass the bolt11 invoice string to a Lightning wallet or payment library. This
+step is outside the Nostr protocol — use whatever Lightning integration your
+application supports (WebLN, NWC, direct LND/CLN API, etc.).
+
+## Step 5: Zap Receipt Creation (Server-Side)
+
+After the invoice is paid, the recipient's LNURL server creates a kind:9735
+event:
+
+```typescript
+function buildZapReceipt(params: {
+  serverPubkey: string; // The LNURL server's nostrPubkey
+  zapRequest: ZapRequest;
+  bolt11: string;
+  preimage?: string;
+  paidAt: number;
+}): Omit<NostrEvent, "id" | "sig"> {
+  const zapReq = params.zapRequest;
+  const recipientPubkey = zapReq.tags.find((t) => t[0] === "p")?.[1];
+  const senderPubkey = zapReq.pubkey;
+  const eventId = zapReq.tags.find((t) => t[0] === "e")?.[1];
+  const aTag = zapReq.tags.find((t) => t[0] === "a");
+
+  const tags: string[][] = [
+    ["p", recipientPubkey!],
+    ["P", senderPubkey],
+    ["bolt11", params.bolt11],
+    ["description", JSON.stringify(zapReq)],
+  ];
+
+  if (eventId) tags.push(["e", eventId]);
+  if (aTag) tags.push(aTag);
+  if (params.preimage) tags.push(["preimage", params.preimage]);
+
+  // Amount from the zap request
+  const amount = zapReq.tags.find((t) => t[0] === "amount")?.[1];
+  if (amount) tags.push(["amount", amount]);
+
+  return {
+    kind: 9735,
+    content: "",
+    tags,
+    pubkey: params.serverPubkey,
+    created_at: params.paidAt,
+  };
+}
+```
+
+The receipt is published to the relays specified in the zap request's `relays`
+tag.
+
+## Step 6: Validate Zap Receipts (Client-Side)
+
+```typescript
+interface ZapValidationResult {
+  valid: boolean;
+  errors: string[];
+  zapRequest?: ZapRequest;
+  amountMsats?: number;
+  senderPubkey?: string;
+  comment?: string;
+}
+
+function validateZapReceipt(
+  receipt: NostrEvent,
+  expectedNostrPubkey: string,
+): ZapValidationResult {
+  const errors: string[] = [];
+
+  // 1. Check receipt pubkey matches LNURL nostrPubkey
+  if (receipt.pubkey !== expectedNostrPubkey) {
+    errors.push(
+      `Receipt pubkey ${receipt.pubkey} does not match expected ${expectedNostrPubkey}`,
+    );
+  }
+
+  // 2. Parse the embedded zap request
+  const descriptionTag = receipt.tags.find((t) => t[0] === "description");
+  if (!descriptionTag) {
+    errors.push("Missing description tag");
+    return { valid: false, errors };
+  }
+
+  let zapRequest: ZapRequest;
+  try {
+    zapRequest = JSON.parse(descriptionTag[1]);
+  } catch {
+    errors.push("Invalid JSON in description tag");
+    return { valid: false, errors };
+  }
+
+  if (zapRequest.kind !== 9734) {
+    errors.push(`Zap request kind is ${zapRequest.kind}, expected 9734`);
+  }
+
+  // 3. Verify amount matches
+  const bolt11Tag = receipt.tags.find((t) => t[0] === "bolt11");
+  const requestAmount = zapRequest.tags.find((t) => t[0] === "amount")?.[1];
+
+  if (bolt11Tag && requestAmount) {
+    const invoiceAmount = decodeBolt11Amount(bolt11Tag[1]);
+    if (invoiceAmount !== Number(requestAmount)) {
+      errors.push(
+        `Invoice amount ${invoiceAmount} does not match request amount ${requestAmount}`,
+      );
+    }
+  }
+
+  // 4. Verify description hash (SHOULD check)
+  if (bolt11Tag) {
+    const descHash = sha256(descriptionTag[1]);
+    const bolt11DescHash = extractDescriptionHash(bolt11Tag[1]);
+    if (bolt11DescHash && descHash !== bolt11DescHash) {
+      errors.push("Description hash mismatch");
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+    zapRequest,
+    amountMsats: requestAmount ? Number(requestAmount) : undefined,
+    senderPubkey: zapRequest.pubkey,
+    comment: zapRequest.content || undefined,
+  };
+}
+```
+
+### Fetching Zap Receipts
+
+```typescript
+// Zaps on a specific event
+const filter = { kinds: [9735], "#e": [eventId] };
+
+// Zaps on a user profile
+const filter = { kinds: [9735], "#p": [pubkey] };
+```
+
+## Zap Splits Implementation
+
+When an event has multiple `zap` tags:
+
+```typescript
+function calculateZapSplits(
+  event: NostrEvent,
+  totalAmountMsats: number,
+): { pubkey: string; relay: string; amountMsats: number }[] {
+  const zapTags = event.tags.filter((t) => t[0] === "zap");
+  if (zapTags.length === 0) return [];
+
+  const totalWeight = zapTags.reduce((sum, t) => sum + Number(t[3] || 0), 0);
+
+  if (totalWeight === 0) {
+    // No weights: divide equally
+    const perRecipient = Math.floor(totalAmountMsats / zapTags.length);
+    return zapTags.map((t) => ({
+      pubkey: t[1],
+      relay: t[2],
+      amountMsats: perRecipient,
+    }));
+  }
+
+  return zapTags
+    .filter((t) => Number(t[3] || 0) > 0) // Skip zero-weight recipients
+    .map((t) => ({
+      pubkey: t[1],
+      relay: t[2],
+      amountMsats: Math.floor(totalAmountMsats * Number(t[3]) / totalWeight),
+    }));
+}
+```
+
+Each split recipient gets a separate zap request → callback → invoice → payment
+cycle.

.gitea/workflows/ci.yaml

@@ -20,13 +20,10 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: pnpm/action-setup@v4
-        with:
-          version: 10
       - name: Install Node
         uses: actions/setup-node@v4
         with:
           node-version: 22
-
       - name: Install Dependencies
         run: pnpm install --frozen-lockfile
       - name: Lint
@@ -42,9 +39,6 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: pnpm/action-setup@v4
-        with:
-          version: 10
-
       - name: Install Dependencies
         run: pnpm install --frozen-lockfile
       - name: Run Tests

app/components/app-menu/about.gjs

@@ -34,6 +34,15 @@ import Icon from '#components/icon';
         >remote storage</a>
         to sync place bookmarks across apps and devices.
       </p>
+      <p>
+        Connect your
+        <a
+          href="https://start.nostr.net"
+          target="_blank"
+          rel="noopener"
+        >Nostr</a>
+        identity to publish photos of places.
+      </p>
 
       <details>
         <summary>
@@ -91,6 +100,26 @@ import Icon from '#components/icon';
                   </a>
                 </td>
               </tr>
+              <tr>
+                <td>
+                  <a
+                    href="https://openfreemap.org"
+                    target="_blank"
+                    rel="noopener"
+                  >
+                    Map tiles
+                  </a>
+                </td>
+                <td>
+                  <a
+                    href="https://github.com/hyperknot/openfreemap/blob/main/LICENSE.md"
+                    target="_blank"
+                    rel="noopener"
+                  >
+                    Various
+                  </a>
+                </td>
+              </tr>
               <tr>
                 <td>
                   <a
@@ -139,13 +168,20 @@ import Icon from '#components/icon';
         <div class="details-content">
           <p>
             <strong>Most impactful:</strong>
+          </p>
+          <ul>
+            <li>
               Add and improve data for points of interest in
               <a
                 href="https://www.openstreetmap.org"
                 target="_blank"
                 rel="noopener"
               >OpenStreetMap</a>.
-          </p>
+            </li>
+            <li>
+              Add place photos with your Nostr account.
+            </li>
+          </ul>
           <p>
             <strong>Most appreciated:</strong>
             Use this app as much as you can and

app/components/app-menu/home.gjs

@@ -25,6 +25,12 @@ import iconRounded from '../../icons/icon-rounded.svg?raw';
           <span>Collections</span>
         </button>
       </li>
+      <li>
+        <button type="button" {{on "click" @onContributions}}>
+          <Icon @name="activity" @size={{20}} />
+          <span>My Contributions</span>
+        </button>
+      </li>
       <li>
         <button type="button" {{on "click" (fn @onNavigate "settings")}}>
           <Icon @name="settings" @size={{20}} />

app/components/app-menu/index.gjs

@@ -23,6 +23,11 @@ export default class AppMenu extends Component {
     this.router.transitionTo('lists.index');
   }
 
+  @action
+  goToContributions() {
+    this.router.transitionTo('contributions');
+  }
+
   <template>
     <div class="sidebar app-menu-pane">
       {{#if (eq this.currentView "menu")}}
@@ -30,6 +35,7 @@ export default class AppMenu extends Component {
           @onNavigate={{this.setView}}
           @onClose={{@onClose}}
           @onSavedPlaces={{this.goToSavedPlaces}}
+          @onContributions={{this.goToContributions}}
         />
 
       {{else if (eq this.currentView "settings")}}

app/components/contribution-photo.gjs

@@ -0,0 +1,86 @@
+import Component from '@glimmer/component';
+import { on } from '@ember/modifier';
+import { fn } from '@ember/helper';
+import or from 'ember-truth-helpers/helpers/or';
+import formatRelativeDate from '../helpers/format-relative-date';
+
+export default class ContributionPhoto extends Component {
+  get item() {
+    return this.args.item;
+  }
+
+  get primaryPhoto() {
+    return this.item?.photos?.[0] || null;
+  }
+
+  get extraPhotoCount() {
+    return Math.max(0, (this.item?.photos?.length || 0) - 1);
+  }
+
+  get placeName() {
+    return this.item?.placeName;
+  }
+
+  get isNameLoading() {
+    return this.item?.placeNameLoading;
+  }
+
+  get tags() {
+    // Collect unique tags across all photos in the contribution group
+    const all = (this.item?.photos || []).flatMap((p) => p.tags || []);
+    return [...new Set(all)];
+  }
+
+  <template>
+    <li>
+      <button
+        type="button"
+        class="contribution-item"
+        {{on "click" (fn @onSelect @item)}}
+      >
+        <div class="contribution-thumb">
+          {{#if this.primaryPhoto}}
+            <img
+              src={{or this.primaryPhoto.thumbUrl this.primaryPhoto.url}}
+              alt={{or this.primaryPhoto.alt "Place photo"}}
+              loading="lazy"
+            />
+          {{/if}}
+          {{#if (gt this.extraPhotoCount 0)}}
+            <span
+              class="contribution-thumb-badge"
+            >+{{this.extraPhotoCount}}</span>
+          {{/if}}
+        </div>
+        <div class="contribution-info">
+          <div class="contribution-place">
+            {{#if this.placeName}}
+              {{this.placeName}}
+            {{else if this.isNameLoading}}
+              <span class="contribution-name-loading">Loading…</span>
+            {{else}}
+              <span class="contribution-name-loading">Unnamed place</span>
+            {{/if}}
+          </div>
+          <div class="contribution-meta">
+            {{formatRelativeDate @item.createdAt}}
+            {{#if (gt this.item.photos.length 1)}}
+              ·
+              {{this.item.photos.length}}
+              photos
+            {{else}}
+              · 1 photo
+            {{/if}}
+          </div>
+          {{#if this.tags.length}}
+            <div class="contribution-tags">
+              {{#each this.tags as |tag|}}
+                <span class="contribution-tag">{{tag}}</span>
+              {{/each}}
+            </div>
+          {{/if}}
+        </div>
+      </button>
+    </li>
+  </template>
+}

app/components/contributions-timeline.gjs

@@ -0,0 +1,86 @@
+import Component from '@glimmer/component';
+import { action } from '@ember/object';
+import { tracked } from '@glimmer/tracking';
+import { on } from '@ember/modifier';
+import Icon from './icon';
+import ContributionPhoto from './contribution-photo';
+import Modal from './modal';
+import NostrConnect from './nostr-connect';
+import eq from 'ember-truth-helpers/helpers/eq';
+import not from 'ember-truth-helpers/helpers/not';
+import restoreScroll from '../modifiers/restore-scroll';
+
+export default class ContributionsTimelineComponent extends Component {
+  @tracked isNostrConnectModalOpen = false;
+
+  @action
+  openNostrConnectModal(event) {
+    event.preventDefault();
+    this.isNostrConnectModalOpen = true;
+  }
+
+  @action
+  closeNostrConnectModal() {
+    this.isNostrConnectModalOpen = false;
+  }
+
+  @action
+  onNostrConnected() {
+    this.closeNostrConnectModal();
+    this.args.onNostrConnected?.();
+  }
+
+  <template>
+    <div class="sidebar">
+      <div class="sidebar-header has-back-btn">
+        <button type="button" class="back-btn" {{on "click" @onBack}}>
+          <Icon @name="arrow-left" @size={{20}} @color="#333" />
+        </button>
+        <h2 class="sidebar-header-text-centered">
+          <span class="sidebar-header-icon-wrapper">
+            <Icon @name="activity" @size={{20}} @color="#898989" />
+          </span>
+          My Contributions
+        </h2>
+        <button type="button" class="close-btn" {{on "click" @onClose}}>
+          <Icon @name="x" @size={{20}} @color="#333" />
+        </button>
+      </div>
+
+      <div class="sidebar-content" {{restoreScroll @scrollTop}}>
+        {{#if @isLoading}}
+          <div class="sidebar-loading">
+            <Icon @name="loading-ring" @size={{24}} @color="#898989" />
+          </div>
+        {{else if (not @isConnected)}}
+          <p class="empty-state">
+            <a
+              href="#"
+              role="button"
+              tabindex="0"
+              {{on "click" this.openNostrConnectModal}}
+            >Connect your Nostr account</a>
+            to see your contributions.
+          </p>
+        {{else if (not @items.length)}}
+          <p class="empty-state">No contributions yet. Start by adding photos to
+            places.</p>
+        {{else}}
+          <ul class="contributions-list">
+            {{#each @items as |item|}}
+              {{#if (eq item.type "photo")}}
+                <ContributionPhoto @item={{item}} @onSelect={{@onSelect}} />
+              {{/if}}
+            {{/each}}
+          </ul>
+        {{/if}}
+      </div>
+    </div>
+
+    {{#if this.isNostrConnectModalOpen}}
+      <Modal @onClose={{this.closeNostrConnectModal}}>
+        <NostrConnect @onConnect={{this.onNostrConnected}} />
+      </Modal>
+    {{/if}}
+  </template>
+}

app/components/map.gjs

@@ -8,6 +8,7 @@ import { defaults as defaultInteractions, DragPan } from 'ol/interaction.js';
 import Kinetic from 'ol/Kinetic.js';
 import View from 'ol/View.js';
 import { fromLonLat, toLonLat, getPointResolution } from 'ol/proj.js';
+import { containsExtent } from 'ol/extent.js';
 import Overlay from 'ol/Overlay.js';
 import LayerGroup from 'ol/layer/Group.js';
 import VectorLayer from 'ol/layer/Vector.js';
@@ -665,7 +666,12 @@ export default class MapComponent extends Component {
       if (options.preventZoom) {
         // If we are preventing zoom (e.g. user clicked a bookmark), we rely on visibility check.
         // This avoids unnecessary panning if the place is already visible.
+        // But if the place has a bbox that doesn't fit in the current view, zoom out to fit it.
+        if (selected.bbox && !this.bboxFitsInView(selected.bbox)) {
+          this.zoomToBbox(selected.bbox);
+        } else {
           this.handlePinVisibility(coords, { maintainZoom: true });
+        }
       } else if (selected.bbox) {
         this.zoomToBbox(selected.bbox);
       } else {
@@ -678,6 +684,20 @@ export default class MapComponent extends Component {
     }
   });
 
+  bboxFitsInView(bbox) {
+    if (!this.mapInstance || !bbox) return true;
+
+    const view = this.mapInstance.getView();
+    const size = this.mapInstance.getSize();
+    const viewExtent = view.calculateExtent(size);
+
+    const min = fromLonLat([bbox.minLon, bbox.minLat]);
+    const max = fromLonLat([bbox.maxLon, bbox.maxLat]);
+    const bboxExtent = [...min, ...max];
+
+    return containsExtent(viewExtent, bboxExtent);
+  }
+
   zoomToBbox(bbox) {
     if (!this.mapInstance || !bbox) return;
 

app/components/modal.gjs

@@ -30,6 +30,10 @@ export default class Modal extends Component {
     return config.environment === 'test';
   }
 
+  get shouldPortal() {
+    return !this.isTesting && !this.args.inline;
+  }
+
   get destinationElement() {
     return document.getElementById('modal-portal') || document.body;
   }
@@ -48,15 +52,7 @@ export default class Modal extends Component {
   }
 
   <template>
-    {{#if this.isTesting}}
+    {{#if this.shouldPortal}}
-      <ModalContent
-        @close={{this.close}}
-        @stopProp={{this.stopProp}}
-        @disableClose={{@disableClose}}
-      >
-        {{yield}}
-      </ModalContent>
-    {{else}}
       {{#in-element this.destinationElement}}
         <ModalContent
           @close={{this.close}}
@@ -66,6 +62,14 @@ export default class Modal extends Component {
           {{yield}}
         </ModalContent>
       {{/in-element}}
+    {{else}}
+      <ModalContent
+        @close={{this.close}}
+        @stopProp={{this.stopProp}}
+        @disableClose={{@disableClose}}
+      >
+        {{yield}}
+      </ModalContent>
     {{/if}}
   </template>
 }

app/components/photo-gallery.gjs

@@ -7,10 +7,13 @@ import { service } from '@ember/service';
 import { modifier } from 'ember-modifier';
 import { task } from 'ember-concurrency';
 import { EventFactory } from 'applesauce-core';
+import or from 'ember-truth-helpers/helpers/or';
 import config from 'marco/config/environment';
 import DropdownMenu from './dropdown-menu';
 import PhotoCarousel from './photo-carousel';
+import ZapPhotoModal from './zap-photo-modal';
 import Icon from './icon';
+import formatRelativeDate from '../helpers/format-relative-date';
 
 const GalleryContent = <template>
   <div
@@ -25,10 +28,11 @@ const GalleryContent = <template>
       class="photo-gallery-content"
       data-current-event-id={{@currentPhoto.eventId}}
     >
+      <div class="photo-gallery-header">
         <div class="actions-btn-container">
           <DropdownMenu
             @iconSize={{24}}
-          @triggerIcon="more-horizontal"
+            @triggerIcon={{@triggerIcon}}
             @iconColor="white"
             as |closeMenu|
           >
@@ -37,6 +41,13 @@ const GalleryContent = <template>
               type="button"
               {{on "click" (fn @copyEventId closeMenu)}}
             >Copy Photo Event ID</button>
+            {{#if @canZapPhoto}}
+              <button
+                class="dropdown-item"
+                type="button"
+                {{on "click" (fn @openZap closeMenu)}}
+              >Zap this photo</button>
+            {{/if}}
             {{#if @canDeletePhoto}}
               <button
                 class="dropdown-item text-danger"
@@ -47,6 +58,20 @@ const GalleryContent = <template>
           </DropdownMenu>
         </div>
 
+        {{#if (or @uploaderName @photoDate)}}
+          <div class="photo-gallery-uploader-info">
+            {{#if @uploaderName}}
+              <span class="photo-gallery-uploader-name">{{@uploaderName}}</span>
+            {{/if}}
+            {{#if @photoDate}}
+              <span class="photo-gallery-uploader-date">
+                {{formatRelativeDate @photoDate}}
+              </span>
+            {{/if}}
+          </div>
+        {{/if}}
+      </div>
+
       <button
         type="button"
         class="close-btn btn-text"
@@ -77,6 +102,10 @@ const GalleryContent = <template>
         />
       </div>
     </div>
+
+    {{#if @zapModalOpen}}
+      <ZapPhotoModal @photo={{@currentPhoto}} @onClose={{@closeZap}} />
+    {{/if}}
   </div>
 </template>;
 
@@ -93,10 +122,19 @@ export default class PhotoGallery extends Component {
   @service nostrAuth;
   @service nostrData;
   @service nostrRelay;
+  @service nostrZap;
   @service blossom;
   @service settings;
 
   @tracked currentPhoto = this.args.selectedPhoto || this.args.photos?.[0];
+  @tracked zapModalOpen = false;
+
+  get triggerIcon() {
+    if (typeof window !== 'undefined' && window.innerWidth <= 768) {
+      return 'more-vertical';
+    }
+    return 'more-horizontal';
+  }
 
   get isCreator() {
     return (
@@ -112,6 +150,27 @@ export default class PhotoGallery extends Component {
     );
   }
 
+  get canZapPhoto() {
+    return (
+      !this.isCreator &&
+      this.nostrAuth.isConnected &&
+      !!this.nostrZap.getLightningAddress(this.currentPhoto?.pubkey)
+    );
+  }
+
+  get uploaderName() {
+    const pubkey = this.currentPhoto?.pubkey;
+    if (!pubkey) return null;
+    const profile = this.nostrData.getProfile?.(pubkey);
+    if (!profile) return null;
+    return profile.displayName || profile.display_name || profile.name || null;
+  }
+
+  get photoDate() {
+    const ts = this.currentPhoto?.publishedAt || this.currentPhoto?.createdAt;
+    return ts || null;
+  }
+
   bindKeyboard = modifier((element, [handler]) => {
     document.addEventListener('keydown', handler);
     return () => document.removeEventListener('keydown', handler);
@@ -131,7 +190,8 @@ export default class PhotoGallery extends Component {
       e.target.closest('.thumbnail-strip-container') ||
       e.target.closest('.carousel-nav-btn') ||
       e.target.closest('.close-btn') ||
-      e.target.closest('.actions-btn-container')
+      e.target.closest('.photo-gallery-header') ||
+      e.target.closest('.modal-overlay')
     ) {
       return;
     }
@@ -187,6 +247,18 @@ export default class PhotoGallery extends Component {
     closeMenu();
   }
 
+  @action
+  openZap(closeMenu, e) {
+    e?.stopPropagation();
+    this.zapModalOpen = true;
+    if (closeMenu) closeMenu();
+  }
+
+  @action
+  closeZap() {
+    this.zapModalOpen = false;
+  }
+
   deletePhotoTask = task(async (closeMenu) => {
     if (
       !confirm(
@@ -268,6 +340,13 @@ export default class PhotoGallery extends Component {
         @handleVisiblePhotoChange={{this.handleVisiblePhotoChange}}
         @placeName={{@placeName}}
         @selectPhoto={{this.selectPhoto}}
+        @uploaderName={{this.uploaderName}}
+        @photoDate={{this.photoDate}}
+        @triggerIcon={{this.triggerIcon}}
+        @openZap={{this.openZap}}
+        @closeZap={{this.closeZap}}
+        @zapModalOpen={{this.zapModalOpen}}
+        @canZapPhoto={{this.canZapPhoto}}
       />
     {{else}}
       {{#in-element this.destinationElement}}
@@ -284,6 +363,13 @@ export default class PhotoGallery extends Component {
           @handleVisiblePhotoChange={{this.handleVisiblePhotoChange}}
           @placeName={{@placeName}}
           @selectPhoto={{this.selectPhoto}}
+          @uploaderName={{this.uploaderName}}
+          @photoDate={{this.photoDate}}
+          @triggerIcon={{this.triggerIcon}}
+          @openZap={{this.openZap}}
+          @closeZap={{this.closeZap}}
+          @zapModalOpen={{this.zapModalOpen}}
+          @canZapPhoto={{this.canZapPhoto}}
         />
       {{/in-element}}
     {{/if}}

app/components/place-details.gjs

@@ -232,7 +232,7 @@ export default class PlaceDetails extends Component {
       return htmlSafe(
         parts
           .map((p) => {
-            const safeTel = p.replace(/[\s-]+/g, '');
+            const safeTel = p.replace(/[\s()+.-]/g, '');
             return `<a href="https://wa.me/${safeTel}" target="_blank" rel="noopener noreferrer">${p}</a>`;
           })
           .join('<br>')

app/components/zap-photo-modal.gjs

@@ -0,0 +1,499 @@
+import Component from '@glimmer/component';
+import { action } from '@ember/object';
+import { tracked } from '@glimmer/tracking';
+import { on } from '@ember/modifier';
+import { service } from '@ember/service';
+import { task } from 'ember-concurrency';
+import { eq } from 'ember-truth-helpers';
+import qrCode from '../modifiers/qr-code';
+import Icon from './icon';
+import Modal from './modal';
+
+const SLIDER_MIN_SATS = 10;
+const SLIDER_MAX_SATS = 100_000;
+const SLIDER_STEPS = 200;
+
+function sliderToSats(position) {
+  const t = position / SLIDER_STEPS;
+  return Math.round(
+    Math.exp(
+      Math.log(SLIDER_MIN_SATS) +
+        (Math.log(SLIDER_MAX_SATS) - Math.log(SLIDER_MIN_SATS)) * t
+    )
+  );
+}
+
+function satsToSlider(sats) {
+  return Math.round(
+    ((Math.log(sats) - Math.log(SLIDER_MIN_SATS)) /
+      (Math.log(SLIDER_MAX_SATS) - Math.log(SLIDER_MIN_SATS))) *
+      SLIDER_STEPS
+  );
+}
+
+const DEFAULT_SLIDER_POSITION = satsToSlider(100);
+
+export default class ZapPhotoModal extends Component {
+  @service nostrZap;
+  @service nostrAuth;
+  @service nostrData;
+  @service toast;
+
+  @tracked step = 'select-amount';
+  @tracked sliderPosition = DEFAULT_SLIDER_POSITION;
+  @tracked message = '';
+  @tracked error = null;
+  @tracked invoice = null;
+  @tracked lightningAddress = null;
+  @tracked lnurlEndpoint = null;
+  @tracked lnurlLoading = false;
+  @tracked lnurlError = null;
+  @tracked paymentNotDetected = false;
+
+  sliderSteps = SLIDER_STEPS;
+  sliderTicks = ['10', '100', '1k', '10k', '100k'];
+
+  _receiptSub = null;
+  _receiptTimeout = null;
+  _zapRequest = null;
+
+  RECEIPT_TIMEOUT_MS = 5 * 60 * 1000;
+
+  constructor() {
+    super(...arguments);
+    this._loadLightningInfo();
+  }
+
+  get photo() {
+    return this.args.photo;
+  }
+
+  get hasWebLN() {
+    return this.nostrZap.hasWebLN();
+  }
+
+  get effectiveAmount() {
+    return sliderToSats(this.sliderPosition);
+  }
+
+  get amountMsats() {
+    return this.effectiveAmount * 1000;
+  }
+
+  get formattedAmount() {
+    return this.effectiveAmount.toLocaleString();
+  }
+
+  get cannotZap() {
+    return !this.canZap;
+  }
+
+  get canZap() {
+    if (!this.lnurlEndpoint) return false;
+    if (this.lnurlError) return false;
+    if (this.effectiveAmount <= 0) return false;
+    return (
+      this.amountMsats >= this.lnurlEndpoint.minSendable &&
+      this.amountMsats <= this.lnurlEndpoint.maxSendable
+    );
+  }
+
+  get minSats() {
+    return this.lnurlEndpoint
+      ? Math.ceil(this.lnurlEndpoint.minSendable / 1000)
+      : 1;
+  }
+
+  get maxSats() {
+    return this.lnurlEndpoint
+      ? Math.floor(this.lnurlEndpoint.maxSendable / 1000)
+      : SLIDER_MAX_SATS;
+  }
+
+  get lightningUri() {
+    return this.invoice ? `lightning:${this.invoice}` : '';
+  }
+
+  get parsedInvoice() {
+    if (!this.invoice) return null;
+    try {
+      return this.nostrZap.parseInvoice(this.invoice);
+    } catch {
+      return null;
+    }
+  }
+  async _loadLightningInfo() {
+    const pubkey = this.photo?.pubkey;
+    if (!pubkey) return;
+
+    // Pre-warm the recipient relay cache so the zap request
+    // uses the recipient's NIP-65 inbox relays (where they'll
+    // see the zap receipt) instead of the sender's relays
+    this.nostrZap.loadRecipientRelays(pubkey).catch(() => {});
+
+    const address = this.nostrZap.getLightningAddress(pubkey);
+    if (!address) {
+      this.lnurlError =
+        'This user has no lightning address set in their profile';
+      return;
+    }
+
+    this.lightningAddress = address;
+    this.lnurlLoading = true;
+    this.lnurlError = null;
+
+    try {
+      this.lnurlEndpoint = await this.nostrZap.resolveLnurl(address);
+    } catch (err) {
+      this.lnurlError =
+        err instanceof Error ? err.message : 'Failed to fetch lightning info';
+    } finally {
+      this.lnurlLoading = false;
+    }
+  }
+  @action
+  updateSlider(e) {
+    this.sliderPosition = Number(e.target.value);
+  }
+
+  @action
+  updateMessage(e) {
+    this.message = e.target.value;
+  }
+
+  @action
+  handleClose() {
+    if (this.args.onClose) {
+      this.args.onClose();
+    }
+  }
+
+  @action
+  resetAndClose() {
+    this._cleanupReceiptSub();
+    this.step = 'select-amount';
+    this.error = null;
+    this.invoice = null;
+    this.paymentNotDetected = false;
+    this.handleClose();
+  }
+
+  @action
+  retry() {
+    this.step = 'select-amount';
+    this.error = null;
+  }
+
+  @action
+  showInvoice() {
+    this.step = 'awaiting-payment';
+    this.error = null;
+  }
+
+  @action
+  performZap() {
+    this.zapTask.perform();
+  }
+
+  @action
+  performWebLNPay() {
+    this.webLNPayTask.perform();
+  }
+
+  @action
+  copyInvoice() {
+    if (!this.invoice) return;
+    try {
+      navigator.clipboard.writeText(this.invoice);
+      this.toast.show('Invoice copied to clipboard');
+    } catch {
+      // no-op
+    }
+  }
+
+  _startReceiptSubscription(zapRequest) {
+    this._cleanupReceiptSub();
+    this._zapRequest = zapRequest;
+    this.paymentNotDetected = false;
+
+    this._receiptSub = this.nostrZap.subscribeForZapReceipt(
+      zapRequest,
+      this.photo,
+      () => {
+        this.step = 'success';
+        this._cleanupReceiptSub();
+      }
+    );
+
+    this._receiptTimeout = setTimeout(() => {
+      this.paymentNotDetected = true;
+    }, this.RECEIPT_TIMEOUT_MS);
+  }
+
+  _cleanupReceiptSub() {
+    if (this._receiptSub) {
+      this._receiptSub.unsubscribe();
+      this._receiptSub = null;
+    }
+    if (this._receiptTimeout) {
+      clearTimeout(this._receiptTimeout);
+      this._receiptTimeout = null;
+    }
+  }
+
+  zapTask = task(async () => {
+    if (!this.canZap) return;
+
+    this.step = 'fetching-invoice';
+    this.error = null;
+
+    try {
+      const { invoice, zapRequest } = await this.nostrZap.zap(
+        this.photo,
+        this.amountMsats,
+        this.message
+      );
+      this.invoice = invoice;
+      this.step = 'awaiting-payment';
+      this._startReceiptSubscription(zapRequest);
+    } catch (err) {
+      console.error('Zap failed:', err);
+      this.error = err instanceof Error ? err.message : 'Failed to create zap';
+      this.step = 'error';
+    }
+  });
+
+  webLNPayTask = task(async () => {
+    if (!this.invoice) return;
+
+    this.step = 'paying-with-wallet';
+    this.error = null;
+
+    try {
+      await this.nostrZap.payWithWebln(this.invoice);
+      this._cleanupReceiptSub();
+      this.step = 'success';
+    } catch (err) {
+      console.error('WebLN pay failed:', err);
+      this.error =
+        err instanceof Error ? err.message : 'Failed to pay with wallet';
+      this.step = 'wallet-pay-error';
+    }
+  });
+
+  willDestroy() {
+    this._cleanupReceiptSub();
+    super.willDestroy(...arguments);
+  }
+
+  <template>
+    <Modal @inline={{true}} @onClose={{this.resetAndClose}}>
+      <div class="zap-photo-modal">
+        <h2>Zap Photo</h2>
+
+        {{! Lightning address status }}
+        <section class="status">
+          {{#if this.lnurlLoading}}
+            <p class="meta-info">Loading lightning address...</p>
+          {{else if this.lightningAddress}}
+            <div class="lightning-address">
+              <span class="lightning-badge">Lightning</span>
+              <span
+                class="lightning-address-text"
+              >{{this.lightningAddress}}</span>
+            </div>
+          {{/if}}
+          {{#if this.lnurlError}}
+            <div class="alert alert-error">{{this.lnurlError}}</div>
+          {{/if}}
+        </section>
+
+        {{! Step: Select Amount }}
+        {{#if (eq this.step "select-amount")}}
+          <section class="slider">
+            <div class="amount-display">
+              <span
+                class="amount-value zap-amount"
+              >{{this.formattedAmount}}</span>
+              <span class="amount-unit">sats</span>
+            </div>
+
+            <input
+              type="range"
+              class="zap-slider"
+              min="0"
+              max={{this.sliderSteps}}
+              value={{this.sliderPosition}}
+              aria-label="Zap amount in sats"
+              {{on "input" this.updateSlider}}
+            />
+
+            <div class="slider-ticks">
+              {{#each this.sliderTicks as |label|}}
+                <span>{{label}}</span>
+              {{/each}}
+            </div>
+
+          </section>
+
+          <div class="form-group">
+            <label>Message (optional)</label>
+            <input
+              type="text"
+              class="form-control"
+              placeholder="Say something nice..."
+              aria-label="Zap message"
+              value={{this.message}}
+              {{on "input" this.updateMessage}}
+            />
+          </div>
+
+          <div class="edit-actions">
+            <button
+              type="button"
+              class="btn btn-outline"
+              {{on "click" this.resetAndClose}}
+            >
+              Cancel
+            </button>
+            <button
+              type="button"
+              class="btn btn-primary"
+              disabled={{this.cannotZap}}
+              {{on "click" this.performZap}}
+            >
+              Zap
+              {{this.formattedAmount}}
+              sats
+            </button>
+          </div>
+        {{/if}}
+
+        {{! Step: Fetching Invoice }}
+        {{#if (eq this.step "fetching-invoice")}}
+          <div class="centered">
+            <Icon @name="loading-ring" @size={{32}} class="spin-animation" />
+            <p>Creating zap request and fetching invoice...</p>
+          </div>
+        {{/if}}
+
+        {{! Step: Awaiting Payment }}
+        {{#if (eq this.step "awaiting-payment")}}
+          <p class="zap-pay-prompt">
+            Scan to pay
+            <strong>{{this.formattedAmount}} sats</strong>
+          </p>
+
+          <div class="qr-code-container">
+            <canvas {{qrCode this.invoice}}></canvas>
+          </div>
+
+          {{#if this.hasWebLN}}
+            <button
+              type="button"
+              class="btn btn-primary btn-full webln-pay-btn"
+              {{on "click" this.performWebLNPay}}
+            >
+              Open in Lightning wallet
+            </button>
+          {{else}}
+            <a href={{this.lightningUri}} class="btn btn-primary btn-full">
+              Open in Lightning wallet
+            </a>
+          {{/if}}
+
+          <button
+            type="button"
+            class="btn btn-outline btn-full copy-invoice-btn"
+            {{on "click" this.copyInvoice}}
+          >
+            Copy payment request
+          </button>
+
+          {{#if this.paymentNotDetected}}
+            <p class="meta-info">
+              Payment not detected yet. Keep the QR code open and try paying
+              again, or use a different Lightning wallet.
+            </p>
+          {{/if}}
+        {{/if}}
+
+        {{! Step: Paying with Wallet }}
+        {{#if (eq this.step "paying-with-wallet")}}
+          <div class="centered">
+            <Icon @name="loading-ring" @size={{32}} class="spin-animation" />
+            <p>Paying invoice with WebLN...</p>
+          </div>
+        {{/if}}
+
+        {{! Step: Wallet Pay Error }}
+        {{#if (eq this.step "wallet-pay-error")}}
+          <div class="alert alert-error">{{this.error}}</div>
+          <p class="meta-info">
+            The WebLN payment failed. You can still scan the QR code with a
+            Lightning wallet.
+          </p>
+          <div class="edit-actions">
+            <button
+              type="button"
+              class="btn btn-outline"
+              {{on "click" this.resetAndClose}}
+            >
+              Cancel
+            </button>
+            <button
+              type="button"
+              class="btn btn-primary"
+              {{on "click" this.showInvoice}}
+            >
+              Show Invoice
+            </button>
+          </div>
+        {{/if}}
+
+        {{! Step: Success }}
+        {{#if (eq this.step "success")}}
+          <div class="success zap-success">
+            <div class="success-icon">&#9889;</div>
+            <h4>Zap Sent!</h4>
+            <p>
+              You zapped
+              <strong>{{this.formattedAmount}} sats</strong>
+              {{#if this.message}}
+                with message: "{{this.message}}"
+              {{/if}}
+            </p>
+            <button
+              type="button"
+              class="btn btn-primary"
+              {{on "click" this.resetAndClose}}
+            >
+              Done
+            </button>
+          </div>
+        {{/if}}
+
+        {{! Step: Error }}
+        {{#if (eq this.step "error")}}
+          <div class="alert alert-error">{{this.error}}</div>
+          <div class="edit-actions">
+            <button
+              type="button"
+              class="btn btn-outline"
+              {{on "click" this.resetAndClose}}
+            >
+              Close
+            </button>
+            <button
+              type="button"
+              class="btn btn-primary"
+              {{on "click" this.retry}}
+            >
+              Try Again
+            </button>
+          </div>
+        {{/if}}
+      </div>
+    </Modal>
+  </template>
+}

app/controllers/contributions.js

@@ -0,0 +1,60 @@
+import Controller from '@ember/controller';
+import { service } from '@ember/service';
+import { action } from '@ember/object';
+import { task } from 'ember-concurrency';
+
+export default class ContributionsController extends Controller {
+  @service router;
+  @service mapUi;
+  @service nostrAuth;
+  @service contributions;
+  @service storage;
+
+  loadContributionsTask = task({ restartable: true }, async (pubkey) => {
+    if (!pubkey) return;
+    await this.contributions.load(pubkey);
+  });
+
+  get scrollTop() {
+    return this.mapUi.getScrollPosition('contributions');
+  }
+
+  get items() {
+    return this.contributions.items;
+  }
+
+  get isConnected() {
+    return this.nostrAuth.isConnected;
+  }
+
+  @action
+  selectContribution(item) {
+    if (!item) return;
+
+    const sidebarContent = document.querySelector('.sidebar-content');
+    if (sidebarContent) {
+      this.mapUi.saveScrollPosition('contributions', sidebarContent.scrollTop);
+    }
+
+    this.mapUi.returnToRoute = { name: 'contributions' };
+    this.mapUi.showSidebar();
+    this.mapUi.preventNextZoom = true;
+
+    this.router.transitionTo(`/place/${item.placeIdentifier}`);
+  }
+
+  @action
+  onNostrConnected() {
+    this.loadContributionsTask.perform(this.nostrAuth.pubkey);
+  }
+
+  @action
+  backToMenu() {
+    this.router.transitionTo('menu');
+  }
+
+  @action
+  close() {
+    this.router.transitionTo('index');
+  }
+}

app/helpers/format-relative-date.js

@@ -0,0 +1,6 @@
+import { helper } from '@ember/component/helper';
+import { formatRelativeDate as format } from '../utils/format-text';
+
+export default helper(function formatRelativeDate([timestamp]) {
+  return format(timestamp);
+});

app/router.js

@@ -14,6 +14,7 @@ Router.map(function () {
   this.route('lists', function () {
     this.route('list', { path: '/:list_id' });
   });
+  this.route('contributions');
   this.route('oauth', function () {
     this.route('osm-callback', { path: '/osm/callback' });
   });

app/routes/contributions.js

@@ -0,0 +1,23 @@
+import Route from '@ember/routing/route';
+import { service } from '@ember/service';
+
+export default class ContributionsRoute extends Route {
+  @service mapUi;
+  @service nostrAuth;
+  @service contributions;
+
+  activate() {
+    this.mapUi.showSidebar();
+  }
+
+  setupController(controller, model) {
+    super.setupController(controller, model);
+    if (controller && controller.loadContributionsTask) {
+      controller.loadContributionsTask.perform(this.nostrAuth.pubkey);
+    }
+  }
+
+  deactivate() {
+    this.contributions.stop();
+  }
+}

app/routes/place.js

@@ -1,6 +1,23 @@
 import Route from '@ember/routing/route';
 import { service } from '@ember/service';
 
+// Detects whether the fresh OSM data differs from the currently-shown model
+// by more than ~1m of coordinate drift, or in any tag. Mirrors the relevant
+// subset of `storage.refreshPlace`'s diff for the non-bookmark path.
+function hasOsmChanges(place, fresh) {
+  const latDiff = Math.abs((place.lat ?? 0) - (fresh.lat ?? 0));
+  const lonDiff = Math.abs((place.lon ?? 0) - (fresh.lon ?? 0));
+  if (latDiff > 0.00001 || lonDiff > 0.00001) return true;
+
+  const oldTags = place.osmTags || {};
+  const newTags = fresh.osmTags || {};
+  const allKeys = new Set([...Object.keys(oldTags), ...Object.keys(newTags)]);
+  for (const key of allKeys) {
+    if (oldTags[key] !== newTags[key]) return true;
+  }
+  return false;
+}
+
 export default class PlaceRoute extends Route {
   @service storage;
   @service osm;
@@ -131,14 +148,32 @@ export default class PlaceRoute extends Route {
   }
 
   async checkUpdates(place) {
-    // Only check for updates if it's a saved place (has ID) and is an OSM object
+    if (!place || !place.osmId || !place.osmType) return;
-    if (place && place.id && place.osmId && place.osmType) {
+
+    // Bookmarked place — refresh via storage, which persists the update.
+    if (place.id) {
       const updatedPlace = await this.storage.refreshPlace(place);
       if (updatedPlace) {
-        // If an update occurred, refresh the map UI selection without moving the camera
+        // If an update occurred, refresh the map UI selection without moving
-        // This ensures the sidebar shows the new data
+        // the camera. This ensures the sidebar shows the new data.
         this.mapUi.selectPlace(updatedPlace, { preventZoom: true });
       }
+      return;
+    }
+
+    // Non-bookmarked explicit OSM place — fetch fresh and update the model
+    // in-place if anything changed, so the sidebar reflects the latest OSM
+    // data without requiring a re-open.
+    try {
+      const fresh = await this.osm.fetchOsmObject(place.osmId, place.osmType, {
+        forceFresh: true,
+      });
+      if (fresh && hasOsmChanges(place, fresh)) {
+        Object.assign(place, fresh);
+        this.mapUi.selectPlace(place, { preventZoom: true });
+      }
+    } catch (e) {
+      console.debug('[place] Fresh fetch failed for', place.osmId, e);
     }
   }
 

app/services/contributions.js

@@ -0,0 +1,279 @@
+import Service, { service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+import { groupPhotoContributions } from '../utils/contributions';
+
+const NAME_CACHE_STORE = 'contributions-name-cache';
+
+/**
+ * Orchestrates loading the user's own Nostr contributions, grouping them into
+ * timeline entries, and resolving place names from bookmarks or the OSM API.
+ *
+ * The flow is:
+ *   1. Subscribe to `nostrData.store.timeline(...)` for the user's kind 360 events.
+ *   2. Group events into contribution entries via `groupPhotoContributions`.
+ *   3. Resolve place names from bookmarks (sync, instant) on the first render,
+ *      then asynchronously from the IndexedDB name cache and OSM cache.
+ *   4. For unresolved names, batch-fetch from the OSM API in the background.
+ *   5. Any items that can't be resolved get a fallback name so they don't stay
+ *      stuck in a "Loading…" state forever.
+ *   6. Update `@tracked items` so the UI renders progressively.
+ *
+ * The persistent name cache is stored in IndexedDB (via the `localForage`
+ * service) with one key per `placeIdentifier`, so partial updates don't
+ * require re-serializing the whole map.
+ */
+export default class ContributionsService extends Service {
+  @service nostrData;
+  @service nostrAuth;
+  @service storage;
+  @service osm;
+  @service localForage;
+
+  @tracked items = [];
+
+  _sub = null;
+  _pendingBatchPromise = null;
+  _lastBatchSignature = '';
+  _unresolvable = new Set();
+
+  /**
+   * Async name resolution. Checks, in order:
+   *   1. Bookmarks (sync, instant).
+   *   2. The persistent IndexedDB name cache (per-entry key).
+   *   3. The OSM service's IndexedDB cache (from place detail visits).
+   *
+   * @param {object} entry A contribution entry with `osmType`, `osmId`, and `placeIdentifier`.
+   * @returns {Promise<string|null>}
+   */
+  async _resolveCachedName(entry) {
+    // 1. Try bookmarks (instant)
+    const bookmark = this.storage.findPlaceById(entry.osmId);
+    if (bookmark?.title) return bookmark.title;
+
+    // 2. Try the persistent name cache (IndexedDB, per-entry, survives sessions)
+    const cachedName = await this.localForage.get(
+      NAME_CACHE_STORE,
+      entry.placeIdentifier
+    );
+    if (cachedName) return cachedName;
+
+    // 3. Try OSM IndexedDB cache (from place detail visits)
+    const cached = await this.osm.getCachedOsmObject(
+      entry.osmType,
+      entry.osmId
+    );
+    return cached?.title || null;
+  }
+
+  /**
+   * Asynchronously resolves names for still-loading entries from the caches.
+   * Falls through to `_maybeBatchFetchNames` for anything that remains
+   * unresolved. Fire-and-forget from `_updateItems` so the list renders
+   * immediately with bookmark-resolved names.
+   *
+   * @param {Array} entries
+   * @returns {Promise<void>}
+   */
+  async _resolveFromCache(entries) {
+    const pending = entries.filter((e) => e.placeNameLoading);
+    if (pending.length === 0) {
+      this._maybeBatchFetchNames(this.items);
+      return;
+    }
+
+    await Promise.all(
+      pending.map(async (entry) => {
+        const name = await this._resolveCachedName(entry);
+        if (name) {
+          entry.placeName = name;
+          entry.placeNameLoading = false;
+        }
+      })
+    );
+
+    // Re-render with whatever resolved, then kick off the network batch for
+    // entries that are still loading.
+    this.items = [...this.items];
+    this._maybeBatchFetchNames(this.items);
+  }
+
+  /**
+   * Loads the user's contributions and subscribes to live updates.
+   *
+   * @param {string} pubkey The user's Nostr pubkey
+   */
+  async load(pubkey) {
+    if (!pubkey) {
+      this.items = [];
+      return;
+    }
+
+    // Subscribe to the user's own kind 360 events. Each update triggers a re-group
+    // and place-name resolution. This mirrors the `loadPhotosForPlace` pattern.
+    this._sub = this.nostrData.store
+      .timeline([{ kinds: [360, 5], authors: [pubkey] }])
+      .subscribe((events) => {
+        this._updateItems(events);
+      });
+
+    // Also kick off the network fetch via nostrData. This populates the store and
+    // causes the subscription above to fire with fresh events.
+    await this.nostrData.loadMyContributions(pubkey);
+  }
+
+  /**
+   * Stops the subscription and clears the timeline. Called when leaving the
+   * contributions route.
+   */
+  stop() {
+    if (this._sub) {
+      this._sub.unsubscribe();
+      this._sub = null;
+    }
+    this.items = [];
+    this._lastBatchSignature = '';
+    this._pendingBatchPromise = null;
+    this._unresolvable.clear();
+  }
+
+  willDestroy() {
+    this.stop();
+    super.willDestroy(...arguments);
+  }
+
+  _updateItems(events) {
+    // 1. Group events into contribution entries (newest-first)
+    const entries = groupPhotoContributions(events);
+
+    // 2. Bookmark lookup is synchronous — resolve those immediately so the
+    //    first render shows bookmarked place names without a "Loading…" flicker.
+    for (const entry of entries) {
+      const bookmark = this.storage.findPlaceById(entry.osmId);
+      if (bookmark?.title) {
+        entry.placeName = bookmark.title;
+        entry.placeNameLoading = false;
+      }
+    }
+
+    this.items = entries;
+
+    // 3. Async-resolve remaining entries from the IndexedDB name cache and OSM
+    //    cache, then fall through to the network batch for the rest.
+    void this._resolveFromCache(entries);
+  }
+
+  _isUnresolvable(entry) {
+    return this._unresolvable.has(entry.placeIdentifier);
+  }
+
+  _maybeBatchFetchNames(entries) {
+    const unresolved = entries.filter(
+      (e) => e.placeNameLoading && !this._isUnresolvable(e)
+    );
+
+    // Apply fallbacks for items already marked unresolvable in this session
+    for (const entry of entries) {
+      if (entry.placeNameLoading && this._isUnresolvable(entry)) {
+        entry.placeName = this._fallbackName(entry);
+        entry.placeNameLoading = false;
+      }
+    }
+
+    if (unresolved.length === 0) {
+      if (this.items.some((i) => !i.placeNameLoading)) {
+        this.items = [...this.items];
+      }
+      return;
+    }
+
+    // Build a stable signature so we only fire one batch request per unique set
+    const signature = unresolved
+      .map((e) => e.placeIdentifier)
+      .sort()
+      .join('|');
+    if (signature === this._lastBatchSignature && this._pendingBatchPromise) {
+      return;
+    }
+    this._lastBatchSignature = signature;
+
+    this._pendingBatchPromise = this._batchResolveNames(unresolved)
+      .then((nameMap) => {
+        // Merge resolved names back into the current `items`.
+        for (const item of this.items) {
+          if (!item.placeNameLoading) continue;
+          if (nameMap.has(item.placeIdentifier)) {
+            const name = nameMap.get(item.placeIdentifier);
+            item.placeName = name;
+            item.placeNameLoading = false;
+          } else {
+            // Could not be resolved (deleted object, network error for this item).
+            // Mark as unresolvable for this session and use a fallback.
+            this._unresolvable.add(item.placeIdentifier);
+            item.placeName = this._fallbackName(item);
+            item.placeNameLoading = false;
+          }
+        }
+        // Trigger a re-render
+        this.items = [...this.items];
+      })
+      .catch((e) => {
+        console.error('[contributions] Batch name resolution failed', e);
+        // On a total failure, mark all as unresolvable and apply fallbacks
+        for (const item of this.items) {
+          if (item.placeNameLoading) {
+            this._unresolvable.add(item.placeIdentifier);
+            item.placeName = this._fallbackName(item);
+            item.placeNameLoading = false;
+          }
+        }
+        this.items = [...this.items];
+      })
+      .finally(() => {
+        this._pendingBatchPromise = null;
+      });
+  }
+
+  _fallbackName(item) {
+    return `OSM ${item.osmType} ${item.osmId}`;
+  }
+
+  async _batchResolveNames(entries) {
+    const nameMap = new Map();
+    const toFetch = [];
+
+    // Re-check cache in case it was populated between the trigger and now
+    for (const entry of entries) {
+      const cached = await this._resolveCachedName(entry);
+      if (cached) {
+        nameMap.set(entry.placeIdentifier, cached);
+      } else {
+        toFetch.push({ osmType: entry.osmType, osmId: entry.osmId });
+      }
+    }
+
+    if (toFetch.length === 0) return nameMap;
+
+    const places = await this.osm.fetchOsmObjectsBatch(toFetch);
+
+    // Persist each newly-resolved name to the IndexedDB name cache as its own
+    // entry (per-placeIdentifier key) so we don't re-fetch next session.
+    const writePromises = [];
+    for (const entry of entries) {
+      if (nameMap.has(entry.placeIdentifier)) continue;
+      const cacheKey = `${entry.osmType}:${entry.osmId}`;
+      const place = places.get(cacheKey);
+      if (place?.title) {
+        nameMap.set(entry.placeIdentifier, place.title);
+        writePromises.push(
+          this.localForage.set(
+            NAME_CACHE_STORE,
+            entry.placeIdentifier,
+            place.title
+          )
+        );
+      }
+    }
+    await Promise.all(writePromises);
+    return nameMap;
+  }
+}

app/services/local-forage.js

@@ -0,0 +1,55 @@
+import localforage from 'localforage';
+import Service from '@ember/service';
+
+const DB_NAME = 'marco';
+
+/**
+ * Thin async-only wrapper around `localforage` that exposes namespaced
+ * object stores under a single IndexedDB database (`marco`).
+ *
+ * Each "store" is a `localforage` instance created with a unique
+ * `storeName`, so callers can keep data isolated (e.g. OSM cache vs.
+ * contributions name cache) without managing their own connections.
+ *
+ * All methods return Promises — IndexedDB is inherently async, so callers
+ * must `await` every read/write.
+ */
+export default class LocalForageService extends Service {
+  _instances = new Map();
+
+  _instance(storeName) {
+    let instance = this._instances.get(storeName);
+    if (!instance) {
+      instance = localforage.createInstance({
+        name: DB_NAME,
+        storeName,
+      });
+      this._instances.set(storeName, instance);
+    }
+    return instance;
+  }
+
+  async get(storeName, key) {
+    return this._instance(storeName).getItem(key);
+  }
+
+  async set(storeName, key, value) {
+    return this._instance(storeName).setItem(key, value);
+  }
+
+  async remove(storeName, key) {
+    return this._instance(storeName).removeItem(key);
+  }
+
+  async keys(storeName) {
+    return this._instance(storeName).keys();
+  }
+
+  async clear(storeName) {
+    return this._instance(storeName).clear();
+  }
+
+  async iterate(storeName, fn) {
+    return this._instance(storeName).iterate(fn);
+  }
+}

app/services/nostr-data.js

@@ -1,10 +1,12 @@
 import Service, { service } from '@ember/service';
 import { tracked } from '@glimmer/tracking';
+import { EMPTY, from } from 'rxjs';
 import { EventStore } from 'applesauce-core/event-store';
 import { ProfileModel } from 'applesauce-core/models/profile';
 import { MailboxesModel } from 'applesauce-core/models/mailboxes';
 import { npubEncode } from 'applesauce-core/helpers/pointers';
 import { persistEventsToCache } from 'applesauce-core/helpers/event-cache';
+import { createEventLoaderForStore } from 'applesauce-loaders/loaders';
 import { NostrIDB, openDB } from 'nostr-idb';
 import {
   excludeRequiredRelays,
@@ -15,9 +17,9 @@ import {
 import { getGeohashPrefixesInBbox } from '../utils/geohash-coverage';
 
 const DIRECTORY_RELAYS = [
-  'wss://purplepag.es',
+  'wss://relay.primal.net',
-  'wss://relay.damus.io',
   'wss://nos.lol',
+  'wss://relay.damus.io',
 ];
 
 const DEFAULT_READ_RELAYS = ['wss://nostr.kosmos.org'];
@@ -34,19 +36,43 @@ export default class NostrDataService extends Service {
   @tracked mailboxes = null;
   @tracked blossomServers = [];
   @tracked placePhotos = [];
+  @tracked myContributionEvents = [];
+  @tracked profiles = {};
+  @tracked zapReceipts = {};
 
   _profileSub = null;
   _mailboxesSub = null;
   _blossomSub = null;
   _photosSub = null;
+  _contributionsSub = null;
+  _profileModelSubs = new Map();
+
+  _zapReceiptsSub = null;
+  _zapReceiptsNetworkSub = null;
+  _zapRefreshTimer = null;
+  _lastPhotoIds = new Set();
 
   _requestSub = null;
   _cachePromise = null;
+  _currentPlaceEntityId = null;
   loadedGeohashPrefixes = new Set();
 
   constructor() {
     super(...arguments);
 
+    // Set up the event loader synchronously so that any subscription
+    // (e.g. loadProfiles from a route's afterModel) can auto-fetch even
+    // before the IndexedDB cache has finished opening. The cacheRequest
+    // is lazy — it returns EMPTY until `this.cache` is available, so the
+    // loader falls through to relay hints → lookup relays in the meantime.
+    createEventLoaderForStore(this.store, this.nostrRelay.pool, {
+      cacheRequest: (filters) => {
+        if (!this.cache) return EMPTY;
+        return from(this.cache.query(filters));
+      },
+      lookupRelays: DIRECTORY_RELAYS,
+    });
+
     // Initialize the IndexedDB cache
     this._cachePromise = openDB('applesauce-events').then(async (db) => {
       this.cache = new NostrIDB(db, {
@@ -67,7 +93,8 @@ export default class NostrDataService extends Service {
               e.kind === 5 ||
               e.kind === 10002 ||
               e.kind === 10063 ||
-              e.kind === 360
+              e.kind === 360 ||
+              e.kind === 9735
           );
 
           if (toCache.length > 0) {
@@ -210,19 +237,36 @@ export default class NostrDataService extends Service {
   }
 
   async loadPhotosForPlace(place) {
+    const entityId =
+      place && place.osmId && place.osmType
+        ? `osm:${place.osmType}:${place.osmId}`
+        : null;
+
+    // Skip the full reset if we're loading the same place again (e.g. from
+    // checkUpdates calling selectPlace a second time). This prevents tearing
+    // down timeline and profile subscriptions that are still in-flight.
+    if (entityId && entityId === this._currentPlaceEntityId) {
+      return;
+    }
+
     if (this._photosSub) {
       this._photosSub.unsubscribe();
       this._photosSub = null;
     }
 
-    this.placePhotos = [];
+    this._cleanupZapReceiptSubs();
+    this._clearZapRefreshTimer();
 
-    if (!place || !place.osmId || !place.osmType) {
+    this.placePhotos = [];
+    this.zapReceipts = {};
+    this._lastPhotoIds = new Set();
+    this._clearProfileSubs();
+    this._currentPlaceEntityId = entityId;
+
+    if (!entityId) {
       return;
     }
 
-    const entityId = `osm:${place.osmType}:${place.osmId}`;
-
     // Setup reactive store query
     this._photosSub = this.store
       .timeline([
@@ -233,6 +277,9 @@ export default class NostrDataService extends Service {
       ])
       .subscribe((events) => {
         this.placePhotos = events;
+        const pubkeys = [...new Set(events.map((e) => e.pubkey))];
+        this.loadProfiles(pubkeys);
+        this._scheduleZapReceiptRefresh(events);
       });
 
     try {
@@ -278,6 +325,84 @@ export default class NostrDataService extends Service {
       });
   }
 
+  async loadMyContributions(pubkey) {
+    if (!pubkey) return;
+
+    // Reset state and unsubscribe from any previous subscription
+    this.myContributionEvents = [];
+    if (this._contributionsSub) {
+      this._contributionsSub.unsubscribe();
+      this._contributionsSub = null;
+    }
+
+    const filters = [{ kinds: [360, 5], authors: [pubkey] }];
+
+    // 1. Set up reactive store subscription so the timeline updates as events arrive
+    this._contributionsSub = this.store
+      .timeline(filters)
+      .subscribe((events) => {
+        this.myContributionEvents = events;
+      });
+
+    // 2. Populate the store from the local Nostr IDB cache (instant)
+    try {
+      await this._cachePromise;
+
+      const cachedEvents = await this.cache.query(filters);
+
+      if (cachedEvents && cachedEvents.length > 0) {
+        for (const event of cachedEvents) {
+          this.store.add(event);
+        }
+      }
+    } catch (e) {
+      console.warn(
+        '[nostr-data] Failed to read my contributions from local Nostr IDB cache',
+        e
+      );
+    }
+
+    // 3. Request fresh events from the network in the background
+    this.nostrRelay.pool.request(this.activeReadRelays, filters).subscribe({
+      next: (event) => {
+        this.store.add(event);
+      },
+      error: (err) => {
+        console.error(
+          '[nostr-data] Error fetching my contribution events:',
+          err
+        );
+      },
+    });
+  }
+
+  loadProfiles(pubkeys) {
+    const newPubkeys = pubkeys.filter(
+      (pk) => pk && !this._profileModelSubs.has(pk)
+    );
+
+    for (const pubkey of newPubkeys) {
+      const sub = this.store
+        .model(ProfileModel, pubkey)
+        .subscribe((profileContent) => {
+          this.profiles = { ...this.profiles, [pubkey]: profileContent };
+        });
+      this._profileModelSubs.set(pubkey, sub);
+    }
+  }
+
+  getProfile(pubkey) {
+    return this.profiles[pubkey];
+  }
+
+  _clearProfileSubs() {
+    for (const sub of this._profileModelSubs.values()) {
+      sub.unsubscribe();
+    }
+    this._profileModelSubs.clear();
+    this.profiles = {};
+  }
+
   async loadProfile(pubkey) {
     if (!pubkey) return;
 
@@ -388,6 +513,109 @@ export default class NostrDataService extends Service {
     }
   }
 
+  _scheduleZapReceiptRefresh(events) {
+    const newIds = new Set(events.map((e) => e.id));
+
+    let changed = false;
+    if (newIds.size !== this._lastPhotoIds.size) {
+      changed = true;
+    } else {
+      for (const id of newIds) {
+        if (!this._lastPhotoIds.has(id)) {
+          changed = true;
+          break;
+        }
+      }
+    }
+
+    if (!changed) return;
+    this._lastPhotoIds = newIds;
+
+    this._clearZapRefreshTimer();
+    this._zapRefreshTimer = setTimeout(() => {
+      this._zapRefreshTimer = null;
+      this._refreshZapReceiptSubscription([...newIds]);
+    }, 100);
+  }
+
+  _clearZapRefreshTimer() {
+    if (this._zapRefreshTimer) {
+      clearTimeout(this._zapRefreshTimer);
+      this._zapRefreshTimer = null;
+    }
+  }
+
+  _refreshZapReceiptSubscription(photoIds) {
+    this._cleanupZapReceiptSubs();
+
+    if (!photoIds || photoIds.length === 0) return;
+
+    // Batch IDs into filters of <=100 to stay under relay REQ limits
+    const BATCH_SIZE = 100;
+    const filters = [];
+    for (let i = 0; i < photoIds.length; i += BATCH_SIZE) {
+      filters.push({
+        kinds: [9735],
+        '#e': photoIds.slice(i, i + BATCH_SIZE),
+      });
+    }
+
+    // Reactive local query — emits whenever matching events are in the store
+    this._zapReceiptsSub = this.store.timeline(filters).subscribe((events) => {
+      this._updateZapReceipts(events);
+    });
+
+    // Load from IDB cache (fire-and-forget — store.add triggers timeline)
+    this._cachePromise
+      .then(() => this.cache.query(filters))
+      .then((cachedEvents) => {
+        if (cachedEvents && cachedEvents.length > 0) {
+          for (const event of cachedEvents) {
+            this.store.add(event);
+          }
+        }
+      })
+      .catch((e) => {
+        console.warn('[nostr-data] Failed to read zap receipts from cache', e);
+      });
+
+    // Network request (fire-and-forget)
+    this._zapReceiptsNetworkSub = this.nostrRelay.pool
+      .request(this.activeReadRelays, filters)
+      .subscribe({
+        next: (event) => {
+          this.store.add(event);
+        },
+        error: (err) => {
+          console.error('[nostr-data] Error fetching zap receipts:', err);
+        },
+      });
+  }
+
+  _updateZapReceipts(events) {
+    const grouped = {};
+    for (const receipt of events) {
+      for (const tag of receipt.tags) {
+        if (tag[0] === 'e' && tag[1]) {
+          if (!grouped[tag[1]]) grouped[tag[1]] = [];
+          grouped[tag[1]].push(receipt);
+        }
+      }
+    }
+    this.zapReceipts = { ...this.zapReceipts, ...grouped };
+  }
+
+  _cleanupZapReceiptSubs() {
+    if (this._zapReceiptsSub) {
+      this._zapReceiptsSub.unsubscribe();
+      this._zapReceiptsSub = null;
+    }
+    if (this._zapReceiptsNetworkSub) {
+      this._zapReceiptsNetworkSub.unsubscribe();
+      this._zapReceiptsNetworkSub = null;
+    }
+  }
+
   _cleanupSubscriptions() {
     if (this._requestSub) {
       this._requestSub.unsubscribe();
@@ -409,11 +637,18 @@ export default class NostrDataService extends Service {
       this._photosSub.unsubscribe();
       this._photosSub = null;
     }
+    if (this._contributionsSub) {
+      this._contributionsSub.unsubscribe();
+      this._contributionsSub = null;
+    }
+    this._cleanupZapReceiptSubs();
+    this._clearZapRefreshTimer();
   }
 
   willDestroy() {
     super.willDestroy(...arguments);
     this._cleanupSubscriptions();
+    this._clearProfileSubs();
 
     if (this._stopPersisting) {
       this._stopPersisting();

app/services/nostr-zap.js

@@ -0,0 +1,244 @@
+import Service, { service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+import { ZapRequestFactory } from 'applesauce-common/factories';
+import {
+  getInvoice,
+  parseBolt11,
+  parseLNURLOrAddress,
+} from 'applesauce-common/helpers';
+import { getInboxes } from 'applesauce-core/helpers/mailboxes';
+import { firstValueFrom, timeout, catchError, of } from 'rxjs';
+
+const DEFAULT_ZAP_RELAYS = [
+  'wss://relay.damus.io',
+  'wss://nos.lol',
+  'wss://relay.primal.net',
+];
+
+const DIRECTORY_RELAYS = [
+  'wss://relay.primal.net',
+  'wss://nos.lol',
+  'wss://relay.damus.io',
+];
+
+const RELAY_FETCH_TIMEOUT = 10_000;
+
+export default class NostrZapService extends Service {
+  @service nostrAuth;
+  @service nostrData;
+  @service nostrRelay;
+
+  @tracked recipientRelays = null;
+
+  getLightningAddress(pubkey) {
+    const profile = this.nostrData.getProfile(pubkey);
+    return profile?.lud16 || profile?.lud06 || null;
+  }
+
+  async resolveLnurl(address) {
+    const url = parseLNURLOrAddress(address);
+    if (!url) throw new Error('Invalid lightning address or LNURL');
+
+    // eslint-disable-next-line warp-drive/no-external-request-patterns
+    const res = await fetch(url.toString());
+    if (!res.ok) {
+      throw new Error(`Failed to fetch LNURL pay endpoint: ${res.statusText}`);
+    }
+
+    const data = await res.json();
+    if (!data.callback) {
+      throw new Error('Invalid LNURL pay endpoint: missing callback');
+    }
+    if (!data.allowsNostr) {
+      throw new Error('This lightning address does not support Nostr zaps');
+    }
+
+    return {
+      callback: data.callback,
+      minSendable: data.minSendable ?? 1000,
+      maxSendable: data.maxSendable ?? 100_000_000_000,
+      allowsNostr: !!data.allowsNostr,
+      nostrPubkey: data.nostrPubkey,
+    };
+  }
+
+  async loadRecipientRelays(pubkey) {
+    if (!pubkey) return this._fallbackRelays();
+
+    // Check the store first — the event may already be cached
+    const fromStore = await this._getMailboxesFromStore(pubkey);
+    if (fromStore?.length) {
+      this.recipientRelays = fromStore;
+      return fromStore;
+    }
+
+    // Fetch from network if not in the store
+    const fetched = await this._fetchMailboxesFromNetwork(pubkey);
+    if (fetched?.length) {
+      this.recipientRelays = fetched;
+      return fetched;
+    }
+
+    // Fallback: sender's inbox relays + popular defaults
+    const fallback = this._fallbackRelays();
+    this.recipientRelays = fallback;
+    return fallback;
+  }
+
+  async _getMailboxesFromStore(pubkey) {
+    try {
+      const event = await firstValueFrom(
+        this.nostrData.store.replaceable(10002, pubkey).pipe(
+          timeout(500),
+          catchError(() => of(null))
+        )
+      );
+      if (event) return getInboxes(event);
+    } catch {
+      // Event not in store yet
+    }
+    return null;
+  }
+
+  async _fetchMailboxesFromNetwork(pubkey) {
+    const relays = this.nostrData.activeReadRelays?.length
+      ? this.nostrData.activeReadRelays
+      : DIRECTORY_RELAYS;
+
+    try {
+      const event = await firstValueFrom(
+        this.nostrRelay.pool
+          .request(relays, [{ kinds: [10002], authors: [pubkey] }])
+          .pipe(
+            timeout(RELAY_FETCH_TIMEOUT),
+            catchError(() => of(null))
+          )
+      );
+      if (event) {
+        this.nostrData.store.add(event);
+        return getInboxes(event);
+      }
+    } catch {
+      // Network fetch failed
+    }
+    return null;
+  }
+
+  _fallbackRelays() {
+    const senderRelays = this.nostrData.mailboxReadRelays || [];
+    return [...new Set([...senderRelays, ...DEFAULT_ZAP_RELAYS])].slice(0, 5);
+  }
+
+  getZapRelays() {
+    if (this.recipientRelays?.length) {
+      return this.recipientRelays.slice(0, 5);
+    }
+    return this._fallbackRelays();
+  }
+
+  async createZapRequest(photo, amountMsats, message) {
+    const event = this.nostrData.store.getEvent(photo.eventId);
+    if (!event) {
+      throw new Error('Photo event not found in store');
+    }
+
+    const relays = this.getZapRelays();
+    const signer = this.nostrAuth.signer;
+    if (!signer) {
+      throw new Error('Nostr signer not available. Please connect Nostr.');
+    }
+
+    return await ZapRequestFactory.event(event, amountMsats, relays)
+      .message(message || '')
+      .as(signer)
+      .sign();
+  }
+
+  async fetchInvoice(callbackUrl, zapRequest, amountMsats) {
+    const url = new URL(callbackUrl);
+    url.searchParams.set('amount', amountMsats.toString());
+    url.searchParams.set('nostr', JSON.stringify(zapRequest));
+    return await getInvoice(url);
+  }
+
+  parseInvoice(invoice) {
+    return parseBolt11(invoice);
+  }
+
+  subscribeForZapReceipt(zapRequest, photo, onReceipt) {
+    const eventId = photo.eventId;
+    const relays = this.getZapRelays();
+    const since = Math.floor(Date.now() / 1000) - 10;
+
+    return this.nostrRelay.pool
+      .subscription(relays, {
+        kinds: [9735],
+        '#e': [eventId],
+        since,
+      })
+      .subscribe({
+        next: (event) => {
+          this.nostrData.store.add(event);
+
+          const descTag = event.tags.find((t) => t[0] === 'description');
+          if (!descTag) return;
+
+          try {
+            const req = JSON.parse(descTag[1]);
+            if (req.id === zapRequest.id) {
+              onReceipt(event);
+            }
+          } catch {
+            // Invalid JSON in description tag
+          }
+        },
+        error: (err) => {
+          console.error('[nostr-zap] Receipt subscription error:', err);
+        },
+      });
+  }
+
+  hasWebLN() {
+    return typeof window !== 'undefined' && typeof window.webln !== 'undefined';
+  }
+
+  async payWithWebln(invoice) {
+    if (!this.hasWebLN()) throw new Error('WebLN not available');
+    await window.webln.enable();
+    return await window.webln.sendPayment(invoice);
+  }
+
+  async zap(photo, amountMsats, message) {
+    const pubkey = photo?.pubkey;
+    if (!pubkey) throw new Error('Photo has no pubkey');
+
+    // Ensure recipient relays are loaded before building the zap request
+    if (!this.recipientRelays) {
+      await this.loadRecipientRelays(pubkey);
+    }
+
+    const address = this.getLightningAddress(pubkey);
+    if (!address) {
+      throw new Error(
+        'This user has no lightning address set in their profile'
+      );
+    }
+
+    const lnurl = await this.resolveLnurl(address);
+
+    if (amountMsats < lnurl.minSendable || amountMsats > lnurl.maxSendable) {
+      throw new Error(
+        `Amount must be between ${lnurl.minSendable} and ${lnurl.maxSendable} millisats`
+      );
+    }
+
+    const zapRequest = await this.createZapRequest(photo, amountMsats, message);
+    const invoice = await this.fetchInvoice(
+      lnurl.callback,
+      zapRequest,
+      amountMsats
+    );
+
+    return { invoice, zapRequest };
+  }
+}

app/services/osm.js

@@ -4,12 +4,110 @@ import { getCategoryById } from '../utils/poi-categories';
 
 export default class OsmService extends Service {
   @service settings;
+  @service localForage;
 
   controller = null;
   cachedResults = null;
   lastQueryKey = null;
   cachedPlaces = new Map();
 
+  // Long-term cache for OSM place metadata, persisted to IndexedDB (via the
+  // `localForage` service) so that names and basic info survive across
+  // sessions and can be rendered instantly without waiting on the OSM API.
+  // Entries are refreshed in the background.
+  static STORE_NAME = 'osm-cache';
+  static CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+  static IN_MEMORY_TTL_MS = 10000; // 10 seconds
+
+  _buildCacheKey(osmType, osmId) {
+    return `${osmType}:${osmId}`;
+  }
+
+  async _readLocalCache(osmType, osmId) {
+    const key = this._buildCacheKey(osmType, osmId);
+    try {
+      const raw = await this.localForage.get(OsmService.STORE_NAME, key);
+      if (!raw) return null;
+      const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw;
+      if (
+        !parsed ||
+        typeof parsed.timestamp !== 'number' ||
+        Date.now() - parsed.timestamp > OsmService.CACHE_TTL_MS
+      ) {
+        await this.localForage.remove(OsmService.STORE_NAME, key);
+        return null;
+      }
+      return parsed.data;
+    } catch {
+      try {
+        await this.localForage.remove(OsmService.STORE_NAME, key);
+      } catch {
+        // ignore
+      }
+      return null;
+    }
+  }
+
+  async _writeLocalCache(osmType, osmId, data) {
+    if (!data) return;
+    const key = this._buildCacheKey(osmType, osmId);
+    try {
+      await this.localForage.set(OsmService.STORE_NAME, key, {
+        data,
+        timestamp: Date.now(),
+      });
+    } catch (e) {
+      console.debug('[osm] Failed to write IndexedDB cache entry', e);
+    }
+  }
+
+  /**
+   * Async lookup for an OSM place. Checks the short-lived in-memory cache
+   * first, then the persistent IndexedDB cache. Returns `null` if not
+   * cached.
+   *
+   * Use this for instant rendering (e.g. place names in a list) and fall
+   * back to `fetchOsmObject` for a fresh fetch + background refresh.
+   *
+   * @param {string} osmType 'node' | 'way' | 'relation'
+   * @param {string} osmId
+   * @returns {Promise<object|null>} Normalized OSM place data
+   */
+  async getCachedOsmObject(osmType, osmId) {
+    if (!osmType || !osmId) return null;
+
+    const cacheKey = this._buildCacheKey(osmType, osmId);
+    const memoryEntry = this.cachedPlaces.get(cacheKey);
+    if (
+      memoryEntry &&
+      Date.now() - memoryEntry.timestamp < OsmService.IN_MEMORY_TTL_MS
+    ) {
+      return memoryEntry.data;
+    }
+
+    return this._readLocalCache(osmType, osmId);
+  }
+
+  _storeInMemoryAndLocalStorage(cacheKey, osmType, osmId, data) {
+    if (!data || !data.title) {
+      console.debug(
+        `[osm] Skipping cache write for ${cacheKey}: data has no title`
+      );
+      return;
+    }
+
+    this.cachedPlaces.set(cacheKey, { data, timestamp: Date.now() });
+
+    // Auto-evict from the short-lived in-memory cache so it doesn't grow unbounded.
+    setTimeout(() => {
+      this.cachedPlaces.delete(cacheKey);
+    }, OsmService.IN_MEMORY_TTL_MS);
+
+    // Fire-and-forget the persistent write — the in-memory cache covers the
+    // next immediate read, and the IndexedDB write happens in the background.
+    void this._writeLocalCache(osmType, osmId, data);
+  }
+
   cancelAll() {
     if (this.controller) {
       this.controller.abort();
@@ -230,16 +328,57 @@ out center;
     return this.normalizePoi(data.elements[0]);
   }
 
-  async fetchOsmObject(osmId, osmType) {
+  async fetchOsmObject(osmId, osmType, { forceFresh = false } = {}) {
     if (!osmId || !osmType) return null;
 
-    const cacheKey = `${osmType}:${osmId}`;
+    const cacheKey = this._buildCacheKey(osmType, osmId);
+
+    // Force a fresh fetch from the API, bypassing the cache. Used by callers
+    // that need genuinely current data (e.g. storage.refreshPlace, which
+    // diffs the bookmark against freshly-fetched OSM data).
+    if (forceFresh) {
+      return this._fetchAndCacheOsmObject(osmId, osmType, cacheKey);
+    }
+
+    // Cached-first path: return the in-memory entry if it's still warm.
     const cached = this.cachedPlaces.get(cacheKey);
-    if (cached && Date.now() - cached.timestamp < 10000) {
+    if (cached && Date.now() - cached.timestamp < OsmService.IN_MEMORY_TTL_MS) {
       console.debug(`Using in-memory cached OSM object for ${cacheKey}`);
       return cached.data;
     }
 
+    // Otherwise return the persistent IndexedDB entry and refresh in the
+    // background so the next visit is fresh.
+    const localCached = await this._readLocalCache(osmType, osmId);
+    if (localCached) {
+      console.debug(`Using IndexedDB cached OSM object for ${cacheKey}`);
+      // Refresh in the background, but don't block the caller.
+      this._refreshOsmObject(osmId, osmType, cacheKey).catch((e) => {
+        console.debug('[osm] Background refresh failed for', cacheKey, e);
+      });
+      return localCached;
+    }
+
+    return this._fetchAndCacheOsmObject(osmId, osmType, cacheKey);
+  }
+
+  async _refreshOsmObject(osmId, osmType, cacheKey) {
+    const fresh = await this._fetchOsmObjectFromApi(osmId, osmType);
+    if (fresh) {
+      this._storeInMemoryAndLocalStorage(cacheKey, osmType, osmId, fresh);
+    }
+    return fresh;
+  }
+
+  async _fetchAndCacheOsmObject(osmId, osmType, cacheKey) {
+    const data = await this._fetchOsmObjectFromApi(osmId, osmType);
+    if (data) {
+      this._storeInMemoryAndLocalStorage(cacheKey, osmType, osmId, data);
+    }
+    return data;
+  }
+
+  async _fetchOsmObjectFromApi(osmId, osmType) {
     let url;
     if (osmType === 'node') {
       url = `https://www.openstreetmap.org/api/0.6/node/${osmId}.json`;
@@ -263,29 +402,100 @@ out center;
       }
 
       const data = await res.json();
-      const normalizedData = this.normalizeOsmApiData(
+      return this.normalizeOsmApiData(data.elements, osmId, osmType);
-        data.elements,
-        osmId,
-        osmType
-      );
-
-      this.cachedPlaces.set(cacheKey, {
-        data: normalizedData,
-        timestamp: Date.now(),
-      });
-
-      // Cleanup cache entry automatically after 10 seconds
-      setTimeout(() => {
-        this.cachedPlaces.delete(cacheKey);
-      }, 10000);
-
-      return normalizedData;
     } catch (e) {
       console.error('Failed to fetch OSM object:', e);
       return null;
     }
   }
 
+  /**
+   * Batch-fetches multiple OSM objects, using cached data where available and
+   * only making network requests for uncached IDs.
+   *
+   * @param {Array<{osmType: string, osmId: string}>} items
+   * @returns {Promise<Map<string, object>>} Map keyed by `${osmType}:${osmId}`
+   */
+  async fetchOsmObjectsBatch(items) {
+    const result = new Map();
+    if (!items || items.length === 0) return result;
+
+    // 1. Collect whatever is already cached
+    const missing = [];
+    for (const { osmType, osmId } of items) {
+      if (!osmType || !osmId) continue;
+      const cacheKey = this._buildCacheKey(osmType, osmId);
+      const cached = await this.getCachedOsmObject(osmType, osmId);
+      if (cached) {
+        result.set(cacheKey, cached);
+      } else {
+        missing.push({ osmType, osmId, cacheKey });
+      }
+    }
+
+    if (missing.length === 0) return result;
+
+    // 2. Group missing items by OSM type for batched API requests
+    const byType = new Map();
+    for (const item of missing) {
+      if (!byType.has(item.osmType)) byType.set(item.osmType, []);
+      byType.get(item.osmType).push(item);
+    }
+
+    // 3. Fetch each type group from the OSM API (one request per type)
+    const fetchPromises = [];
+    for (const [osmType, group] of byType) {
+      fetchPromises.push(this._fetchOsmObjectsByType(osmType, group, result));
+    }
+
+    await Promise.allSettled(fetchPromises);
+    return result;
+  }
+
+  async _fetchOsmObjectsByType(osmType, group, result) {
+    // OSM API supports fetching multiple elements of the same type in a single
+    // request using comma-separated IDs (max ~50 per request).
+    //
+    // Note: the multi-fetch endpoint returns ways/relations WITHOUT their child
+    // nodes, so normalized data may lack lat/lon and geometry. We intentionally
+    // do NOT write these results to the general OSM cache — only the returned
+    // Map is used by the caller (the contributions service manages its own
+    // name cache). This prevents incomplete data from breaking place detail
+    // navigation, which needs the full single-object endpoint.
+    const MAX_IDS_PER_REQUEST = 50;
+
+    for (let i = 0; i < group.length; i += MAX_IDS_PER_REQUEST) {
+      const chunk = group.slice(i, i + MAX_IDS_PER_REQUEST);
+      const idsParam = chunk.map((c) => c.osmId).join(',');
+      const plural = osmType === 'way' ? 'ways' : osmType + 's';
+      const url = `https://www.openstreetmap.org/api/0.6/${plural}.json?${plural}=${idsParam}`;
+
+      try {
+        const res = await this.fetchWithRetry(url);
+        if (!res.ok) {
+          console.warn(
+            `[osm] Batch fetch failed for ${osmType} (${res.status})`,
+            idsParam
+          );
+          continue;
+        }
+        const data = await res.json();
+        for (const item of chunk) {
+          const normalized = this.normalizeOsmApiData(
+            data.elements,
+            item.osmId,
+            osmType
+          );
+          if (normalized) {
+            result.set(item.cacheKey, normalized);
+          }
+        }
+      } catch (e) {
+        console.error(`[osm] Batch fetch error for ${osmType}:`, e);
+      }
+    }
+  }
+
   normalizeOsmApiData(elements, targetId, targetType) {
     if (!elements || elements.length === 0) return null;
 

app/services/storage.js

@@ -426,7 +426,8 @@ export default class StorageService extends Service {
       console.debug(`Checking for updates for ${place.title} (${place.osmId})`);
       const freshData = await this.osm.fetchOsmObject(
         place.osmId,
-        place.osmType
+        place.osmType,
+        { forceFresh: true }
       );
 
       if (!freshData) {

app/styles/app.css

@@ -752,6 +752,25 @@ select.form-control {
   text-decoration: underline;
 }
 
+.about-section p + ul {
+  margin-top: 0.25rem;
+}
+
+.about-section ul {
+  padding-inline-start: 1.2em;
+  margin: 0.5rem 0 0;
+}
+
+.about-section li {
+  padding-inline-start: 0.5rem;
+  margin-block: 0.15rem;
+}
+
+.about-section li::marker {
+  content: '♥';
+  color: #898989;
+}
+
 .btn-full {
   width: 100%;
 }
@@ -1074,6 +1093,11 @@ abbr[title] {
 }
 
 .btn {
+  /* TODO: remove this scoped rule in favor of a global box-sizing reset
+     (e.g. `*, *::before, *::after { box-sizing: border-box; }`) at the top
+     of this file. Needed so `width: 100%` .btn elements like <a class="btn-full">
+     include padding within their width like <button> does. */
+  box-sizing: border-box;
   padding: 0.6rem 1.2rem;
   border-radius: 4px;
   cursor: pointer;
@@ -2132,17 +2156,68 @@ button.create-place {
   background: #f0f0f0;
 }
 
-/* Actions button in photo gallery */
+/* Photo gallery header (actions button + uploader info) */
-.photo-gallery-overlay .actions-btn-container {
+.photo-gallery-overlay .photo-gallery-header {
   position: absolute;
   top: 0.5rem;
-  left: 0.5rem;
+  left: 1rem;
-  width: 48px;
-  height: 48px;
   z-index: 10;
   display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 0.25rem;
+}
+
+.photo-gallery-overlay .photo-gallery-header .actions-btn-container {
+  position: relative;
+  z-index: 2;
+  height: 48px;
+  display: flex;
   align-items: center;
-  justify-content: center;
+  justify-content: flex-start;
+  flex-shrink: 0;
+}
+
+/* Uploader info (name + date) in photo gallery */
+.photo-gallery-overlay .photo-gallery-uploader-info {
+  color: rgb(255 255 255 / 90%);
+  display: flex;
+  flex-direction: column;
+  gap: 0.1rem;
+  pointer-events: none;
+  text-shadow: 0 1px 2px rgb(0 0 0 / 60%);
+  max-width: calc(100vw - 4rem);
+  overflow: hidden;
+}
+
+.photo-gallery-overlay .photo-gallery-uploader-name {
+  font-size: 0.95rem;
+  font-weight: 600;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.photo-gallery-overlay .photo-gallery-uploader-date {
+  font-size: 0.8rem;
+  color: rgb(255 255 255 / 70%);
+  white-space: nowrap;
+}
+
+@media (width <= 768px) {
+  .photo-gallery-overlay .photo-gallery-header {
+    flex-direction: row;
+    align-items: flex-start;
+    gap: 0.5rem;
+    left: 0.5rem;
+  }
+
+  .photo-gallery-overlay .photo-gallery-uploader-info {
+    flex-direction: row;
+    align-items: center;
+    gap: 0.35rem;
+    align-self: center;
+  }
 }
 
 /* Snappy slide-in from left (Desktop) */
@@ -2258,3 +2333,247 @@ button.create-place {
   justify-content: center;
   padding: 4rem 1rem;
 }
+
+/* Contributions Timeline */
+.contributions-list {
+  list-style: none;
+  padding: 0;
+  margin: -1rem -1rem 0;
+}
+
+.contribution-item {
+  width: 100%;
+  text-align: left;
+  border: none;
+  border-bottom: 1px solid var(--divider-color);
+  background: var(--primary-background-color);
+  color: var(--body-text-color);
+  padding: 0.75rem 1rem;
+  cursor: pointer;
+  transition: background 0.2s;
+  font-family: inherit;
+  display: flex;
+  align-items: flex-start;
+  gap: 12px;
+}
+
+.contribution-item:hover {
+  background: var(--hover-bg);
+}
+
+.contribution-thumb {
+  position: relative;
+  flex-shrink: 0;
+  width: 56px;
+  height: 56px;
+  border-radius: 6px;
+  overflow: hidden;
+  background: #f0f0f0;
+}
+
+.contribution-thumb img {
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+  display: block;
+}
+
+.contribution-thumb-badge {
+  position: absolute;
+  bottom: 2px;
+  right: 2px;
+  background: rgb(0 0 0 / 65%);
+  color: #fff;
+  font-size: 0.7rem;
+  font-weight: bold;
+  padding: 1px 4px;
+  border-radius: 4px;
+}
+
+.contribution-info {
+  flex: 1;
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+
+.contribution-place {
+  font-size: 1rem;
+  font-weight: bold;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.contribution-name-loading {
+  color: #999;
+  font-weight: normal;
+  font-style: italic;
+}
+
+.contribution-meta {
+  color: #666;
+  font-size: 0.85rem;
+}
+
+.contribution-tags {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+  margin-top: 4px;
+}
+
+.contribution-tag {
+  background: #f0f0f0;
+  color: #555;
+  font-size: 0.72rem;
+  padding: 2px 6px;
+  border-radius: 10px;
+}
+
+/* Generic modal heading reset (shared by all modals) */
+.modal-content h2,
+.modal-content h3 {
+  margin-top: 0;
+}
+
+/* Zap Photo Modal — scoped, nested styles */
+.zap-photo-modal {
+  text-align: left;
+
+  & h2 {
+    margin-bottom: 1rem;
+    padding-bottom: 0.75rem;
+    border-bottom: 1px solid var(--divider-color);
+  }
+
+  & section.status {
+    padding-bottom: 0.75rem;
+    margin-bottom: 1.5rem;
+    border-bottom: 1px solid var(--divider-color);
+  }
+
+  & section.slider {
+    text-align: center;
+    margin-bottom: 1.5rem;
+  }
+
+  & .amount-display {
+    display: flex;
+    align-items: baseline;
+    justify-content: center;
+    gap: 0.4rem;
+    margin-bottom: 0.75rem;
+  }
+
+  & .amount-value {
+    font-size: 2rem;
+    font-weight: 700;
+    color: var(--default-list-color);
+  }
+
+  & .amount-unit {
+    font-size: 0.9rem;
+    color: var(--body-text-color);
+    opacity: 0.7;
+  }
+
+  & .zap-slider {
+    width: 100%;
+    accent-color: var(--default-list-color);
+    cursor: pointer;
+  }
+
+  & .slider-ticks {
+    display: flex;
+    justify-content: space-between;
+    font-size: 0.85rem;
+    color: var(--body-text-color);
+    opacity: 0.5;
+    padding: 0 0.25rem;
+  }
+
+  & .form-group {
+    margin-bottom: 1.5rem;
+  }
+
+  & .lightning-address {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+  }
+
+  & .lightning-badge {
+    background: var(--default-list-color);
+    color: white;
+    font-size: 0.7rem;
+    font-weight: 600;
+    padding: 2px 8px;
+    border-radius: 10px;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+  }
+
+  & .lightning-address-text {
+    font-family: monospace;
+    font-size: 0.9rem;
+    color: var(--body-text-color);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  & .zap-pay-prompt {
+    text-align: center;
+  }
+
+  & .qr-code-container {
+    margin-bottom: 1.5rem;
+  }
+
+  & .btn-full + .btn-full {
+    margin-top: 0.75rem;
+  }
+
+  & .alert-error {
+    font-size: 0.95rem;
+  }
+
+  & .meta-info {
+    font-size: 0.95rem;
+  }
+
+  & .centered {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    text-align: center;
+    gap: 1rem;
+    padding-top: 1.5rem;
+  }
+
+  & .success {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    text-align: center;
+    gap: 0.5rem;
+  }
+
+  & .success-icon {
+    font-size: 3rem;
+  }
+
+  & .success h4 {
+    margin: 0;
+    font-size: 1.2rem;
+  }
+
+  & .success p {
+    margin: 0;
+    margin-bottom: 1.5rem;
+    font-size: 0.9rem;
+    color: var(--body-text-color);
+  }
+}

app/templates/application.gjs

@@ -13,7 +13,7 @@ export default class ApplicationComponent extends Component {
   @service router;
 
   get isSidebarOpen() {
-    // We consider the sidebar "open" if we are in search, menu, lists or place routes AND it's visible.
+    // We consider the sidebar "open" if we are in search, menu, lists, contributions or place routes AND it's visible.
     // This helps the map know if it should shift the center or adjust view.
     const name = this.router.currentRouteName;
     return (
@@ -22,6 +22,7 @@ export default class ApplicationComponent extends Component {
         name === 'place.new' ||
         name === 'search' ||
         name === 'menu' ||
+        name === 'contributions' ||
         name.startsWith('lists'))
     );
   }
@@ -49,11 +50,16 @@ export default class ApplicationComponent extends Component {
       name === 'search' ||
       name === 'place' ||
       name === 'menu' ||
+      name === 'contributions' ||
       name.startsWith('lists')
     ) {
       this.mapUi.clearSelection();
       this.mapUi.hideSidebar();
-      if (name === 'menu' || name.startsWith('lists')) {
+      if (
+        name === 'menu' ||
+        name === 'contributions' ||
+        name.startsWith('lists')
+      ) {
         this.router.transitionTo('index');
       } else if (name === 'place') {
         if (this.mapUi.returnToSearch && this.mapUi.currentSearch) {

app/templates/contributions.gjs

@@ -0,0 +1,16 @@
+import ContributionsTimeline from '#components/contributions-timeline';
+
+<template>
+  {{#if @controller.mapUi.isSidebarVisible}}
+    <ContributionsTimeline
+      @items={{@controller.items}}
+      @isLoading={{@controller.loadContributionsTask.isRunning}}
+      @isConnected={{@controller.isConnected}}
+      @scrollTop={{@controller.scrollTop}}
+      @onSelect={{@controller.selectContribution}}
+      @onBack={{@controller.backToMenu}}
+      @onClose={{@controller.close}}
+      @onNostrConnected={{@controller.onNostrConnected}}
+    />
+  {{/if}}
+</template>

app/templates/place.gjs

@@ -81,7 +81,11 @@ export default class PlaceTemplate extends Component {
       if (this.mapUi.returnToRoute) {
         this.mapUi.showSidebar();
         const { name, model } = this.mapUi.returnToRoute;
+        if (model !== undefined) {
           this.router.transitionTo(name, model);
+        } else {
+          this.router.transitionTo(name);
+        }
       }
       // If we have an active search context, return to it (UP navigation)
       else if (this.mapUi.returnToSearch && this.mapUi.currentSearch) {

app/utils/contributions.js

@@ -0,0 +1,232 @@
+/**
+ * Utilities for grouping the user's Nostr contribution events into timeline entries.
+ *
+ * A contribution "entry" groups one or more related Nostr events that are part of the
+ * same logical action (e.g. uploading several photos of the same place in quick
+ * succession). Entries are ordered newest-first.
+ */
+
+import { tracked } from '@glimmer/tracking';
+
+const HOUR_IN_SECONDS = 60 * 60;
+
+/**
+ * A single contribution timeline entry.
+ *
+ * `placeName` and `placeNameLoading` are tracked so that mutating them after
+ * the entry has been rendered (e.g. when the background OSM batch fetch
+ * resolves a place name) re-renders the consuming component. The remaining
+ * fields are static data and do not need to be tracked.
+ */
+export class ContributionEntry {
+  type = 'photo';
+  placeIdentifier;
+  osmType;
+  osmId;
+  photos;
+  createdAt;
+  eventCount;
+  @tracked placeName = null;
+  @tracked placeNameLoading = true;
+
+  constructor({
+    placeIdentifier,
+    osmType,
+    osmId,
+    photos,
+    createdAt,
+    eventCount,
+  }) {
+    this.placeIdentifier = placeIdentifier;
+    this.osmType = osmType;
+    this.osmId = osmId;
+    this.photos = photos;
+    this.createdAt = createdAt;
+    this.eventCount = eventCount;
+  }
+}
+
+/**
+ * Parses a single kind 360 (Place Photo) event's `imeta` tag into a photo object.
+ * Reuses the same field shape as `parsePlacePhotos` in `utils/nostr.js` but operates
+ * on a single event (the NIP mandates exactly one `imeta` tag per event).
+ *
+ * @param {object} event A NIP-360 (kind 360) Nostr event
+ * @returns {object|null} A photo object, or null if no usable `imeta` was found
+ */
+function parsePhotoFromEvent(event) {
+  const tags = event.tags || [];
+
+  const eventTags = tags
+    .filter((t) => t[0] === 't')
+    .map((t) => t[1])
+    .filter(Boolean);
+
+  const imeta = tags.find((t) => t[0] === 'imeta');
+  if (!imeta) return null;
+
+  let url = null;
+  let thumbUrl = null;
+  let blurhash = null;
+  let isLandscape = false;
+  let aspectRatio = 16 / 9;
+  let altText = null;
+
+  for (const tag of imeta.slice(1)) {
+    if (tag.startsWith('url ')) {
+      url = tag.substring(4);
+    } else if (tag.startsWith('thumb ')) {
+      thumbUrl = tag.substring(6);
+    } else if (tag.startsWith('blurhash ')) {
+      blurhash = tag.substring(9);
+    } else if (tag.startsWith('dim ')) {
+      const [width, height] = tag.substring(4).split('x').map(Number);
+      if (width && height) {
+        aspectRatio = width / height;
+        if (width > height) isLandscape = true;
+      }
+    } else if (tag.startsWith('alt ')) {
+      const alt = tag.substring(4).trim();
+      altText = alt === 'A photo of a place' ? null : alt || null;
+    }
+  }
+
+  if (!url) return null;
+
+  const placeIdentifier = tags.find((t) => t[0] === 'i')?.[1];
+  const publishedAtRaw = tags.find((t) => t[0] === 'published_at')?.[1];
+  const publishedAt = publishedAtRaw ? Number(publishedAtRaw) : null;
+
+  return {
+    eventId: event.id,
+    pubkey: event.pubkey,
+    createdAt: event.created_at,
+    publishedAt: publishedAt && publishedAt > 0 ? publishedAt : null,
+    url,
+    thumbUrl,
+    blurhash,
+    isLandscape,
+    aspectRatio,
+    placeIdentifier,
+    tags: eventTags,
+    alt: altText,
+  };
+}
+
+/**
+ * Applies kind 5 deletion events to a list of kind 360 events, returning the
+ * surviving kind 360 events.
+ *
+ * @param {Array} events Mixed kind 360 and kind 5 events
+ * @returns {Array} Surviving kind 360 events
+ */
+function applyDeletions(events) {
+  const deletedIds = new Set();
+  for (const event of events) {
+    if (event.kind === 5) {
+      for (const tag of event.tags || []) {
+        if (tag[0] === 'e' && tag[1]) deletedIds.add(tag[1]);
+      }
+    }
+  }
+  return events.filter(
+    (event) => event.kind === 360 && !deletedIds.has(event.id)
+  );
+}
+
+/**
+ * Groups kind 360 (Place Photo) events into contribution entries.
+ *
+ * Grouping rules:
+ *   1. Events are grouped by their OSM entity identifier (the `i` tag).
+ *   2. Within an entity, events are sub-grouped by time proximity: a new
+ *      sub-group starts whenever the gap between two consecutive events
+ *      exceeds `thresholdHours`.
+ *   3. Each sub-group becomes a single contribution entry with one or more
+ *      photos, sorted by `created_at` descending (newest entry first).
+ *
+ * @param {Array} events Mixed kind 360 / kind 5 events from the user
+ * @param {number} [thresholdHours=3] Max gap in hours within a sub-group
+ * @returns {Array} Sorted contribution entries (newest first)
+ */
+export function groupPhotoContributions(events, thresholdHours = 3) {
+  if (!events || events.length === 0) return [];
+
+  const photoEvents = applyDeletions(events);
+  if (photoEvents.length === 0) return [];
+
+  // Group by OSM entity identifier
+  const byEntity = new Map();
+  for (const event of photoEvents) {
+    const entityTag = (event.tags || []).find((t) => t[0] === 'i');
+    const entityId = entityTag?.[1];
+    if (!entityId) continue;
+
+    if (!byEntity.has(entityId)) byEntity.set(entityId, []);
+    byEntity.get(entityId).push(event);
+  }
+
+  const thresholdSeconds = thresholdHours * HOUR_IN_SECONDS;
+  const entries = [];
+
+  for (const [entityId, entityEvents] of byEntity) {
+    // Sort newest-first within the entity
+    const sorted = [...entityEvents].sort(
+      (a, b) => b.created_at - a.created_at
+    );
+
+    // Walk newest -> oldest, starting a new sub-group when the gap to the
+    // previous event exceeds the threshold.
+    let currentGroup = [];
+    let prevTime = null;
+
+    for (const event of sorted) {
+      if (prevTime !== null && prevTime - event.created_at > thresholdSeconds) {
+        entries.push(buildEntry(entityId, currentGroup));
+        currentGroup = [];
+      }
+      currentGroup.push(event);
+      prevTime = event.created_at;
+    }
+    if (currentGroup.length > 0) {
+      entries.push(buildEntry(entityId, currentGroup));
+    }
+  }
+
+  // Sort entries by their newest event's created_at, descending. Entries with
+  // no usable photos (e.g. malformed imeta) are filtered out.
+  return entries
+    .filter((e) => e.photos.length > 0)
+    .sort((a, b) => b.createdAt - a.createdAt);
+}
+
+/**
+ * Builds a single contribution entry object from a group of events for the
+ * same OSM entity.
+ *
+ * @param {string} placeIdentifier e.g. "osm:node:123456"
+ * @param {Array} events Kind 360 events in this sub-group
+ * @returns {object} Contribution entry
+ */
+function buildEntry(placeIdentifier, events) {
+  const photos = events
+    .map(parsePhotoFromEvent)
+    .filter(Boolean)
+    .sort((a, b) => a.createdAt - b.createdAt);
+
+  const createdAt = events.reduce(
+    (max, e) => (e.created_at > max ? e.created_at : max),
+    0
+  );
+
+  const [, osmType, osmId] = placeIdentifier.split(':');
+
+  return new ContributionEntry({
+    placeIdentifier,
+    osmType,
+    osmId,
+    photos,
+    createdAt,
+    eventCount: events.length,
+  });
+}

app/utils/format-text.js

@@ -12,3 +12,23 @@ export function capitalize(text) {
   if (typeof text !== 'string' || !text) return '';
   return text.charAt(0).toUpperCase() + text.slice(1);
 }
+
+export function formatRelativeDate(timestamp) {
+  if (!timestamp) return '';
+  const date = new Date(timestamp * 1000);
+  const now = new Date();
+  const diffMs = now - date;
+  const diffMin = Math.floor(diffMs / 60000);
+  const diffHr = Math.floor(diffMin / 60);
+  const diffDay = Math.floor(diffHr / 24);
+
+  if (diffMin < 1) return 'just now';
+  if (diffMin < 60) return `${diffMin} min ago`;
+  if (diffHr < 24) return `${diffHr} hr ago`;
+  if (diffDay < 7) return `${diffDay} day${diffDay === 1 ? '' : 's'} ago`;
+  return date.toLocaleDateString(undefined, {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+  });
+}

app/utils/nostr.js

@@ -69,6 +69,10 @@ export function parsePlacePhotos(events) {
       let aspectRatio = 16 / 9; // default
       let altText = null;
       let placeIdentifier = event.tags.find((t) => t[0] === 'i')?.[1];
+      const publishedAtRaw = event.tags.find(
+        (t) => t[0] === 'published_at'
+      )?.[1];
+      const publishedAt = publishedAtRaw ? Number(publishedAtRaw) : null;
 
       for (const tag of imeta.slice(1)) {
         if (tag.startsWith('url ')) {
@@ -98,6 +102,7 @@ export function parsePlacePhotos(events) {
           eventId: event.id,
           pubkey: event.pubkey,
           createdAt: event.created_at,
+          publishedAt: publishedAt && publishedAt > 0 ? publishedAt : null,
           url,
           thumbUrl,
           blurhash,

package.json

@@ -1,6 +1,6 @@
 {
   "name": "marco",
-  "version": "1.26.2",
+  "version": "1.29.1",
   "private": true,
   "description": "Unhosted maps app",
   "repository": {
@@ -104,15 +104,19 @@
   "dependencies": {
     "@noble/hashes": "^2.3.0",
     "@waysidemapping/pinhead": "^15.25.0",
+    "applesauce-common": "^6.2.0",
     "applesauce-core": "^6.2.0",
+    "applesauce-loaders": "^6.2.0",
     "applesauce-relay": "^6.2.1",
     "applesauce-signers": "^6.2.2",
     "blurhash": "^2.0.5",
     "ember-concurrency": "^5.2.0",
     "ember-lifeline": "^7.1.0",
+    "localforage": "^1.10.0",
     "nostr-idb": "^5.1.0",
     "oauth2-pkce": "^3.0.0",
     "qrcode": "^1.5.4",
     "rxjs": "^7.8.2"
-  }
+  },
+  "packageManager": "pnpm@11.22.0+sha512.1ff870c4c6133dfd88fb2afc46dd13d47f09c9794b438c6fdb47ca98caf3bc16381ee0be93a091b8e3824cf01f889f46d7d9e20910fb0be1ab0fb5baa80dd621"
 }

pnpm-workspace.yaml

@@ -1,2 +1,5 @@
+allowBuilds:
+  core-js: true
+  esbuild: true
 patchedDependencies:
   ember-concurrency@5.2.0: patches/ember-concurrency@5.2.0.patch

release/index.html

@@ -39,8 +39,8 @@
     <meta name="msapplication-TileColor" content="#F6E9A6">
     <meta name="msapplication-TileImage" content="/icons/icon-144.png">
 
-  <script type="module" crossorigin src="/assets/main-CAv0oB3R.js"></script>
+  <script type="module" crossorigin src="/assets/main-D_udYDYo.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/main-CIu0qcV7.css">
+  <link rel="stylesheet" crossorigin href="/assets/main-DWxZH-9E.css">
 </head>
   <body>
     <div id="modal-portal"></div>

skills-lock.json

@@ -4,17 +4,26 @@
     "ember-best-practices": {
       "source": "nullvoxpopuli/agent-skills",
       "sourceType": "github",
-      "computedHash": "7909c3def6c4ddefb358d1973cf724269ede9f6cdba1dd2888e4e6072a897f3e"
+      "skillPath": "skills/ember-best-practices/SKILL.md",
+      "computedHash": "34e82668e2fa1e6b025ac8cf1015634484bf5d8fbc80e8aa642489d2df79498c"
     },
     "nak": {
       "source": "soapbox-pub/nostr-skills",
       "sourceType": "github",
+      "skillPath": "skills/nak/SKILL.md",
       "computedHash": "710d3f3945ff421ed2b7f40ecd32c5e263bc029d43fe8f4fd1491a8013c7389a"
     },
     "nostr": {
       "source": "soapbox-pub/nostr-skills",
       "sourceType": "github",
+      "skillPath": "skills/nostr/SKILL.md",
       "computedHash": "e1e6834c18d18a5deef4cd9555f6eee0fc0b968acf1c619253999eda76beab8e"
+    },
+    "nostr-zap-integration": {
+      "source": "accolver/skill-maker",
+      "sourceType": "github",
+      "skillPath": "nostr-zap-integration/SKILL.md",
+      "computedHash": "5c0c9a97fb74b6b620340bdc522fc3e813dae34a2af87cfda764733d2632229c"
     }
   }
 }

tests/acceptance/contributions-test.js

@@ -0,0 +1,208 @@
+import { module, test } from 'qunit';
+import { visit, currentURL, click, waitFor } from '@ember/test-helpers';
+import { setupApplicationTest } from 'marco/tests/helpers';
+import Service from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+
+class MockOsmService extends Service {
+  fetchOsmObjectCalls = [];
+
+  async fetchOsmObject(id, type) {
+    this.fetchOsmObjectCalls.push({ id, type });
+    return {
+      osmId: String(id),
+      osmType: type,
+      lat: 1,
+      lon: 1,
+      osmTags: { name: 'Test Place', amenity: 'cafe' },
+      title: 'Test Place',
+    };
+  }
+
+  getCachedOsmObject() {
+    return Promise.resolve(null);
+  }
+}
+
+class MockStorageService extends Service {
+  initialSyncDone = true;
+  savedPlaces = [];
+  findPlaceById() {
+    return null;
+  }
+  isPlaceSaved() {
+    return false;
+  }
+  loadPlacesInBounds() {
+    return [];
+  }
+  get placesInView() {
+    return [];
+  }
+  rs = {
+    on: () => {},
+  };
+}
+
+class MockContributionsService extends Service {
+  @tracked items = [
+    {
+      type: 'photo',
+      placeIdentifier: 'osm:node:123',
+      osmType: 'node',
+      osmId: '123',
+      placeName: 'Test Place',
+      placeNameLoading: false,
+      createdAt: 2000,
+      photos: [
+        {
+          url: 'https://x.com/photo.jpg',
+          thumbUrl: 'https://x.com/thumb.jpg',
+          tags: ['food'],
+        },
+      ],
+    },
+  ];
+
+  async load() {}
+  stop() {
+    this.items = [];
+  }
+}
+
+class MockNostrAuthService extends Service {
+  @tracked pubkey = 'test-pubkey';
+
+  get isConnected() {
+    return true;
+  }
+}
+
+module('Acceptance | contributions navigation', function (hooks) {
+  setupApplicationTest(hooks);
+
+  hooks.beforeEach(function () {
+    this.owner.register('service:osm', MockOsmService);
+    this.owner.register('service:storage', MockStorageService);
+    this.owner.register('service:contributions', MockContributionsService);
+    this.owner.register('service:nostrAuth', MockNostrAuthService);
+  });
+
+  test('navigating from menu to contributions and back to menu', async function (assert) {
+    await visit('/');
+    assert.strictEqual(currentURL(), '/');
+
+    // Open the app menu
+    await click('.menu-btn-integrated');
+    assert.dom('.sidebar.app-menu-pane').exists('App menu sidebar is open');
+
+    // Click "My Contributions"
+    const buttons = document.querySelectorAll('.app-menu button');
+    const contributionsBtn = Array.from(buttons).find((b) =>
+      b.textContent.includes('My Contributions')
+    );
+    await click(contributionsBtn);
+
+    assert.strictEqual(
+      currentURL(),
+      '/contributions',
+      'Transitions to /contributions'
+    );
+    assert
+      .dom('.sidebar-header-text-centered')
+      .includesText('My Contributions', 'Header shows the title');
+
+    // Contribution item should be visible
+    await waitFor('.contribution-item');
+    assert.dom('.contribution-place').includesText('Test Place');
+
+    // Click back button -> returns to menu
+    await click('.sidebar-header .back-btn');
+    assert.strictEqual(currentURL(), '/menu', 'Goes back to /menu');
+  });
+
+  test('clicking a contribution opens place details and back returns to contributions', async function (assert) {
+    const mapUi = this.owner.lookup('service:map-ui');
+
+    await visit('/contributions');
+    await waitFor('.contribution-item');
+
+    // Click the contribution item
+    await click('.contribution-item');
+    assert.ok(
+      currentURL().includes('/place/osm:node:123'),
+      'Transitions to place details'
+    );
+    assert.deepEqual(
+      mapUi.returnToRoute,
+      { name: 'contributions' },
+      'returnToRoute is set to contributions'
+    );
+
+    // Click back from place details
+    await click('.back-btn');
+    assert.strictEqual(
+      currentURL(),
+      '/contributions',
+      'Returns to contributions list'
+    );
+  });
+
+  test('closing the contributions sidebar returns to index', async function (assert) {
+    await visit('/contributions');
+    await waitFor('.sidebar');
+
+    await click('.sidebar-header .close-btn');
+    assert.strictEqual(currentURL(), '/', 'Returns to index');
+  });
+
+  test('contributions route saves scroll position when selecting a place', async function (assert) {
+    const mapUi = this.owner.lookup('service:map-ui');
+
+    await visit('/contributions');
+    await waitFor('.contribution-item');
+
+    // The scroll position key should start at 0
+    assert.strictEqual(
+      mapUi.getScrollPosition('contributions'),
+      0,
+      'Initial scroll position is 0'
+    );
+
+    await click('.contribution-item');
+
+    // After navigating to a place, the scroll position should have been saved
+    // (0 in this case since the sidebar wasn't scrolled, but the key should exist)
+    assert.ok(
+      mapUi.returnToRoute,
+      'returnToRoute is set when selecting a contribution'
+    );
+  });
+
+  test('selecting a contribution runs the model hook so the place has lat/lon', async function (assert) {
+    const mapUi = this.owner.lookup('service:map-ui');
+    const osm = this.owner.lookup('service:osm');
+
+    await visit('/contributions');
+    await waitFor('.contribution-item');
+
+    await click('.contribution-item');
+
+    assert.ok(
+      currentURL().includes('/place/osm:node:123'),
+      'Transitions to place details via URL'
+    );
+
+    // The model hook should have called fetchOsmObject (not skipped it)
+    assert.ok(
+      osm.fetchOsmObjectCalls.length > 0,
+      'OSM fetchOsmObject was called (model hook ran)'
+    );
+
+    // The selected place should have lat/lon so the map can pan
+    assert.ok(
+      mapUi.selectedPlace?.lat && mapUi.selectedPlace?.lon,
+      'Selected place has lat/lon coordinates'
+    );
+  });
+});

tests/helpers/index.js

@@ -4,6 +4,7 @@ import {
   setupTest as upstreamSetupTest,
 } from 'ember-qunit';
 import { setupNostrMocks } from './mock-nostr';
+import { setupLocalForageMock } from './mock-local-forage';
 import sinon from 'sinon';
 
 function setupMapStyleMocks(hooks) {
@@ -98,6 +99,7 @@ function setupMapStyleMocks(hooks) {
 function setupApplicationTest(hooks, options) {
   upstreamSetupApplicationTest(hooks, options);
   setupNostrMocks(hooks);
+  setupLocalForageMock(hooks);
   setupMapStyleMocks(hooks);
 
   // Additional setup for application tests can be done here.
@@ -119,6 +121,7 @@ function setupApplicationTest(hooks, options) {
 function setupRenderingTest(hooks, options) {
   upstreamSetupRenderingTest(hooks, options);
   setupNostrMocks(hooks);
+  setupLocalForageMock(hooks);
 
   // Additional setup for rendering tests can be done here.
 }
@@ -126,6 +129,7 @@ function setupRenderingTest(hooks, options) {
 function setupTest(hooks, options) {
   upstreamSetupTest(hooks, options);
   setupNostrMocks(hooks);
+  setupLocalForageMock(hooks);
 
   // Additional setup for unit tests can be done here.
 }

tests/helpers/mock-local-forage.js

@@ -0,0 +1,59 @@
+import Service from '@ember/service';
+
+/**
+ * In-memory mock of the `localForage` service for tests. Uses per-store
+ * `Map`s so tests stay isolated from real IndexedDB state and stay
+ * deterministic.
+ *
+ * Mirrors the real service's interface: `get/set/remove/keys/clear/iterate`.
+ */
+export class MockLocalForageService extends Service {
+  _stores = new Map();
+
+  _store(name) {
+    let store = this._stores.get(name);
+    if (!store) {
+      store = new Map();
+      this._stores.set(name, store);
+    }
+    return store;
+  }
+
+  async get(storeName, key) {
+    const store = this._store(storeName);
+    return store.has(key) ? store.get(key) : null;
+  }
+
+  async set(storeName, key, value) {
+    this._store(storeName).set(key, value);
+    return value;
+  }
+
+  async remove(storeName, key) {
+    this._store(storeName).delete(key);
+  }
+
+  async keys(storeName) {
+    return [...this._store(storeName).keys()];
+  }
+
+  async clear(storeName) {
+    this._store(storeName).clear();
+  }
+
+  async iterate(storeName, fn) {
+    let result;
+    let idx = 0;
+    for (const [key, value] of this._store(storeName)) {
+      result = fn(value, key, idx);
+      idx++;
+    }
+    return result;
+  }
+}
+
+export function setupLocalForageMock(hooks) {
+  hooks.beforeEach(function () {
+    this.owner.register('service:localForage', MockLocalForageService);
+  });
+}

tests/helpers/mock-nostr.js

@@ -9,7 +9,12 @@ export class MockNostrAuthService extends Service {
   @tracked connectUri = null;
 
   get isConnected() {
-    return false;
+    return (
+      !!this.pubkey &&
+      (this.signerType === 'extension'
+        ? typeof window !== 'undefined' && typeof window.nostr !== 'undefined'
+        : true)
+    );
   }
 
   get isMobile() {
@@ -36,11 +41,27 @@ export class MockNostrDataService extends Service {
   @tracked mailboxes = null;
   @tracked blossomServers = [];
   @tracked placePhotos = [];
+  @tracked profiles = {};
+  @tracked zapReceipts = {};
 
   store = {
     add: () => {},
+    timeline: () => ({
+      subscribe: () => ({
+        unsubscribe: () => {},
+      }),
+    }),
+    replaceable: () => ({
+      subscribe: () => ({
+        unsubscribe: () => {},
+      }),
+    }),
   };
 
+  getProfile(pubkey) {
+    return this.profiles[pubkey];
+  }
+
   get activeReadRelays() {
     return [];
   }
@@ -95,10 +116,87 @@ export class MockNostrRelayService extends Service {
   }
 }
 
+export class MockNostrZapService extends Service {
+  @tracked _lightningAddress = 'user@example.com';
+  @tracked _endpoint = {
+    callback: 'https://example.com/callback',
+    minSendable: 1000,
+    maxSendable: 100_000_000,
+    allowsNostr: true,
+    nostrPubkey: 'c'.repeat(64),
+  };
+  @tracked _webLNAvailable = false;
+  @tracked _zapResult = {
+    invoice: 'lnbc1u1pjtestinvoice1234567890',
+    zapRequest: { id: 'zap-req-1' },
+  };
+  @tracked _parsedInvoice = {
+    amount: 1_000_000,
+    expiry: 9_999_999_999,
+    description: 'test zap',
+  };
+
+  @tracked recipientRelays = null;
+
+  getLightningAddress() {
+    return this._lightningAddress;
+  }
+
+  async resolveLnurl() {
+    if (!this._endpoint.allowsNostr) {
+      throw new Error('This lightning address does not support Nostr zaps');
+    }
+    return this._endpoint;
+  }
+
+  async loadRecipientRelays() {
+    this.recipientRelays = ['wss://relay.test'];
+    return this.recipientRelays;
+  }
+
+  getZapRelays() {
+    return (
+      this.recipientRelays || [
+        'wss://relay.damus.io',
+        'wss://nos.lol',
+        'wss://relay.primal.net',
+      ]
+    );
+  }
+
+  hasWebLN() {
+    return this._webLNAvailable;
+  }
+
+  subscribeForZapReceipt(zapRequest, photo, onReceipt) {
+    this._receiptCallback = onReceipt;
+    this._receiptZapRequest = zapRequest;
+    return {
+      unsubscribe: () => {
+        this._receiptCallback = null;
+        this._receiptZapRequest = null;
+      },
+    };
+  }
+
+  async zap() {
+    return this._zapResult;
+  }
+
+  parseInvoice() {
+    return this._parsedInvoice;
+  }
+
+  async payWithWebln() {
+    return {};
+  }
+}
+
 export function setupNostrMocks(hooks) {
   hooks.beforeEach(function () {
     this.owner.register('service:nostrAuth', MockNostrAuthService);
     this.owner.register('service:nostrData', MockNostrDataService);
     this.owner.register('service:nostrRelay', MockNostrRelayService);
+    this.owner.register('service:nostrZap', MockNostrZapService);
   });
 }

tests/integration/components/contribution-photo-test.gjs

@@ -0,0 +1,185 @@
+import { module, test } from 'qunit';
+import { setupRenderingTest } from 'marco/tests/helpers';
+import { render, click, settled } from '@ember/test-helpers';
+import ContributionPhoto from 'marco/components/contribution-photo';
+import { ContributionEntry } from 'marco/utils/contributions';
+
+function noop() {}
+
+module('Integration | Component | contribution-photo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  hooks.beforeEach(function () {
+    this.noop = noop;
+  });
+
+  test('it renders the place name and thumbnail', async function (assert) {
+    this.item = {
+      type: 'photo',
+      placeIdentifier: 'osm:node:12345',
+      osmType: 'node',
+      osmId: '12345',
+      placeName: 'Café Example',
+      placeNameLoading: false,
+      createdAt: Math.floor(Date.now() / 1000) - 60 * 60,
+      photos: [
+        {
+          url: 'https://x.com/photo.jpg',
+          thumbUrl: 'https://x.com/thumb.jpg',
+          alt: 'A nice café',
+          tags: ['food'],
+        },
+      ],
+    };
+
+    await render(
+      <template>
+        <ContributionPhoto @item={{this.item}} @onSelect={{this.noop}} />
+      </template>
+    );
+
+    assert.dom('.contribution-place').hasText('Café Example');
+    assert
+      .dom('.contribution-thumb img')
+      .hasAttribute('src', 'https://x.com/thumb.jpg');
+    assert.dom('.contribution-tag').hasText('food');
+    assert.dom('.contribution-thumb-badge').doesNotExist();
+  });
+
+  test('it shows a +N badge when there are multiple photos', async function (assert) {
+    this.item = {
+      type: 'photo',
+      placeIdentifier: 'osm:node:12345',
+      osmType: 'node',
+      osmId: '12345',
+      placeName: 'Park',
+      placeNameLoading: false,
+      createdAt: 1000,
+      photos: [
+        {
+          url: 'https://x.com/1.jpg',
+          thumbUrl: 'https://x.com/t1.jpg',
+          tags: [],
+        },
+        {
+          url: 'https://x.com/2.jpg',
+          thumbUrl: 'https://x.com/t2.jpg',
+          tags: [],
+        },
+        {
+          url: 'https://x.com/3.jpg',
+          thumbUrl: 'https://x.com/t3.jpg',
+          tags: [],
+        },
+      ],
+    };
+
+    await render(
+      <template>
+        <ContributionPhoto @item={{this.item}} @onSelect={{this.noop}} />
+      </template>
+    );
+
+    assert.dom('.contribution-thumb-badge').hasText('+2');
+  });
+
+  test('it shows a loading label when placeNameLoading is true', async function (assert) {
+    this.item = {
+      type: 'photo',
+      placeIdentifier: 'osm:node:12345',
+      osmType: 'node',
+      osmId: '12345',
+      placeName: null,
+      placeNameLoading: true,
+      createdAt: 1000,
+      photos: [
+        {
+          url: 'https://x.com/1.jpg',
+          thumbUrl: 'https://x.com/t1.jpg',
+          tags: [],
+        },
+      ],
+    };
+
+    await render(
+      <template>
+        <ContributionPhoto @item={{this.item}} @onSelect={{this.noop}} />
+      </template>
+    );
+
+    assert.dom('.contribution-name-loading').hasText('Loading…');
+  });
+
+  test('clicking the item fires @onSelect with the item', async function (assert) {
+    this.item = {
+      type: 'photo',
+      placeIdentifier: 'osm:node:12345',
+      osmType: 'node',
+      osmId: '12345',
+      placeName: 'Test',
+      placeNameLoading: false,
+      createdAt: 1000,
+      photos: [
+        {
+          url: 'https://x.com/1.jpg',
+          thumbUrl: 'https://x.com/t1.jpg',
+          tags: [],
+        },
+      ],
+    };
+
+    let selected = null;
+    this.handleSelect = (item) => {
+      selected = item;
+    };
+
+    await render(
+      <template>
+        <ContributionPhoto
+          @item={{this.item}}
+          @onSelect={{this.handleSelect}}
+        />
+      </template>
+    );
+
+    await click('.contribution-item');
+
+    assert.strictEqual(selected, this.item);
+  });
+
+  test('it updates the place name when a tracked entry resolves after render', async function (assert) {
+    // Regression: when a place name is resolved by the background batch fetch
+    // after the entry has already been rendered as "Loading…", the component
+    // must re-render with the resolved name. This requires the entry's
+    // placeName/placeNameLoading to be tracked.
+    this.item = new ContributionEntry({
+      placeIdentifier: 'osm:node:12345',
+      osmType: 'node',
+      osmId: '12345',
+      createdAt: 1000,
+      photos: [
+        {
+          url: 'https://x.com/1.jpg',
+          thumbUrl: 'https://x.com/t1.jpg',
+          tags: [],
+        },
+      ],
+    });
+
+    await render(
+      <template>
+        <ContributionPhoto @item={{this.item}} @onSelect={{this.noop}} />
+      </template>
+    );
+
+    assert.dom('.contribution-name-loading').hasText('Loading…');
+
+    // Simulate the contributions service resolving the name after the batch fetch
+    this.item.placeName = 'Resolved Café';
+    this.item.placeNameLoading = false;
+    await settled();
+
+    assert.dom('.contribution-place').hasText('Resolved Café');
+    assert.dom('.contribution-name-loading').doesNotExist();
+  });
+});

tests/integration/components/contributions-timeline-test.gjs

@@ -0,0 +1,175 @@
+import { module, test } from 'qunit';
+import { setupRenderingTest } from 'marco/tests/helpers';
+import { render, click } from '@ember/test-helpers';
+import Service from '@ember/service';
+import ContributionsTimeline from 'marco/components/contributions-timeline';
+import { setupNostrMocks } from 'marco/tests/helpers/mock-nostr';
+
+function noop() {}
+
+class MockToastService extends Service {
+  show() {}
+}
+
+module('Integration | Component | contributions-timeline', function (hooks) {
+  setupRenderingTest(hooks);
+  setupNostrMocks(hooks);
+
+  hooks.beforeEach(function () {
+    this.owner.register('service:toast', MockToastService);
+
+    this.noop = noop;
+    this.emptyItems = [];
+  });
+
+  test('it renders a loading state', async function (assert) {
+    await render(
+      <template>
+        <ContributionsTimeline
+          @items={{this.emptyItems}}
+          @isLoading={{true}}
+          @isConnected={{true}}
+          @onBack={{this.noop}}
+          @onClose={{this.noop}}
+          @onSelect={{this.noop}}
+        />
+      </template>
+    );
+
+    assert.dom('.sidebar-loading').exists();
+    assert.dom('.contributions-list').doesNotExist();
+  });
+
+  test('it renders a not-connected state', async function (assert) {
+    await render(
+      <template>
+        <ContributionsTimeline
+          @items={{this.emptyItems}}
+          @isLoading={{false}}
+          @isConnected={{false}}
+          @onBack={{this.noop}}
+          @onClose={{this.noop}}
+          @onSelect={{this.noop}}
+        />
+      </template>
+    );
+
+    assert.dom('.empty-state').includesText('Connect your Nostr account');
+  });
+
+  test('clicking "Connect your Nostr account" opens the Nostr connect modal', async function (assert) {
+    await render(
+      <template>
+        <div id="modal-portal"></div>
+        <ContributionsTimeline
+          @items={{this.emptyItems}}
+          @isLoading={{false}}
+          @isConnected={{false}}
+          @onBack={{this.noop}}
+          @onClose={{this.noop}}
+          @onSelect={{this.noop}}
+        />
+      </template>
+    );
+
+    assert.dom('.nostr-connect-modal').doesNotExist();
+
+    await click('.empty-state a');
+
+    assert.dom('.nostr-connect-modal').exists();
+  });
+
+  test('it renders an empty state when connected but no contributions', async function (assert) {
+    await render(
+      <template>
+        <ContributionsTimeline
+          @items={{this.emptyItems}}
+          @isLoading={{false}}
+          @isConnected={{true}}
+          @onBack={{this.noop}}
+          @onClose={{this.noop}}
+          @onSelect={{this.noop}}
+        />
+      </template>
+    );
+
+    assert.dom('.empty-state').includesText('No contributions yet');
+  });
+
+  test('it renders contribution items', async function (assert) {
+    this.items = [
+      {
+        type: 'photo',
+        placeIdentifier: 'osm:node:111',
+        osmType: 'node',
+        osmId: '111',
+        placeName: 'Café One',
+        placeNameLoading: false,
+        createdAt: 2000,
+        photos: [
+          {
+            url: 'https://x.com/1.jpg',
+            thumbUrl: 'https://x.com/t1.jpg',
+            tags: ['food'],
+          },
+        ],
+      },
+      {
+        type: 'photo',
+        placeIdentifier: 'osm:node:222',
+        osmType: 'node',
+        osmId: '222',
+        placeName: 'Park Two',
+        placeNameLoading: false,
+        createdAt: 1000,
+        photos: [
+          {
+            url: 'https://x.com/2.jpg',
+            thumbUrl: 'https://x.com/t2.jpg',
+            tags: [],
+          },
+        ],
+      },
+    ];
+
+    await render(
+      <template>
+        <ContributionsTimeline
+          @items={{this.items}}
+          @isLoading={{false}}
+          @isConnected={{true}}
+          @onBack={{this.noop}}
+          @onClose={{this.noop}}
+          @onSelect={{this.noop}}
+        />
+      </template>
+    );
+
+    assert.dom('.contribution-item').exists({ count: 2 });
+    assert.dom(this.element).includesText('Café One');
+    assert.dom(this.element).includesText('Park Two');
+  });
+
+  test('clicking the back button fires @onBack', async function (assert) {
+    let backClicked = false;
+    this.handleBack = () => {
+      backClicked = true;
+    };
+
+    await render(
+      <template>
+        <ContributionsTimeline
+          @items={{this.emptyItems}}
+          @isLoading={{false}}
+          @isConnected={{true}}
+          @onBack={{this.handleBack}}
+          @onClose={{this.noop}}
+          @onSelect={{this.noop}}
+        />
+      </template>
+    );
+
+    await click('.sidebar-header .back-btn');
+    assert.true(backClicked);
+  });
+});

tests/integration/components/photo-gallery-test.gjs

@@ -339,4 +339,203 @@ module('Integration | Component | photo-gallery', function (hooks) {
     await triggerKeyEvent(document, 'keydown', 'Escape');
     assert.ok(closed, 'gallery was closed on escape key');
   });
+
+  test('it renders uploader name and date when profile is loaded', async function (assert) {
+    const displayName = 'Alice';
+    const publishedAt = Math.floor(Date.now() / 1000) - 60 * 60 * 24; // 1 day ago
+
+    this.nostrData.profiles = {
+      [USER_A]: { displayName, display_name: 'ignored', name: 'ignored' },
+    };
+
+    this.photos = [
+      {
+        eventId: 'event1',
+        pubkey: USER_A,
+        placeIdentifier: 'osm:node:12345',
+        url: 'https://example.com/photo.jpg',
+        publishedAt,
+        createdAt: publishedAt + 10,
+      },
+    ];
+    this.selectedPhoto = this.photos[0];
+
+    await render(
+      <template>
+        <div id="test-container">
+          <div id="modal-portal"></div>
+          <PhotoGallery
+            @photos={{this.photos}}
+            @selectedPhoto={{this.selectedPhoto}}
+          />
+        </div>
+      </template>
+    );
+
+    assert
+      .dom('.photo-gallery-uploader-name')
+      .hasText(displayName, 'uploader name is rendered');
+    assert
+      .dom('.photo-gallery-uploader-date')
+      .exists('date element is rendered');
+  });
+
+  test('it prefers published_at over created_at for the date', async function (assert) {
+    this.nostrData.profiles = {
+      [USER_A]: { displayName: 'Alice' },
+    };
+
+    const publishedAt = Math.floor(Date.now() / 1000) - 60 * 60 * 24 * 3; // 3 days ago
+    const createdAt = Math.floor(Date.now() / 1000) - 60; // 1 min ago
+
+    this.photos = [
+      {
+        eventId: 'event1',
+        pubkey: USER_A,
+        url: 'https://example.com/photo.jpg',
+        publishedAt,
+        createdAt,
+      },
+    ];
+    this.selectedPhoto = this.photos[0];
+
+    await render(
+      <template>
+        <div id="test-container">
+          <div id="modal-portal"></div>
+          <PhotoGallery
+            @photos={{this.photos}}
+            @selectedPhoto={{this.selectedPhoto}}
+          />
+        </div>
+      </template>
+    );
+
+    // Should show "3 days ago" (publishedAt), not "just now" (createdAt)
+    assert.dom('.photo-gallery-uploader-date').hasText('3 days ago');
+  });
+
+  test('it does not render uploader info when profile is missing', async function (assert) {
+    this.nostrData.profiles = {};
+
+    this.photos = [
+      {
+        eventId: 'event1',
+        pubkey: USER_A,
+        url: 'https://example.com/photo.jpg',
+        createdAt: Math.floor(Date.now() / 1000),
+      },
+    ];
+    this.selectedPhoto = this.photos[0];
+
+    await render(
+      <template>
+        <div id="test-container">
+          <div id="modal-portal"></div>
+          <PhotoGallery
+            @photos={{this.photos}}
+            @selectedPhoto={{this.selectedPhoto}}
+          />
+        </div>
+      </template>
+    );
+
+    assert
+      .dom('.photo-gallery-uploader-name')
+      .doesNotExist('uploader name is not rendered without profile');
+    // Date should still render since createdAt is present
+    assert.dom('.photo-gallery-uploader-date').exists('date is still rendered');
+  });
+
+  test('it falls back through displayName -> display_name -> name', async function (assert) {
+    this.nostrData.profiles = {
+      [USER_A]: { display_name: 'Bob', name: 'Robert' },
+    };
+
+    this.photos = [
+      {
+        eventId: 'event1',
+        pubkey: USER_A,
+        url: 'https://example.com/photo.jpg',
+        createdAt: Math.floor(Date.now() / 1000) - 60,
+      },
+    ];
+    this.selectedPhoto = this.photos[0];
+
+    await render(
+      <template>
+        <div id="test-container">
+          <div id="modal-portal"></div>
+          <PhotoGallery
+            @photos={{this.photos}}
+            @selectedPhoto={{this.selectedPhoto}}
+          />
+        </div>
+      </template>
+    );
+
+    assert
+      .dom('.photo-gallery-uploader-name')
+      .hasText('Bob', 'falls back to display_name when displayName is missing');
+  });
+
+  test('it shows Zap this photo in the dropdown', async function (assert) {
+    this.nostrAuth.pubkey = USER_B;
+    this.nostrAuth.signerType = 'connect';
+    this.selectedPhoto = this.photos[0];
+
+    await render(
+      <template>
+        <div id="test-container">
+          <div id="modal-portal"></div>
+          <PhotoGallery
+            @photos={{this.photos}}
+            @selectedPhoto={{this.selectedPhoto}}
+          />
+        </div>
+      </template>
+    );
+
+    await click('.dropdown-trigger-btn');
+
+    let zapBtn;
+    document.querySelectorAll('.dropdown-item').forEach((item) => {
+      if (item.textContent.includes('Zap this photo')) {
+        zapBtn = item;
+      }
+    });
+
+    assert.ok(zapBtn, 'Zap this photo dropdown item exists');
+  });
+
+  test('it opens zap modal when Zap this photo is clicked', async function (assert) {
+    this.nostrAuth.pubkey = USER_B;
+    this.nostrAuth.signerType = 'connect';
+    this.selectedPhoto = this.photos[0];
+
+    await render(
+      <template>
+        <div id="test-container">
+          <div id="modal-portal"></div>
+          <PhotoGallery
+            @photos={{this.photos}}
+            @selectedPhoto={{this.selectedPhoto}}
+          />
+        </div>
+      </template>
+    );
+
+    await click('.dropdown-trigger-btn');
+
+    let zapBtn;
+    document.querySelectorAll('.dropdown-item').forEach((item) => {
+      if (item.textContent.includes('Zap this photo')) {
+        zapBtn = item;
+      }
+    });
+
+    await click(zapBtn);
+
+    assert.dom('.zap-photo-modal').exists('zap modal is rendered');
+  });
 });

tests/integration/components/place-details-test.gjs

@@ -320,14 +320,14 @@ module('Integration | Component | place-details', function (hooks) {
     const links = whatsappBlock.querySelectorAll('a[href^="https://wa.me/"]');
     assert.strictEqual(links.length, 2, 'Rendered exactly 2 WhatsApp links');
 
-    // Verify it stripped the dashes and spaces for the wa.me URL
+    // Verify it stripped the dashes, spaces and leading plus for the wa.me URL
     assert.strictEqual(
       links[0].getAttribute('href'),
-      'https://wa.me/+44987654321'
+      'https://wa.me/44987654321'
     );
     assert.strictEqual(
       links[1].getAttribute('href'),
-      'https://wa.me/+12345678900'
+      'https://wa.me/12345678900'
     );
 
     // Verify it kept the dashes and spaces for the visible text
@@ -335,6 +335,33 @@ module('Integration | Component | place-details', function (hooks) {
     assert.dom(links[1]).hasText('+1 234-567 8900');
   });
 
+  test('it strips parentheses, dots and the leading plus from whatsapp hrefs', async function (assert) {
+    const place = {
+      title: 'Chat Shop',
+      osmTags: {
+        whatsapp: '+504-9850-3802;(504) 9850.3802;+1.234.567.8900',
+      },
+    };
+
+    await render(<template><PlaceDetails @place={{place}} /></template>);
+
+    const links = this.element.querySelectorAll('a[href^="https://wa.me/"]');
+    assert.strictEqual(links.length, 3, 'Rendered exactly 3 WhatsApp links');
+
+    assert.strictEqual(
+      links[0].getAttribute('href'),
+      'https://wa.me/50498503802'
+    );
+    assert.strictEqual(
+      links[1].getAttribute('href'),
+      'https://wa.me/50498503802'
+    );
+    assert.strictEqual(
+      links[2].getAttribute('href'),
+      'https://wa.me/12345678900'
+    );
+  });
+
   test('it renders correct OpenStreetMap link for an OSM place', async function (assert) {
     const place = {
       title: 'OSM Place',

tests/integration/components/zap-photo-modal-test.gjs

@@ -0,0 +1,286 @@
+import { module, test } from 'qunit';
+import { setupRenderingTest } from 'marco/tests/helpers';
+import { render, click, fillIn, waitFor } from '@ember/test-helpers';
+import Service from '@ember/service';
+import ZapPhotoModal from 'marco/components/zap-photo-modal';
+import { setupNostrMocks } from 'marco/tests/helpers/mock-nostr';
+import sinon from 'sinon';
+
+const USER_A = 'a'.repeat(64);
+
+class MockToastService extends Service {
+  show() {}
+}
+
+module('Integration | Component | zap-photo-modal', function (hooks) {
+  setupRenderingTest(hooks);
+  setupNostrMocks(hooks);
+
+  hooks.beforeEach(function () {
+    this.owner.register('service:toast', MockToastService);
+
+    this.nostrZap = this.owner.lookup('service:nostrZap');
+    this.toast = this.owner.lookup('service:toast');
+
+    this.photo = {
+      eventId: 'event1',
+      pubkey: USER_A,
+      url: 'https://example.com/photo.jpg',
+    };
+  });
+
+  hooks.afterEach(function () {
+    sinon.restore();
+  });
+
+  test('it renders the amount slider when lightning address is available', async function (assert) {
+    await render(
+      <template>
+        <div id="modal-portal"></div>
+        <ZapPhotoModal @photo={{this.photo}} />
+      </template>
+    );
+
+    assert.dom('.zap-slider').exists('slider is rendered');
+    assert.dom('.zap-amount').exists('amount is displayed');
+    assert
+      .dom('.lightning-address-text')
+      .hasText('user@example.com', 'lightning address is shown');
+    assert.dom('.lightning-badge').hasText('Lightning', 'badge is shown');
+  });
+
+  test('it shows error when user has no lightning address', async function (assert) {
+    this.nostrZap._lightningAddress = null;
+
+    await render(
+      <template>
+        <div id="modal-portal"></div>
+        <ZapPhotoModal @photo={{this.photo}} />
+      </template>
+    );
+
+    assert
+      .dom('.alert-error')
+      .exists('error message is shown when no lightning address');
+    assert
+      .dom('.edit-actions .btn-primary')
+      .isDisabled('zap button is disabled when no address');
+  });
+
+  test('it shows error when LNURL does not support Nostr zaps', async function (assert) {
+    this.nostrZap._endpoint = {
+      ...this.nostrZap._endpoint,
+      allowsNostr: false,
+    };
+
+    await render(
+      <template>
+        <div id="modal-portal"></div>
+        <ZapPhotoModal @photo={{this.photo}} />
+      </template>
+    );
+
+    assert.dom('.alert-error').exists('error shown when allowsNostr is false');
+    assert
+      .dom('.edit-actions .btn-primary')
+      .isDisabled('zap button is disabled');
+  });
+
+  test('it performs zap flow when Zap button is clicked', async function (assert) {
+    const zapSpy = sinon.spy(this.nostrZap, 'zap');
+    let closed = false;
+    this.handleClose = () => {
+      closed = true;
+    };
+
+    await render(
+      <template>
+        <div id="modal-portal"></div>
+        <ZapPhotoModal @photo={{this.photo}} @onClose={{this.handleClose}} />
+      </template>
+    );
+
+    assert
+      .dom('.edit-actions .btn-primary')
+      .isNotDisabled('zap button is enabled when endpoint is valid');
+
+    await click('.edit-actions .btn-primary');
+
+    assert.ok(zapSpy.calledOnce, 'nostrZap.zap was called');
+    assert.deepEqual(
+      zapSpy.firstCall.args[0],
+      this.photo,
+      'zap was called with the photo'
+    );
+    assert.strictEqual(
+      zapSpy.firstCall.args[1],
+      100_000,
+      'zap amount is 100 sats in millisats'
+    );
+
+    await waitFor('.qr-code-container');
+
+    assert.dom('.qr-code-container').exists('QR code is shown');
+    assert.dom('.zap-pay-prompt').exists('payment prompt is shown');
+    assert.notOk(closed, 'modal was not closed by clicking the Zap button');
+  });
+
+  test('it passes the message to the zap call', async function (assert) {
+    const zapSpy = sinon.spy(this.nostrZap, 'zap');
+
+    await render(
+      <template>
+        <div id="modal-portal"></div>
+        <ZapPhotoModal @photo={{this.photo}} />
+      </template>
+    );
+
+    await fillIn('.form-group input', 'Great photo!');
+
+    await click('.edit-actions .btn-primary');
+
+    assert.ok(zapSpy.calledOnce, 'nostrZap.zap was called');
+    assert.strictEqual(
+      zapSpy.firstCall.args[2],
+      'Great photo!',
+      'message is passed to zap'
+    );
+  });
+
+  test('it shows WebLN button when available', async function (assert) {
+    this.nostrZap._webLNAvailable = true;
+
+    await render(
+      <template>
+        <div id="modal-portal"></div>
+        <ZapPhotoModal @photo={{this.photo}} />
+      </template>
+    );
+
+    await click('.edit-actions .btn-primary');
+    await waitFor('.webln-pay-btn');
+
+    assert.dom('.webln-pay-btn').exists('WebLN button is shown when available');
+  });
+
+  test('it shows success after WebLN payment', async function (assert) {
+    this.nostrZap._webLNAvailable = true;
+
+    await render(
+      <template>
+        <div id="modal-portal"></div>
+        <ZapPhotoModal @photo={{this.photo}} />
+      </template>
+    );
+
+    await click('.edit-actions .btn-primary');
+    await waitFor('.webln-pay-btn');
+    await click('.webln-pay-btn');
+
+    await waitFor('.zap-success');
+
+    assert.dom('.zap-success').exists('success state is shown');
+    assert.dom('.zap-success h4').hasText('Zap Sent!', 'success title');
+  });
+
+  test('it shows success when a matching zap receipt is received', async function (assert) {
+    await render(
+      <template>
+        <div id="modal-portal"></div>
+        <ZapPhotoModal @photo={{this.photo}} />
+      </template>
+    );
+
+    await click('.edit-actions .btn-primary');
+    await waitFor('.qr-code-container');
+
+    assert.dom('.qr-code-container').exists('QR code is shown');
+
+    assert.ok(
+      this.nostrZap._receiptCallback,
+      'receipt subscription was started'
+    );
+
+    this.nostrZap._receiptCallback();
+
+    await waitFor('.zap-success');
+
+    assert.dom('.zap-success').exists('success state is shown after receipt');
+    assert.notOk(
+      this.nostrZap._receiptCallback,
+      'receipt subscription was cleaned up'
+    );
+  });
+
+  test('it calls onClose when close button is clicked', async function (assert) {
+    let closed = false;
+    this.handleClose = () => {
+      closed = true;
+    };
+
+    await render(
+      <template>
+        <div id="modal-portal"></div>
+        <ZapPhotoModal @photo={{this.photo}} @onClose={{this.handleClose}} />
+      </template>
+    );
+
+    await click('.close-modal-btn');
+
+    assert.ok(closed, 'onClose was called');
+  });
+
+  test('it calls onClose when Cancel button is clicked', async function (assert) {
+    let closed = false;
+    this.handleClose = () => {
+      closed = true;
+    };
+
+    await render(
+      <template>
+        <div id="modal-portal"></div>
+        <ZapPhotoModal @photo={{this.photo}} @onClose={{this.handleClose}} />
+      </template>
+    );
+
+    await click('.edit-actions .btn-outline');
+
+    assert.ok(closed, 'onClose was called from Cancel button');
+  });
+
+  test('it does not close when clicking inside the modal body', async function (assert) {
+    let closed = false;
+    this.handleClose = () => {
+      closed = true;
+    };
+
+    await render(
+      <template>
+        <div id="modal-portal"></div>
+        <ZapPhotoModal @photo={{this.photo}} @onClose={{this.handleClose}} />
+      </template>
+    );
+
+    await click('.zap-photo-modal');
+
+    assert.notOk(closed, 'onClose was not called when clicking inside modal');
+  });
+
+  test('it closes when clicking the overlay background', async function (assert) {
+    let closed = false;
+    this.handleClose = () => {
+      closed = true;
+    };
+
+    await render(
+      <template>
+        <div id="modal-portal"></div>
+        <ZapPhotoModal @photo={{this.photo}} @onClose={{this.handleClose}} />
+      </template>
+    );
+
+    await click('.modal-overlay');
+
+    assert.ok(closed, 'onClose was called when clicking overlay');
+  });
+});

tests/unit/services/contributions-test.js

@@ -0,0 +1,277 @@
+import { module, test } from 'qunit';
+import { setupTest } from 'marco/tests/helpers';
+import Service from '@ember/service';
+
+function makePhotoEvent({
+  id,
+  created_at,
+  placeIdentifier = 'osm:node:123',
+  url = 'https://example.com/photo.jpg',
+}) {
+  return {
+    id,
+    pubkey: 'pubkey-1',
+    kind: 360,
+    created_at,
+    tags: [
+      ['i', placeIdentifier],
+      ['imeta', `url ${url}`, 'dim 800x600'],
+    ],
+  };
+}
+
+class MockStorageService extends Service {
+  savedPlaces = [];
+  findPlaceById() {
+    return null;
+  }
+}
+
+class MockNostrDataService extends Service {
+  store = {
+    timeline() {
+      return {
+        subscribe() {
+          return { unsubscribe() {} };
+        },
+      };
+    },
+  };
+
+  async loadMyContributions() {}
+}
+
+class MockOsmService extends Service {
+  async getCachedOsmObject() {
+    return null;
+  }
+
+  async fetchOsmObjectsBatch() {
+    return new Map();
+  }
+}
+
+const NAME_CACHE_STORE = 'contributions-name-cache';
+
+function flushPromises() {
+  return new Promise((resolve) => setTimeout(resolve, 50));
+}
+
+module('Unit | Service | contributions', function (hooks) {
+  setupTest(hooks);
+
+  hooks.beforeEach(function () {
+    this.owner.register('service:storage', MockStorageService);
+    this.owner.register('service:nostrData', MockNostrDataService);
+    this.owner.register('service:osm', MockOsmService);
+  });
+
+  test('_updateItems resolves names from bookmarks immediately', function (assert) {
+    const events = [makePhotoEvent({ id: 'e1', created_at: 1000 })];
+
+    const service = this.owner.lookup('service:contributions');
+    service.storage.savedPlaces = [{ id: '123', title: 'Bookmarked Café' }];
+    service.storage.findPlaceById = (id) =>
+      id === '123' ? { id: '123', title: 'Bookmarked Café' } : null;
+
+    service._updateItems(events);
+
+    assert.strictEqual(service.items.length, 1);
+    assert.false(service.items[0].placeNameLoading, 'Not loading');
+    assert.strictEqual(
+      service.items[0].placeName,
+      'Bookmarked Café',
+      'Resolved from bookmark'
+    );
+  });
+
+  test('_updateItems resolves names from the persistent name cache', async function (assert) {
+    const events = [
+      makePhotoEvent({
+        id: 'e1',
+        created_at: 1000,
+        placeIdentifier: 'osm:node:999',
+      }),
+    ];
+
+    const service = this.owner.lookup('service:contributions');
+    await service.localForage.set(
+      NAME_CACHE_STORE,
+      'osm:node:999',
+      'Cached Park'
+    );
+
+    service._updateItems(events);
+    await flushPromises();
+
+    assert.strictEqual(service.items[0].placeName, 'Cached Park');
+    assert.false(service.items[0].placeNameLoading);
+  });
+
+  test('resolved names are persisted to the IndexedDB name cache', async function (assert) {
+    const events = [
+      makePhotoEvent({
+        id: 'e1',
+        created_at: 1000,
+        placeIdentifier: 'osm:node:42',
+      }),
+    ];
+
+    const service = this.owner.lookup('service:contributions');
+    service.osm.fetchOsmObjectsBatch = async () => {
+      const map = new Map();
+      map.set('node:42', { title: 'Test Place' });
+      return map;
+    };
+
+    service._updateItems(events);
+    await flushPromises();
+
+    assert.strictEqual(
+      await service.localForage.get(NAME_CACHE_STORE, 'osm:node:42'),
+      'Test Place',
+      'Name is persisted to the IndexedDB name cache'
+    );
+  });
+
+  test('names stored in a previous session are resolved from the IndexedDB cache', async function (assert) {
+    const events = [
+      makePhotoEvent({
+        id: 'e1',
+        created_at: 1000,
+        placeIdentifier: 'osm:node:77',
+      }),
+    ];
+
+    const service = this.owner.lookup('service:contributions');
+    await service.localForage.set(
+      NAME_CACHE_STORE,
+      'osm:node:77',
+      'Persisted Place'
+    );
+
+    service._updateItems(events);
+    await flushPromises();
+
+    assert.strictEqual(service.items[0].placeName, 'Persisted Place');
+    assert.false(service.items[0].placeNameLoading);
+  });
+
+  test('batch fetch failure applies a fallback name so items do not stay loading', async function (assert) {
+    const events = [
+      makePhotoEvent({
+        id: 'e1',
+        created_at: 1000,
+        placeIdentifier: 'osm:node:555',
+      }),
+    ];
+
+    const service = this.owner.lookup('service:contributions');
+    // OSM batch returns empty (simulating all-failed fetch)
+    service.osm.fetchOsmObjectsBatch = async () => new Map();
+
+    service._updateItems(events);
+
+    // Wait for the background batch to complete
+    await flushPromises();
+
+    assert.false(
+      service.items[0].placeNameLoading,
+      'Item is no longer loading after batch failure'
+    );
+    assert.strictEqual(
+      service.items[0].placeName,
+      'OSM node 555',
+      'Fallback name is applied'
+    );
+  });
+
+  test('fallback names are NOT persisted to the name cache (so they can be re-fetched next session)', async function (assert) {
+    const events = [
+      makePhotoEvent({
+        id: 'e1',
+        created_at: 1000,
+        placeIdentifier: 'osm:node:666',
+      }),
+    ];
+
+    const service = this.owner.lookup('service:contributions');
+    service.osm.fetchOsmObjectsBatch = async () => new Map();
+
+    service._updateItems(events);
+    await flushPromises();
+
+    // Fallback should be shown but NOT cached
+    assert.strictEqual(service.items[0].placeName, 'OSM node 666');
+    assert.notOk(
+      await service.localForage.get(NAME_CACHE_STORE, 'osm:node:666'),
+      'No fallback name persisted in the IndexedDB name cache'
+    );
+    assert.true(
+      service._unresolvable.has('osm:node:666'),
+      'Item is marked unresolvable for this session'
+    );
+  });
+
+  test('unresolvable items are not re-fetched within the same session', async function (assert) {
+    const events = [
+      makePhotoEvent({
+        id: 'e1',
+        created_at: 1000,
+        placeIdentifier: 'osm:node:777',
+      }),
+    ];
+
+    let fetchCount = 0;
+    const service = this.owner.lookup('service:contributions');
+    service.osm.fetchOsmObjectsBatch = async () => {
+      fetchCount++;
+      return new Map();
+    };
+
+    // First update triggers a fetch
+    service._updateItems(events);
+    await flushPromises();
+
+    assert.strictEqual(fetchCount, 1, 'First update triggers a fetch');
+    assert.strictEqual(service.items[0].placeName, 'OSM node 777');
+
+    // Second update should NOT trigger another fetch (already unresolvable)
+    service._updateItems(events);
+    await flushPromises();
+
+    assert.strictEqual(fetchCount, 1, 'Second update does not re-fetch');
+    assert.strictEqual(
+      service.items[0].placeName,
+      'OSM node 777',
+      'Fallback is shown immediately'
+    );
+  });
+
+  test('successful batch resolution stores names in the name cache', async function (assert) {
+    const events = [
+      makePhotoEvent({
+        id: 'e1',
+        created_at: 1000,
+        placeIdentifier: 'osm:node:111',
+      }),
+    ];
+
+    const service = this.owner.lookup('service:contributions');
+    service.osm.fetchOsmObjectsBatch = async () => {
+      const map = new Map();
+      map.set('node:111', { title: 'Resolved Café' });
+      return map;
+    };
+
+    service._updateItems(events);
+    await flushPromises();
+
+    assert.strictEqual(service.items[0].placeName, 'Resolved Café');
+    assert.strictEqual(
+      await service.localForage.get(NAME_CACHE_STORE, 'osm:node:111'),
+      'Resolved Café',
+      'Name is stored in the name cache'
+    );
+  });
+});

tests/unit/services/osm-test.js

@@ -292,4 +292,205 @@ module('Unit | Service | osm', function (hooks) {
       'Call with different lat/lon should trigger fetch'
     );
   });
+
+  test('_storeInMemoryAndLocalStorage rejects entries without a title', function (assert) {
+    let service = this.owner.lookup('service:osm');
+
+    service._storeInMemoryAndLocalStorage('node:1', 'node', '1', {
+      title: null,
+      lat: 1,
+      lon: 1,
+    });
+
+    assert.false(
+      service.cachedPlaces.has('node:1'),
+      'Does not cache entries without a title'
+    );
+
+    service._storeInMemoryAndLocalStorage('node:2', 'node', '2', null);
+    assert.false(
+      service.cachedPlaces.has('node:2'),
+      'Does not cache null entries'
+    );
+  });
+
+  test('_storeInMemoryAndLocalStorage accepts entries with a title', function (assert) {
+    let service = this.owner.lookup('service:osm');
+
+    service._storeInMemoryAndLocalStorage('node:3', 'node', '3', {
+      title: 'Café Example',
+      lat: 52.5,
+      lon: 13.4,
+    });
+
+    assert.true(
+      service.cachedPlaces.has('node:3'),
+      'Caches entries with a title'
+    );
+  });
+
+  test('fetchOsmObjectsBatch does not write to the general OSM cache', async function (assert) {
+    let service = this.owner.lookup('service:osm');
+
+    service.fetchWithRetry = async () => ({
+      ok: true,
+      json: async () => ({
+        elements: [
+          { id: 100, type: 'node', lat: 1, lon: 2, tags: { name: 'Node 100' } },
+        ],
+      }),
+    });
+
+    await service.fetchOsmObjectsBatch([{ osmType: 'node', osmId: '100' }]);
+
+    assert.false(
+      service.cachedPlaces.has('node:100'),
+      'Batch fetch does not write to the in-memory OSM cache'
+    );
+    assert.notOk(
+      await service.localForage.get('osm-cache', 'node:100'),
+      'Batch fetch does not write to the persistent OSM cache'
+    );
+  });
+
+  test('fetchOsmObjectsBatch returns resolved places in the result Map', async function (assert) {
+    let service = this.owner.lookup('service:osm');
+
+    service.fetchWithRetry = async () => ({
+      ok: true,
+      json: async () => ({
+        elements: [
+          { id: 200, type: 'node', lat: 1, lon: 2, tags: { name: 'Café 200' } },
+        ],
+      }),
+    });
+
+    const result = await service.fetchOsmObjectsBatch([
+      { osmType: 'node', osmId: '200' },
+    ]);
+
+    assert.true(result.has('node:200'), 'Result contains the fetched place');
+    assert.strictEqual(
+      result.get('node:200').title,
+      'Café 200',
+      'Result has the correct title'
+    );
+  });
+
+  test('fetchOsmObjectsBatch uses .json suffix in the API URL', async function (assert) {
+    let service = this.owner.lookup('service:osm');
+
+    let capturedUrls = [];
+    service.fetchWithRetry = async (url) => {
+      capturedUrls.push(url);
+      return {
+        ok: true,
+        json: async () => ({
+          elements: [
+            { id: 300, type: 'node', lat: 1, lon: 2, tags: { name: 'Test' } },
+          ],
+        }),
+      };
+    };
+
+    await service.fetchOsmObjectsBatch([{ osmType: 'node', osmId: '300' }]);
+
+    assert.true(
+      capturedUrls.some((url) => url.includes('.json')),
+      'Batch fetch URL includes .json suffix'
+    );
+  });
+
+  test('fetchOsmObjectsBatch uses correct pluralized endpoints', async function (assert) {
+    let service = this.owner.lookup('service:osm');
+
+    let capturedUrls = [];
+    service.fetchWithRetry = async (url) => {
+      capturedUrls.push(url);
+      return {
+        ok: true,
+        json: async () => ({ elements: [] }),
+      };
+    };
+
+    await service.fetchOsmObjectsBatch([
+      { osmType: 'node', osmId: '1' },
+      { osmType: 'way', osmId: '2' },
+      { osmType: 'relation', osmId: '3' },
+    ]);
+
+    assert.true(
+      capturedUrls.some((u) => u.includes('/nodes.json?nodes=')),
+      'Uses nodes.json endpoint'
+    );
+    assert.true(
+      capturedUrls.some((u) => u.includes('/ways.json?ways=')),
+      'Uses ways.json endpoint'
+    );
+    assert.true(
+      capturedUrls.some((u) => u.includes('/relations.json?relations=')),
+      'Uses relations.json endpoint'
+    );
+  });
+
+  test('fetchOsmObject with forceFresh bypasses the cache and returns fresh data', async function (assert) {
+    let service = this.owner.lookup('service:osm');
+
+    // Seed both caches so we can prove forceFresh skips them.
+    service.cachedPlaces.set('node:5', {
+      data: { title: 'Stale In-Memory', lat: 1, lon: 1 },
+      timestamp: Date.now(),
+    });
+    await service.localForage.set('osm-cache', 'node:5', {
+      data: { title: 'Stale IndexedDB', lat: 1, lon: 1 },
+      timestamp: Date.now(),
+    });
+
+    service.fetchWithRetry = async () => ({
+      ok: true,
+      json: async () => ({
+        elements: [
+          {
+            id: 5,
+            type: 'node',
+            lat: 2,
+            lon: 3,
+            tags: { name: 'Fresh From API' },
+          },
+        ],
+      }),
+    });
+
+    const result = await service.fetchOsmObject('5', 'node', {
+      forceFresh: true,
+    });
+
+    assert.strictEqual(
+      result.title,
+      'Fresh From API',
+      'Returns fresh API data, not cached data'
+    );
+    assert.strictEqual(result.lat, 2);
+    assert.strictEqual(result.lon, 3);
+  });
+
+  test('fetchOsmObject without forceFresh returns the in-memory cache entry without hitting the API', async function (assert) {
+    let service = this.owner.lookup('service:osm');
+
+    service.cachedPlaces.set('node:6', {
+      data: { title: 'Warm In-Memory', lat: 4, lon: 5 },
+      timestamp: Date.now(),
+    });
+
+    let fetchCalled = 0;
+    service.fetchWithRetry = async () => {
+      fetchCalled++;
+      return { ok: true, json: async () => ({ elements: [] }) };
+    };
+
+    const result = await service.fetchOsmObject('6', 'node');
+
+    assert.strictEqual(fetchCalled, 0, 'API was not hit');
+    assert.strictEqual(result.title, 'Warm In-Memory');
+  });
 });

tests/unit/services/storage-test.js

@@ -15,8 +15,10 @@ module('Unit | Service | storage', function (hooks) {
     let service = this.owner.lookup('service:storage');
 
     // Stub OSM Service
+    let capturedOptions;
     class OsmStub extends Service {
-      async fetchOsmObject(id, type) {
+      async fetchOsmObject(id, type, options) {
+        capturedOptions = options;
         return {
           osmId: id,
           osmType: type,
@@ -49,6 +51,10 @@ module('Unit | Service | storage', function (hooks) {
 
     assert.ok(updatePlaceCalled, 'updatePlace should be called');
     assert.strictEqual(result.lat, 52.5201, 'Latitude updated');
+    assert.ok(
+      capturedOptions?.forceFresh,
+      'refreshPlace fetches fresh OSM data (forceFresh: true)'
+    );
   });
 
   test('refreshPlace ignores tiny coordinate drift', async function (assert) {

tests/unit/utils/contributions-test.js

@@ -0,0 +1,262 @@
+import { module, test } from 'qunit';
+import { groupPhotoContributions } from 'marco/utils/contributions';
+
+function makePhotoEvent({
+  id,
+  created_at,
+  placeIdentifier = 'osm:node:123',
+  url = 'https://example.com/photo.jpg',
+  tags = [],
+}) {
+  return {
+    id,
+    pubkey: 'pubkey-1',
+    kind: 360,
+    created_at,
+    tags: [
+      ['i', placeIdentifier],
+      ['imeta', `url ${url}`, 'dim 800x600'],
+      ...tags.map((t) => ['t', t]),
+    ],
+  };
+}
+
+function makeDeletionEvent({ id, targetId }) {
+  return {
+    id,
+    pubkey: 'pubkey-1',
+    kind: 5,
+    created_at: 999,
+    tags: [['e', targetId]],
+  };
+}
+
+module('Unit | Utility | contributions', function () {
+  test('groupPhotoContributions returns empty for no events', function (assert) {
+    assert.deepEqual(groupPhotoContributions([]), []);
+    assert.deepEqual(groupPhotoContributions(null), []);
+  });
+
+  test('groupPhotoContributions creates one entry per event for the same place when spread out', function (assert) {
+    // Two events 10 hours apart for the same place -> two entries
+    const events = [
+      makePhotoEvent({
+        id: 'e1',
+        created_at: 1000,
+        url: 'https://x.com/1.jpg',
+      }),
+      makePhotoEvent({
+        id: 'e2',
+        created_at: 1000 + 10 * 60 * 60,
+        url: 'https://x.com/2.jpg',
+      }),
+    ];
+
+    const entries = groupPhotoContributions(events);
+    assert.strictEqual(entries.length, 2);
+    // Newest first
+    assert.strictEqual(entries[0].photos[0].url, 'https://x.com/2.jpg');
+    assert.strictEqual(entries[1].photos[0].url, 'https://x.com/1.jpg');
+  });
+
+  test('groupPhotoContributions groups events for the same place within the threshold', function (assert) {
+    // Two events 30 minutes apart -> one entry with two photos
+    const events = [
+      makePhotoEvent({
+        id: 'e1',
+        created_at: 1000,
+        url: 'https://x.com/1.jpg',
+      }),
+      makePhotoEvent({
+        id: 'e2',
+        created_at: 1000 + 30 * 60,
+        url: 'https://x.com/2.jpg',
+      }),
+    ];
+
+    const entries = groupPhotoContributions(events);
+    assert.strictEqual(entries.length, 1);
+    assert.strictEqual(entries[0].photos.length, 2);
+    assert.strictEqual(entries[0].eventCount, 2);
+    // createdAt = newest event's created_at
+    assert.strictEqual(entries[0].createdAt, 1000 + 30 * 60);
+  });
+
+  test('groupPhotoContributions orders photos within a group oldest-first', function (assert) {
+    // Three events within the threshold for the same place
+    const events = [
+      makePhotoEvent({
+        id: 'e3',
+        created_at: 3000,
+        url: 'https://x.com/3.jpg',
+      }),
+      makePhotoEvent({
+        id: 'e1',
+        created_at: 1000,
+        url: 'https://x.com/1.jpg',
+      }),
+      makePhotoEvent({
+        id: 'e2',
+        created_at: 2000,
+        url: 'https://x.com/2.jpg',
+      }),
+    ];
+
+    const entries = groupPhotoContributions(events);
+    assert.strictEqual(entries.length, 1);
+    assert.strictEqual(
+      entries[0].photos[0].url,
+      'https://x.com/1.jpg',
+      'First photo is the oldest'
+    );
+    assert.strictEqual(
+      entries[0].photos[1].url,
+      'https://x.com/2.jpg',
+      'Second photo is the middle'
+    );
+    assert.strictEqual(
+      entries[0].photos[2].url,
+      'https://x.com/3.jpg',
+      'Third photo is the newest'
+    );
+  });
+
+  test('groupPhotoContributions groups by OSM entity identifier', function (assert) {
+    const events = [
+      makePhotoEvent({
+        id: 'e1',
+        created_at: 1000,
+        placeIdentifier: 'osm:node:111',
+        url: 'https://x.com/a.jpg',
+      }),
+      makePhotoEvent({
+        id: 'e2',
+        created_at: 1000,
+        placeIdentifier: 'osm:node:222',
+        url: 'https://x.com/b.jpg',
+      }),
+    ];
+
+    const entries = groupPhotoContributions(events);
+    assert.strictEqual(entries.length, 2);
+  });
+
+  test('groupPhotoContributions sorts entries newest-first', function (assert) {
+    const events = [
+      makePhotoEvent({
+        id: 'old',
+        created_at: 100,
+        placeIdentifier: 'osm:node:111',
+      }),
+      makePhotoEvent({
+        id: 'new',
+        created_at: 200,
+        placeIdentifier: 'osm:node:222',
+      }),
+      makePhotoEvent({
+        id: 'mid',
+        created_at: 150,
+        placeIdentifier: 'osm:node:333',
+      }),
+    ];
+
+    const entries = groupPhotoContributions(events);
+    assert.strictEqual(entries[0].placeIdentifier, 'osm:node:222');
+    assert.strictEqual(entries[1].placeIdentifier, 'osm:node:333');
+    assert.strictEqual(entries[2].placeIdentifier, 'osm:node:111');
+  });
+
+  test('groupPhotoContributions respects custom threshold hours', function (assert) {
+    // Events 2 hours apart. With threshold 1, they are separate; with 3, they group.
+    const events = [
+      makePhotoEvent({
+        id: 'e1',
+        created_at: 1000,
+        url: 'https://x.com/1.jpg',
+      }),
+      makePhotoEvent({
+        id: 'e2',
+        created_at: 1000 + 2 * 60 * 60,
+        url: 'https://x.com/2.jpg',
+      }),
+    ];
+
+    assert.strictEqual(groupPhotoContributions(events, 1).length, 2);
+    assert.strictEqual(groupPhotoContributions(events, 3).length, 1);
+  });
+
+  test('groupPhotoContributions parses place identifier into osmType and osmId', function (assert) {
+    const events = [
+      makePhotoEvent({
+        id: 'e1',
+        created_at: 1000,
+        placeIdentifier: 'osm:way:98765',
+      }),
+    ];
+
+    const entries = groupPhotoContributions(events);
+    assert.strictEqual(entries[0].osmType, 'way');
+    assert.strictEqual(entries[0].osmId, '98765');
+  });
+
+  test('groupPhotoContributions attaches t tags to photos', function (assert) {
+    const events = [
+      makePhotoEvent({
+        id: 'e1',
+        created_at: 1000,
+        tags: ['food', 'vibe'],
+      }),
+    ];
+
+    const entries = groupPhotoContributions(events);
+    assert.deepEqual(entries[0].photos[0].tags, ['food', 'vibe']);
+  });
+
+  test('groupPhotoContributions excludes events deleted by kind 5', function (assert) {
+    const events = [
+      makePhotoEvent({
+        id: 'e1',
+        created_at: 1000,
+        url: 'https://x.com/1.jpg',
+      }),
+      makePhotoEvent({
+        id: 'e2',
+        created_at: 2000,
+        url: 'https://x.com/2.jpg',
+      }),
+      makeDeletionEvent({ id: 'd1', targetId: 'e1' }),
+    ];
+
+    const entries = groupPhotoContributions(events);
+    assert.strictEqual(entries.length, 1);
+    assert.strictEqual(entries[0].photos[0].url, 'https://x.com/2.jpg');
+  });
+
+  test('groupPhotoContributions skips events without an i tag', function (assert) {
+    const events = [
+      {
+        id: 'no-i',
+        pubkey: 'pubkey-1',
+        kind: 360,
+        created_at: 1000,
+        tags: [['imeta', 'url https://x.com/1.jpg', 'dim 800x600']],
+      },
+    ];
+
+    const entries = groupPhotoContributions(events);
+    assert.strictEqual(entries.length, 0);
+  });
+
+  test('groupPhotoContributions skips events without a usable imeta', function (assert) {
+    const events = [makePhotoEvent({ id: 'e1', created_at: 1000, url: null })];
+
+    // The helper always sets a URL, so override manually
+    events[0].tags = [
+      ['i', 'osm:node:123'],
+      ['imeta', 'dim 800x600'],
+    ];
+
+    const entries = groupPhotoContributions(events);
+    assert.strictEqual(entries.length, 0);
+  });
+});

tests/unit/utils/format-text-test.js

@@ -0,0 +1,66 @@
+import { module, test } from 'qunit';
+import {
+  formatRelativeDate,
+  humanizeOsmTag,
+  capitalize,
+} from 'marco/utils/format-text';
+
+module('Unit | Utility | format-text', function () {
+  test('humanizeOsmTag replaces underscores and dashes with spaces and title-cases', function (assert) {
+    assert.strictEqual(humanizeOsmTag('atm'), 'Atm');
+    assert.strictEqual(humanizeOsmTag('fast_food'), 'Fast Food');
+    assert.strictEqual(humanizeOsmTag('phone-repair'), 'Phone Repair');
+    assert.strictEqual(humanizeOsmTag(''), '');
+    assert.strictEqual(humanizeOsmTag(null), '');
+  });
+
+  test('capitalize uppercases the first letter', function (assert) {
+    assert.strictEqual(capitalize('hello'), 'Hello');
+    assert.strictEqual(capitalize(''), '');
+    assert.strictEqual(capitalize(null), '');
+  });
+
+  test('formatRelativeDate returns empty string for falsy timestamp', function (assert) {
+    assert.strictEqual(formatRelativeDate(null), '');
+    assert.strictEqual(formatRelativeDate(0), '');
+    assert.strictEqual(formatRelativeDate(undefined), '');
+  });
+
+  test('formatRelativeDate returns "just now" for timestamps within the last minute', function (assert) {
+    const now = Math.floor(Date.now() / 1000);
+    assert.strictEqual(formatRelativeDate(now), 'just now');
+    assert.strictEqual(formatRelativeDate(now - 10), 'just now');
+  });
+
+  test('formatRelativeDate returns "min ago" for timestamps within the last hour', function (assert) {
+    const now = Math.floor(Date.now() / 1000);
+    assert.strictEqual(formatRelativeDate(now - 60), '1 min ago');
+    assert.strictEqual(formatRelativeDate(now - 300), '5 min ago');
+    assert.strictEqual(formatRelativeDate(now - 3599), '59 min ago');
+  });
+
+  test('formatRelativeDate returns "hr ago" for timestamps within the last day', function (assert) {
+    const now = Math.floor(Date.now() / 1000);
+    assert.strictEqual(formatRelativeDate(now - 3600), '1 hr ago');
+    assert.strictEqual(formatRelativeDate(now - 7200), '2 hr ago');
+    assert.strictEqual(formatRelativeDate(now - 86399), '23 hr ago');
+  });
+
+  test('formatRelativeDate returns "day(s) ago" for timestamps within the last week', function (assert) {
+    const now = Math.floor(Date.now() / 1000);
+    assert.strictEqual(formatRelativeDate(now - 86400), '1 day ago');
+    assert.strictEqual(formatRelativeDate(now - 86400 * 2), '2 days ago');
+    assert.strictEqual(formatRelativeDate(now - 86400 * 6), '6 days ago');
+  });
+
+  test('formatRelativeDate returns an absolute date for timestamps older than a week', function (assert) {
+    const now = Math.floor(Date.now() / 1000);
+    const oldTimestamp = now - 86400 * 30; // 30 days ago
+    const result = formatRelativeDate(oldTimestamp);
+    // The exact format depends on the locale, but it should contain a year
+    assert.ok(
+      result.includes(String(new Date().getFullYear())),
+      'Contains the year'
+    );
+  });
+});

tests/unit/utils/nostr-test.js

@@ -210,6 +210,66 @@ module('Unit | Utility | nostr', function () {
     assert.strictEqual(photos[0].alt, null);
   });
 
+  test('parsePlacePhotos extracts published_at when present', function (assert) {
+    const events = [
+      {
+        id: 'event-1',
+        pubkey: 'pubkey-1',
+        created_at: 200,
+        tags: [
+          ['i', 'osm:node:123'],
+          ['published_at', '100'],
+          ['imeta', 'url https://example.com/photo.jpg', 'dim 800x600'],
+        ],
+      },
+    ];
+
+    const photos = parsePlacePhotos(events);
+
+    assert.strictEqual(photos.length, 1);
+    assert.strictEqual(photos[0].publishedAt, 100);
+    assert.strictEqual(photos[0].createdAt, 200);
+  });
+
+  test('parsePlacePhotos sets publishedAt to null when not present', function (assert) {
+    const events = [
+      {
+        id: 'event-1',
+        pubkey: 'pubkey-1',
+        created_at: 200,
+        tags: [
+          ['i', 'osm:node:123'],
+          ['imeta', 'url https://example.com/photo.jpg', 'dim 800x600'],
+        ],
+      },
+    ];
+
+    const photos = parsePlacePhotos(events);
+
+    assert.strictEqual(photos.length, 1);
+    assert.strictEqual(photos[0].publishedAt, null);
+  });
+
+  test('parsePlacePhotos ignores invalid published_at values', function (assert) {
+    const events = [
+      {
+        id: 'event-1',
+        pubkey: 'pubkey-1',
+        created_at: 200,
+        tags: [
+          ['i', 'osm:node:123'],
+          ['published_at', 'not-a-number'],
+          ['imeta', 'url https://example.com/photo.jpg', 'dim 800x600'],
+        ],
+      },
+    ];
+
+    const photos = parsePlacePhotos(events);
+
+    assert.strictEqual(photos.length, 1);
+    assert.strictEqual(photos[0].publishedAt, null);
+  });
+
   test('uniqNormalizedRelays returns normalized unique relays', function (assert) {
     const relays = uniqNormalizedRelays([
       'Relay.example.com',