**Status**: Planning
+> **Status**: ON HOLD (deferred 2026-06-23 — revisit after launch backlog clears)
+> **Status (original)**: Planning
> **Platforms**: Android, iOS, Windows, macOS, Linux
> **Framework**: [Capacitor](https://capacitorjs.com/) by Ionic
> **Goal**: Ship bitvid as a native app on all major platforms while keeping a single codebase with the existing web/PWA deployment.
diff --git a/docs/nip46-roadmap.md b/docs/nip46-roadmap.md
index aaca171c..1bc959a6 100644
--- a/docs/nip46-roadmap.md
+++ b/docs/nip46-roadmap.md
@@ -1,5 +1,7 @@
# NIP-46 Roadmap & Features
+> **Status**: ON HOLD (deferred 2026-06-23 — current NIP-46 login is working well; revisit these enhancements later).
+
This document outlines the current state of our NIP-46 (Nostr Connect) implementation and tracks future enhancements. The goal is to provide a seamless, secure, and user-friendly remote signing experience.
## Current State
diff --git a/docs/zap-audit-plan.md b/docs/zap-audit-plan.md
index b8c51cfa..53e2a625 100644
--- a/docs/zap-audit-plan.md
+++ b/docs/zap-audit-plan.md
@@ -18,6 +18,88 @@ Pre-launch priority #3. The zap flow feels clunky and errors on send.
platform address via `platformAddress.js` / `PLATFORM_LUD16_OVERRIDE`.
## Findings so far
+
+### 2026-06-23 session 3 (live-test: successful zap reported as error)
+- **A successful zap was shown as a red error (FIXED, item #4).** Live test: zapping
+ `NosToons@coinos.io` (CORS-friendly) actually PAID — the platform fee landed — but
+ bitvid showed *"Awaiting validated zap receipt… No zap receipt was published on the
+ advertised relays."* Root cause: a share whose PAYMENT succeeded (NWC returned a
+ preimage) but whose kind-9735 receipt couldn't be validated was routed through
+ `notifyError` as a warning. The preimage is proof the invoice was paid; the 9735 is
+ supplementary and a static client commonly can't see it (relay coverage/timing/late
+ publish). Fixed (`js/ui/zapController.js`): paid-but-unvalidated is now a SUCCESS with
+ a soft note ("Payment went through; couldn't confirm the zap receipt on relays").
+ Genuine payment failures (status !== success) still go through the failure/retry path.
+ Spec-corrected test in `tests/video-modal-zap.test.mjs` (see TEST_INTEGRITY.md).
+ RECEIPT DISCOVERY FIXED (item #4, 2026-06-23): the validator queried receipts with
+ `{ kinds:[9735], "#bolt11":[invoice] }` — but most relays DON'T index arbitrary tags
+ like `bolt11`, so the query returned nothing even when the receipt was published.
+ New `buildReceiptFilters` (`js/payments/zapReceiptValidator.js`) queries by the
+ reliably-indexed `#e` (event) / `#a` (coordinate) + `#p` (recipient) tags from the
+ zap request, falling back to `#bolt11` only if no anchor exists; the precise match
+ (author pubkey + bolt11 + description hash) still confirms the right receipt. Tests
+ in `tests/zap-receipt-pool.test.mjs` + spec-corrected `tests/zap-split.test.mjs`.
+ TIMING GAP CLOSED (2026-06-23): the validator now POLLS for the receipt — up to 3
+ lookups (default), ~1.2s apart — so a receipt the recipient's service publishes a
+ few seconds after EOSE is still caught. Stops as soon as it's found (no delay in the
+ common case); attempts/delay/sleep are injectable (`receiptLookupAttempts`,
+ `receiptLookupDelayMs`, `sleep`) and tests stub `sleep` so they don't wait. Reason
+ now distinguishes "no events at all" vs "events but none matched". Tests:
+ `testValidateZapReceiptRetriesForLateReceipt` (found on 3rd poll) +
+ `testValidateZapReceiptGivesUpAfterRetries` in `tests/zap-split.test.mjs`. NOTE: in
+ the no-receipt case this adds ~2.4s before the (success-with-note) status shows;
+ acceptable for a payment confirmation. A fully background validate-and-upgrade flow
+ remains a possible future refinement.
+- LOG NOISE seen during the live test (pre-existing, separate items): cold-start
+ RELAY STORM (~28 REQ/s, item #9); `bad req: uneven size input to from_hex` (odd-length
+ hex reaching a relay — the sanitizer #9 should catch this; re-confirm); watch-history
+ bucketing items with `watchedAt:0` into a `1970-01` month (minor watch-history bug).
+
+### 2026-06-23 session 2 (live-test fixes)
+- **Couldn't type in the zap comment box (FIXED, real bug).** The shared popover
+ engine treats every panel as an ARIA menu and `preventDefault`'d single-character
+ + arrow keydowns → every keystroke in the comment/amount fields was swallowed.
+ `handleMenuKeydown` now ignores events from editable targets
+ (input/textarea/select/contenteditable/role=textbox). Regression test in
+ `tests/ui/popoverEngine.test.mjs`.
+- **NWC wallet didn't restore "like storage" (FIXED, real bug).** The "already
+ offered" flag in `settingsRestorePrompt.js` was per-PUBKEY, so the first item
+ offered (storage) flagged the whole account and the wallet note was never offered
+ afterward. Now tracked PER-ITEM. Decision (user, 2026-06-23): keep the one-time
+ CONFIRM for the wallet (it's a spending secret) — not silent auto-restore.
+ Regression test in `tests/settings-restore-prompt.test.mjs`.
+- **"Click the Zap button many times before it opens" (FIX — needs live confirm).**
+ A click during an in-flight open canceled it (`pendingToggle="close"`), so rapid
+ double-clicks toggled the popover back closed. Now an in-flight-open click is
+ ignored unless the dialog is already visibly open. (`video-modal/zapController.js`)
+- **CORS confirmed for goblinbox** (`unitypay.cash/.well-known/lnurlp/goblinbox` →
+ net::ERR_FAILED). With the NWC fix in place, `wallet.hasUri:true` — the send fails
+ purely at the LNURL fetch (CORS), not NWC. This is the data point for the proxy
+ decision (item 1).
+
+### 2026-06-23 session (fixes landed)
+- **NWC wallet connection was BROKEN (launch-blocker, FIXED).** `parseNwcUri`
+ (`js/payments/nwcClient.js`) passed the hex `secret` to nostr-tools `getPublicKey`,
+ which in v2.x requires a `Uint8Array` → it threw `expected Uint8Array` and the whole
+ NWC connect failed (NWC is the only zap payment path). Now converts hex→bytes (try
+ hex, fall back to `hexToBytesCompat`). Real-tools regression test:
+ `tests/nwc-parse-uri.test.mjs`. (The mock-based `tests/nwc-client.test.mjs` is still
+ quarantined — its nostr-tools mock is shadowed by the frozen canonical toolkit; needs
+ a harness rework, but the bug itself is fixed + guarded.)
+- **In-flight "Sending… sats" status was mis-toned as `warning` (FIXED).** A pending
+ state was colored `text-warning-strong` (alarming) and counted as a warning. Now
+ `neutral`. (`js/ui/zapController.js`)
+- **Success path didn't fully reset the form (FIXED).** The terminal success path
+ cleared only the comment (`setZapComment`) while the validation-warning path used the
+ holistic `resetZapForm`. Unified to `resetZapForm({amount:"",comment:""})` so amount +
+ comment reset consistently after a send. (`js/ui/zapController.js`)
+- **Fee-fallback is no-bypass (verified).** `resolvePlatformFeePercent` falls back to
+ the configured `PLATFORM_FEE_PERCENT` (30) on an unparseable override — a junk override
+ can't silently disable the fee. (Stale test that expected 0 corrected.)
+- **3a popover** — FIXED separately (see TODO 3a); the in-modal zap dialog now portals
+ to `#uiOverlay` so it positions `bottom-end` under the button.
+
+### Earlier findings
- **Send error = recipient LNURL unreachable (CORS/offline).** [PARTLY FIXED]
Sending to a creator whose LNURL host is down or lacks CORS headers (observed:
`unitypay.cash/.well-known/lnurlp/goblinbox`) makes the browser `fetch` reject
@@ -31,13 +113,15 @@ Pre-launch priority #3. The zap flow feels clunky and errors on send.
- **Popover mis-positioning (zap + embed)** — see TODO 3a; shared `popoverEngine`.
## To do (next session, in priority order)
-1. **CORS / LNURL proxy decision (the real reliability fix).** A static client
- can't fetch LNURL endpoints that omit CORS headers, so zaps to many creators
- fail. Options: (a) a small server-side/edge proxy (Vercel function) that fetches
- the LNURL pay-service data + invoice and returns it with CORS — what most web
- wallets do; (b) document the limitation and only support CORS-enabled hosts;
- (c) route via the connected NWC wallet if it can resolve LN addresses. Decide,
- then implement. Confirm whether `unitypay.cash` is also just offline.
+1. **CORS / LNURL proxy — DECISION: re-test first (2026-06-23).** Because the NWC
+ connection was fully broken (hex secret → `getPublicKey`; fixed this session), an
+ unknown share of the observed "send errors" were the NWC bug, NOT CORS. Plan:
+ deploy the NWC fix, run real zaps, and measure the actual CORS failure rate before
+ committing to a proxy. THEN choose: (a) small Vercel edge proxy that fetches LNURL
+ pay-data + invoice and returns with CORS [recommended if the rate is high — what web
+ wallets do]; (b) document the limit / CORS-only hosts; (c) route LN-address
+ resolution via the connected NWC wallet. Also confirm whether `unitypay.cash` is
+ simply offline vs. CORS-less.
2. **Popover positioning (3a).** Fix the shared engine safely (portal in-modal
panels out to `#uiOverlay`, or remove the modal-subtree containing block).
Needs the live computed `position/left/top` + DOM parent of `#modalZapDialog`.
diff --git a/js/app.js b/js/app.js
index 59db1b8a..96f4d2f5 100644
--- a/js/app.js
+++ b/js/app.js
@@ -2974,6 +2974,37 @@ class Application {
return false;
}
+ // Direct messages require a signing identity. If nobody is logged in, prompt
+ // for login instead of silently opening an unusable messages tab.
+ if (!this.isUserLoggedIn()) {
+ this.showError(
+ "Please log in with your Nostr account to send a direct message.",
+ );
+ try {
+ if (
+ this.loginModalController &&
+ typeof this.loginModalController.openModal === "function" &&
+ this.loginModalController.openModal({})
+ ) {
+ return false;
+ }
+ } catch (error) {
+ devLogger.warn(
+ "[Application] Failed to open login modal for direct message:",
+ error,
+ );
+ }
+ Promise.resolve(
+ this.authService?.requestLogin?.({ allowAccountSelection: true }),
+ ).catch((error) => {
+ devLogger.warn(
+ "[Application] Direct message login request failed:",
+ error,
+ );
+ });
+ return false;
+ }
+
this.setDmRecipientPubkey(normalized);
if (this.profileController) {
@@ -3905,6 +3936,11 @@ class Application {
return this._feed.registerExploreFeed(...args);
}
+ registerTrendingFeed(...args) {
+ this._initCoordinators();
+ return this._feed.registerTrendingFeed(...args);
+ }
+
registerSubscriptionsFeed(...args) {
this._initCoordinators();
return this._feed.registerSubscriptionsFeed(...args);
@@ -3950,6 +3986,11 @@ class Application {
return this._feed.refreshFeed(FEED_TYPES.EXPLORE, ...args);
}
+ refreshTrendingFeed(...args) {
+ this._initCoordinators();
+ return this._feed.refreshFeed(FEED_TYPES.TRENDING, ...args);
+ }
+
refreshRecentFeed(...args) {
this._initCoordinators();
return this._feed.refreshFeed("recent", ...args);
@@ -3993,6 +4034,11 @@ class Application {
return this._feed.loadExploreVideos(...args);
}
+ async loadTrendingVideos(...args) {
+ this._initCoordinators();
+ return this._feed.loadTrendingVideos(...args);
+ }
+
async loadOlderVideos(...args) {
this._initCoordinators();
return this._feed.loadOlderVideos(...args);
diff --git a/js/app/authSessionCoordinator.js b/js/app/authSessionCoordinator.js
index dc79c790..22fc2f9a 100644
--- a/js/app/authSessionCoordinator.js
+++ b/js/app/authSessionCoordinator.js
@@ -12,7 +12,7 @@
import { clearDecryptionSchemeCache } from "../nostr/decryptionSchemeCache.js";
import { clearWatchHistoryConversationKeyCache } from "../nostr/watchHistory.js";
import { clearWatchHistoryDecryptedChunkCache } from "../nostr/watchHistoryDecryptCache.js";
-import { FEED_TYPES } from "../constants.js";
+import { FEED_TYPES, FEATURE_TRENDING_FEED } from "../constants.js";
/**
* Kick a background watch-history refresh after login, once the feed-driving
@@ -988,7 +988,11 @@ export function createAuthSessionCoordinator(deps) {
typeof logoutView === "string" &&
logoutView.trim().toLowerCase() === FEED_TYPES.FOR_YOU
) {
- setHashView(FEED_TYPES.RECENT);
+ // For You is logged-in only; send logged-out users to the same landing
+ // as the default homepage — Trending (or Recent if Trending is off).
+ setHashView(
+ FEATURE_TRENDING_FEED ? FEED_TYPES.TRENDING : FEED_TYPES.RECENT
+ );
}
const activeModalVideo =
diff --git a/js/app/feedCoordinator.js b/js/app/feedCoordinator.js
index b461d2d7..2ac93bbc 100644
--- a/js/app/feedCoordinator.js
+++ b/js/app/feedCoordinator.js
@@ -10,6 +10,10 @@
*/
import { FEED_TYPES, STANDARD_TIMEOUT_MS, MEDIUM_TIMEOUT_MS, DEBOUNCE_DELAY_MS } from "../constants.js";
+import {
+ registerTrendingFeed as registerTrendingFeedPipeline,
+ buildTrendingFeedRuntime,
+} from "../feedEngine/trendingFeed.js";
/**
* @param {object} deps - Injected dependencies.
@@ -398,7 +402,7 @@ export function createFeedCoordinator(deps) {
createResolvePostedAtStage(),
createExploreScorerStage(),
],
- sorter: createExploreDiversitySorter(),
+ sorter: createExploreDiversitySorter({ lambda: 0.5 }),
hooks: {
timestamps: {
getKnownVideoPostedAt: (video) => this.getKnownVideoPostedAt(video),
@@ -531,20 +535,11 @@ export function createFeedCoordinator(deps) {
const preferencesAvailable = preferenceSource?.dataReady === true;
const moderationThresholds = this.getActiveModerationThresholds();
- // Follows drive the For You ranking (follows-boost in the scorer).
- let subscriptionAuthors = [];
- try {
- if (subscriptions && typeof subscriptions.getSubscribedAuthors === "function") {
- const authors = subscriptions.getSubscribedAuthors();
- if (Array.isArray(authors)) {
- subscriptionAuthors = authors.filter(
- (a) => typeof a === "string" && a,
- );
- }
- }
- } catch (error) {
- devLogger.warn("[feedCoordinator] Failed to read subscribed authors:", error);
- }
+ // Follows drive the For You ranking (follows-boost in the scorer). The
+ // refreshFeed caller wraps this in a try, so optional chaining is enough.
+ const subscriptionAuthors = (
+ subscriptions?.getSubscribedAuthors?.() || []
+ ).filter((a) => typeof a === "string" && a);
// Watch-topic affinity signal (reuse the Explore source if present).
const whTagSource =
@@ -671,6 +666,11 @@ export function createFeedCoordinator(deps) {
return {
blacklistedEventIds: blacklist,
isAuthorBlocked: (pubkey) => this.isAuthorBlocked(pubkey),
+ // Explore leans new-to-you: the scorer applies a soft penalty to authors
+ // you already follow so non-followed creators surface.
+ subscriptionAuthors: (
+ subscriptions?.getSubscribedAuthors?.() || []
+ ).filter((a) => typeof a === "string" && a),
tagPreferences: {
interests: Array.isArray(interests) ? [...interests] : [],
disinterests: Array.isArray(disinterests) ? [...disinterests] : [],
@@ -848,14 +848,18 @@ export function createFeedCoordinator(deps) {
);
}
runtime = this.buildForYouFeedRuntime({ watchHistoryItems });
+ // Keep the scorer/sorter's "your people first" order — without this
+ // VideoListView re-sorts chronologically and For You looks like Recent.
+ metadataModifier = (m) => ({ ...m, preserveOrder: true });
break;
}
case FEED_TYPES.KIDS:
runtime = this.buildKidsFeedRuntime();
metadataModifier = (m) => {
- if (runtime?.ageGroup && !m.ageGroup)
- m.ageGroup = runtime.ageGroup;
- return m;
+ const next = { ...m, preserveOrder: true };
+ if (runtime?.ageGroup && !next.ageGroup)
+ next.ageGroup = runtime.ageGroup;
+ return next;
};
break;
case FEED_TYPES.EXPLORE:
@@ -867,6 +871,11 @@ export function createFeedCoordinator(deps) {
return next;
};
break;
+ case FEED_TYPES.TRENDING:
+ runtime = buildTrendingFeedRuntime(this);
+ // Preserve the view-count ranking (otherwise re-sorted by date).
+ metadataModifier = (m) => ({ ...m, preserveOrder: true });
+ break;
case "recent":
runtime = this.buildRecentFeedRuntime();
break;
@@ -1026,6 +1035,12 @@ export function createFeedCoordinator(deps) {
refreshMethod = (opts) => this.refreshFeed(FEED_TYPES.EXPLORE, opts);
shouldCheckRelayHealth = false;
break;
+ case FEED_TYPES.TRENDING:
+ includeTags = false;
+ loadingMessage = "Fetching trending videos\u2026";
+ refreshMethod = (opts) => this.refreshFeed(FEED_TYPES.TRENDING, opts);
+ shouldCheckRelayHealth = false;
+ break;
default:
devLogger.warn(
`[Application] Unknown feed type for loadFeedVideos: ${feedType}`,
@@ -1120,6 +1135,14 @@ export function createFeedCoordinator(deps) {
return this.loadFeedVideos(FEED_TYPES.EXPLORE, forceFetch);
},
+ registerTrendingFeed() {
+ return registerTrendingFeedPipeline(this);
+ },
+
+ async loadTrendingVideos(forceFetch = false) {
+ return this.loadFeedVideos(FEED_TYPES.TRENDING, forceFetch);
+ },
+
async loadOlderVideos(lastTimestamp) {
const olderVideos = await this.nostrService.loadOlderVideos(lastTimestamp, {
blacklistedEventIds: this.blacklistedEventIds,
diff --git a/js/app/playbackCoordinator.js b/js/app/playbackCoordinator.js
index e9f00649..37bae812 100644
--- a/js/app/playbackCoordinator.js
+++ b/js/app/playbackCoordinator.js
@@ -867,6 +867,10 @@ export function createPlaybackCoordinator(deps) {
const playbackOptions = {
url: trimmedUrl,
magnet: magnetInput,
+ // Hosted mirrors (NIP-71 imeta variants) to fail over to mid-load.
+ sources: Array.isArray(this.currentVideo?.sources)
+ ? this.currentVideo.sources
+ : [],
};
if (hasTrigger) {
playbackOptions.trigger = this.lastModalTrigger;
diff --git a/js/channelProfile.js b/js/channelProfile.js
index e8e4935d..b6e59fe4 100644
--- a/js/channelProfile.js
+++ b/js/channelProfile.js
@@ -1,7 +1,7 @@
// js/channelProfile.js
import { nostrClient } from "./nostrClientFacade.js";
-import { convertChannelEvent, buildChannelVideoFilters, loadCachedChannelVideos, saveCachedChannelVideos } from "./channelProfileVideos.js";
+import { convertChannelEvent, buildChannelVideoFilters, loadCachedChannelVideos, saveCachedChannelVideos, mergeChannelVideoSources } from "./channelProfileVideos.js";
import { dedupeVideos } from "./utils/videoDeduper.js";
import { DEFAULT_RELAY_URLS } from "./nostr/toolkit.js";
import { subscriptions } from "./subscriptions.js";
@@ -5440,7 +5440,7 @@ async function loadUserVideos(pubkey) {
return;
}
- const videos = buildRenderableChannelVideos({ events, app });
+ const videos = buildRenderableChannelVideos({ events: mergeChannelVideoSources(events, getCachedChannelVideoEvents(pubkey)), app });
saveCachedChannelVideos(pubkey, videos);
const rendered = await renderChannelVideosFromList({
videos,
diff --git a/js/channelProfileVideos.js b/js/channelProfileVideos.js
index 766d8f3b..669d9d02 100644
--- a/js/channelProfileVideos.js
+++ b/js/channelProfileVideos.js
@@ -28,6 +28,33 @@ export function convertChannelEvent(entry) {
return sharedConvertEventToVideo(entry);
}
+// Reconcile a fresh live fetch with already-known events (the in-memory video
+// store + persisted cache) so a transiently-failing relay can't SHRINK the grid.
+// The channel render replaces the container with the live set, so rendering only
+// what this load fetched drops any video whose sole relay timed out — the "some
+// of a creator's videos are missing" bug. Union the two by event id (live wins on
+// collision since it's the freshest copy); the caller's dedupe-by-root + access
+// checks still handle versioning, deletes, and precedence downstream.
+export function mergeChannelVideoSources(liveEvents, knownEvents) {
+ const byId = new Map();
+ const extras = [];
+ const add = (list) => {
+ if (!Array.isArray(list)) return;
+ for (const entry of list) {
+ if (!entry || typeof entry !== "object") continue;
+ const id = typeof entry.id === "string" ? entry.id : "";
+ if (!id) {
+ extras.push(entry);
+ continue;
+ }
+ if (!byId.has(id)) byId.set(id, entry);
+ }
+ };
+ add(liveEvents); // live first → wins on id collision
+ add(knownEvents);
+ return [...byId.values(), ...extras];
+}
+
// ---- Per-channel persisted cache (instant cold-load paint) -------------------
// Mirrors the main feed's optimistic cache: on a cold hard-refresh of a profile,
// render the last-seen videos from localStorage BEFORE relays connect, then the
diff --git a/js/constants.js b/js/constants.js
index 5cb050cc..2dfc4d5f 100644
--- a/js/constants.js
+++ b/js/constants.js
@@ -197,6 +197,7 @@ const DEFAULT_FLAGS = Object.freeze({
FEATURE_TRUST_SEEDS: true, // Rollback: disable to drop baseline trust seeds without code changes.
FEATURE_TRUSTED_HIDE_CONTROLS: true,
FEATURE_IMPROVED_COMMENT_FETCHING: true, // Default true for comment persistence fixes
+ FEATURE_TRENDING_FEED: true, // "Trending" tab: recently-added ranked by view count. Disable to hide the tab.
TRUSTED_MUTE_HIDE_THRESHOLD: DEFAULT_TRUSTED_MUTE_HIDE_THRESHOLD,
TRUSTED_SPAM_HIDE_THRESHOLD: DEFAULT_TRUSTED_SPAM_HIDE_THRESHOLD,
WSS_TRACKERS: DEFAULT_WSS_TRACKERS,
@@ -220,6 +221,7 @@ const runtimeFlags = (() => {
FEATURE_TRUSTED_HIDE_CONTROLS: DEFAULT_FLAGS.FEATURE_TRUSTED_HIDE_CONTROLS,
FEATURE_IMPROVED_COMMENT_FETCHING:
DEFAULT_FLAGS.FEATURE_IMPROVED_COMMENT_FETCHING,
+ FEATURE_TRENDING_FEED: DEFAULT_FLAGS.FEATURE_TRENDING_FEED,
TRUSTED_MUTE_HIDE_THRESHOLD: DEFAULT_FLAGS.TRUSTED_MUTE_HIDE_THRESHOLD,
TRUSTED_SPAM_HIDE_THRESHOLD: DEFAULT_FLAGS.TRUSTED_SPAM_HIDE_THRESHOLD,
WSS_TRACKERS: [...DEFAULT_FLAGS.WSS_TRACKERS],
@@ -265,6 +267,11 @@ export let FEATURE_SEARCH_FILTERS = coerceBoolean(
DEFAULT_FLAGS.FEATURE_SEARCH_FILTERS
);
+export let FEATURE_TRENDING_FEED = coerceBoolean(
+ runtimeFlags.FEATURE_TRENDING_FEED,
+ DEFAULT_FLAGS.FEATURE_TRENDING_FEED
+);
+
export let FEATURE_TRUST_SEEDS = coerceBoolean(
runtimeFlags.FEATURE_TRUST_SEEDS,
DEFAULT_FLAGS.FEATURE_TRUST_SEEDS
@@ -538,6 +545,7 @@ export const FEED_TYPES = Object.freeze({
FOR_YOU: "for-you",
KIDS: "kids",
EXPLORE: "explore",
+ TRENDING: "trending",
SUBSCRIPTIONS: "subscriptions",
HISTORY: "history",
CHANNEL: "channel-profile",
diff --git a/js/dmDecryptor.js b/js/dmDecryptor.js
index e4f83cde..28f2c086 100644
--- a/js/dmDecryptor.js
+++ b/js/dmDecryptor.js
@@ -261,6 +261,21 @@ function orderDecryptors(candidates, hints, { preferGiftWrap = false, preferLega
}
}
+ // Legacy (kind 4) default: with no explicit hint, kind-4 DMs are NIP-04, so
+ // try nip04 first and don't burn a (serialized, slow) nip-07 round-trip on
+ // nip44. This MUST outrank `priority` below — the signer registers its nip44
+ // candidate at a lower (earlier) priority than nip04, so leaving priority to
+ // decide made every kind-4 message attempt nip44 first (guaranteed "invalid
+ // base64" on the ?iv= ciphertext) before falling back to nip04. Only flips
+ // the nip04-vs-nip44 default; an explicit hint above already took over.
+ if (preferLegacy && !hasHints) {
+ const aL = a.scheme === "nip04" ? 0 : 1;
+ const bL = b.scheme === "nip04" ? 0 : 1;
+ if (aL !== bL) {
+ return aL - bL;
+ }
+ }
+
if (a.priority !== b.priority) {
return a.priority - b.priority;
}
@@ -273,17 +288,6 @@ function orderDecryptors(candidates, hints, { preferGiftWrap = false, preferLega
}
}
- // Legacy (kind 4) default: with no explicit hint, kind-4 DMs are NIP-04, so
- // try nip04 first and don't burn a (serialized, slow) nip-07 round-trip on
- // nip44. Only flips the default — an explicit hint above already took over.
- if (preferLegacy && !hasHints) {
- const aL = a.scheme === "nip04" ? 0 : 1;
- const bL = b.scheme === "nip04" ? 0 : 1;
- if (aL !== bL) {
- return aL - bL;
- }
- }
-
const aRank = desiredSchemeRank(a.scheme);
const bRank = desiredSchemeRank(b.scheme);
if (aRank !== bRank) {
diff --git a/js/feedEngine/exploreScoring.js b/js/feedEngine/exploreScoring.js
index 01a47250..2ae562f7 100644
--- a/js/feedEngine/exploreScoring.js
+++ b/js/feedEngine/exploreScoring.js
@@ -4,12 +4,13 @@ import { normalizeHashtag } from "../utils/hashtagNormalization.js";
import { isPlainObject, toSet } from "./utils.js";
const DEFAULT_WEIGHTS = Object.freeze({
- novelty: 0.3,
- freshness: 0.25,
+ novelty: 0.35, // reward topics outside your watch history (discovery)
+ freshness: 0.12, // Explore is discovery, not "what's new" — recency matters less
historySimilarity: 0.2,
newTagFraction: 0.1,
popularityNorm: 0.1,
disinterestOverlap: 0.25,
+ followedPenalty: 0.3, // deprioritize creators you already follow → new-to-you
});
const DEFAULT_FRESHNESS_HALF_LIFE_DAYS = 14;
@@ -319,6 +320,10 @@ export function createExploreScorerStage({ stageName = "explore-scorer", ...opti
const popularityMax = resolvePopularityMax(options, context);
const freshnessHalfLifeDays = resolveFreshnessHalfLife(options, context);
const now = resolveNow(context);
+ // Soft penalty for creators you already follow so Explore leans toward
+ // creators that are NEW to you. A penalty (not a filter) keeps the feed full
+ // when you follow lots of people.
+ const follows = toSet(context?.runtime?.subscriptionAuthors);
for (const item of items) {
if (!item || typeof item !== "object") {
@@ -379,13 +384,17 @@ export function createExploreScorerStage({ stageName = "explore-scorer", ...opti
freshness = clamp01(decay);
}
+ const followedMatch =
+ typeof video.pubkey === "string" && follows.has(video.pubkey) ? 1 : 0;
+
const score = clamp01(
weights.novelty * novelty +
weights.freshness * freshness +
weights.historySimilarity * historySimilarityPositive +
weights.newTagFraction * newTagFraction +
weights.popularityNorm * popularityNorm -
- weights.disinterestOverlap * disinterestOverlap,
+ weights.disinterestOverlap * disinterestOverlap -
+ (weights.followedPenalty || 0) * followedMatch,
);
if (!isPlainObject(item.metadata)) {
@@ -400,6 +409,7 @@ export function createExploreScorerStage({ stageName = "explore-scorer", ...opti
historySimilarity,
popularityNorm,
freshness,
+ followedMatch,
tags: Array.from(videoTags),
};
@@ -459,6 +469,11 @@ const FOR_YOU_WEIGHTS = Object.freeze({
disinterestOverlap: 0.3, // penalty for disinterested tags
});
+// Affinity at/above this counts as a real interest match (tier 1), so
+// interest/watch-topic videos lead the feed alongside follows. Tuned low because
+// cosine affinity against a sparse user vector rarely gets near 1.
+const FOR_YOU_AFFINITY_TIER = 0.15;
+
/**
* For You scorer (docs/feed-algo-audit.md). Inclusive + ranked: it scores (never
* filters) so the feed is never empty — when you have no follows/interests/
@@ -540,6 +555,16 @@ export function createForYouScorerStage({
item.metadata = {};
}
item.metadata.forYouScore = score;
+ // Tier drives "your people first": followed authors (2) and interest/
+ // watch-topic matches (1) lead the feed regardless of recency; everything
+ // else (0) ranks below by score. The sorter reads this; when NO item is
+ // tiered (logged-out / no follows / no interests) it falls back to a
+ // discovery ordering so For You never mirrors Recently-added.
+ item.metadata.forYouTier = followsMatch
+ ? 2
+ : affinity >= FOR_YOU_AFFINITY_TIER
+ ? 1
+ : 0;
item.metadata.forYouComponents = {
followsMatch,
affinity,
diff --git a/js/feedEngine/sorters.js b/js/feedEngine/sorters.js
index e3a97f63..66b52878 100644
--- a/js/feedEngine/sorters.js
+++ b/js/feedEngine/sorters.js
@@ -3,21 +3,122 @@
import { normalizeHashtag } from "../utils/hashtagNormalization.js";
import { markAsNormalized } from "./utils.js";
-// Ranks by the For You score (set by createForYouScorerStage): score desc,
-// trusted-muted last, recency as the tiebreak. Reuses the same muted-last rule
-// as the chronological sorter so behavior is consistent across feeds.
+// Ranks the active feed by VIEW COUNT (the "Trending" tab). Counts come from the
+// injected runtime.getViewCount(video) — the shared viewCounter cache populated
+// by the grid cards' per-card subscriptions. Unknown/not-yet-loaded counts are
+// treated as 0, so on a cold cache the feed reads as recency and settles into
+// true trending as counts stream in (the Trending view re-runs the feed on
+// viewCounter's debounced change signal). Trusted-muted always sinks last.
+export function createTrendingSorter() {
+ return function trendingSorter(items = [], context = {}) {
+ if (!Array.isArray(items)) {
+ return [];
+ }
+ const getViewCount =
+ typeof context?.runtime?.getViewCount === "function"
+ ? context.runtime.getViewCount
+ : () => 0;
+
+ const isMuted = (entry) =>
+ entry?.metadata?.moderation?.trustedMuted === true ||
+ entry?.video?.moderation?.trustedMuted === true;
+
+ const timestampOf = (entry) => {
+ const video = entry?.video;
+ if (!video || typeof video !== "object") {
+ return Number.NEGATIVE_INFINITY;
+ }
+ const root = Number(video.rootCreatedAt);
+ if (Number.isFinite(root)) return Math.floor(root);
+ const created = Number(video.created_at);
+ return Number.isFinite(created) ? Math.floor(created) : Number.NEGATIVE_INFINITY;
+ };
+
+ // Resolve each item's view count once (avoid O(n log n) cache lookups).
+ const viewsByItem = new Map();
+ for (const item of items) {
+ let total = 0;
+ try {
+ const value = getViewCount(item?.video);
+ total = Number.isFinite(value) ? Number(value) : 0;
+ } catch (error) {
+ total = 0;
+ }
+ viewsByItem.set(item, total);
+ }
+
+ const compare = (a, b) => {
+ const viewDiff = (viewsByItem.get(b) || 0) - (viewsByItem.get(a) || 0);
+ if (viewDiff !== 0) return viewDiff;
+ return timestampOf(b) - timestampOf(a);
+ };
+
+ const live = items.filter((entry) => !isMuted(entry));
+ const muted = items.filter((entry) => isMuted(entry));
+ return [...live.sort(compare), ...muted.sort(compare)];
+ };
+}
+
+// Round-robin interleave by author: one video per creator per pass, each pass in
+// the caller's pre-sorted order. Consecutive cards are from different creators,
+// so a feed reads as a varied "discovery" mix instead of a chronological wall —
+// used for For You's no-signal fallback and Explore's diversity.
+export function interleaveByAuthor(items, { authorOf } = {}) {
+ if (!Array.isArray(items) || items.length < 3) {
+ return Array.isArray(items) ? [...items] : [];
+ }
+ const keyOf =
+ typeof authorOf === "function"
+ ? authorOf
+ : (entry) =>
+ typeof entry?.video?.pubkey === "string" ? entry.video.pubkey : "";
+
+ const buckets = new Map();
+ const order = [];
+ for (const item of items) {
+ const key = keyOf(item) || `__anon__${order.length}`;
+ if (!buckets.has(key)) {
+ buckets.set(key, []);
+ order.push(key);
+ }
+ buckets.get(key).push(item);
+ }
+
+ const result = [];
+ let remaining = items.length;
+ while (remaining > 0) {
+ for (const key of order) {
+ const bucket = buckets.get(key);
+ if (bucket && bucket.length) {
+ result.push(bucket.shift());
+ remaining -= 1;
+ }
+ }
+ }
+ return result;
+}
+
+// Ranks the For You feed "your people first": followed authors and interest/
+// watch-topic matches (forYouTier, set by the scorer) lead regardless of
+// recency, then everyone else by score. When NOTHING is tiered (logged-out / no
+// follows / no interests) it falls back to an author-interleaved discovery order
+// so the feed never mirrors Recently-added. Trusted-muted always sinks last.
export function createForYouScoreSorter() {
return function forYouScoreSorter(items = [], context = {}) {
if (!Array.isArray(items)) {
return [];
}
void context;
- const copy = [...items];
const isMuted = (entry) =>
entry?.metadata?.moderation?.trustedMuted === true ||
entry?.video?.moderation?.trustedMuted === true;
+ const tierOf = (entry) => {
+ const tier = Number(entry?.metadata?.forYouTier);
+ return Number.isFinite(tier) ? tier : 0;
+ };
+
const scoreOf = (entry) => {
const score = Number(entry?.metadata?.forYouScore);
return Number.isFinite(score) ? score : 0;
@@ -34,20 +135,32 @@ export function createForYouScoreSorter() {
return Number.isFinite(created) ? Math.floor(created) : Number.NEGATIVE_INFINITY;
};
- copy.sort((a, b) => {
- const aMuted = isMuted(a);
- const bMuted = isMuted(b);
- if (aMuted !== bMuted) {
- return aMuted ? 1 : -1;
- }
- const scoreDiff = scoreOf(b) - scoreOf(a);
- if (scoreDiff !== 0) {
- return scoreDiff;
- }
- return timestampOf(b) - timestampOf(a);
- });
+ const live = items.filter((entry) => !isMuted(entry));
+ const muted = items.filter((entry) => isMuted(entry));
- return copy;
+ const byScore = (a, b) => {
+ const scoreDiff = scoreOf(b) - scoreOf(a);
+ if (scoreDiff !== 0) return scoreDiff;
+ return timestampOf(b) - timestampOf(a);
+ };
+
+ const personalized = live.some((entry) => tierOf(entry) > 0);
+
+ let ordered;
+ if (personalized) {
+ // Tier desc, then score within tier. "Your people" rise to the top.
+ ordered = [...live].sort((a, b) => {
+ const tierDiff = tierOf(b) - tierOf(a);
+ if (tierDiff !== 0) return tierDiff;
+ return byScore(a, b);
+ });
+ } else {
+ // No signals → discovery fallback: score order, then interleave authors so
+ // it doesn't read as a chronological clone of Recently-added.
+ ordered = interleaveByAuthor([...live].sort(byScore));
+ }
+
+ return [...ordered, ...muted.sort(byScore)];
};
}
diff --git a/js/feedEngine/trendingFeed.js b/js/feedEngine/trendingFeed.js
new file mode 100644
index 00000000..c85e3ae8
--- /dev/null
+++ b/js/feedEngine/trendingFeed.js
@@ -0,0 +1,124 @@
+// js/feedEngine/trendingFeed.js
+//
+// The "Trending" tab: the recently-added (active) source ranked by VIEW COUNT.
+// Lives outside feedCoordinator.js (which is at its size cap) and is wired in via
+// thin delegations. The sorter ranks by the shared viewCounter cache; the
+// Trending view re-runs the feed on viewCounter's debounced change signal so the
+// order settles into true trending as counts stream in.
+
+import { FEED_TYPES } from "../constants.js";
+import { getVideoViewCountSnapshot } from "../viewCounter.js";
+import {
+ createActiveNostrSource,
+ createBlacklistFilterStage,
+ createDedupeByRootStage,
+ createModerationStage,
+ createResolvePostedAtStage,
+} from "./index.js";
+import { createTrendingSorter } from "./sorters.js";
+
+// Resolve a video's deduped view total from the shared viewCounter cache using
+// the app's canonical pointer derivation (the same key the grid cards subscribe
+// with, so Trending and the per-card count agree).
+function makeGetViewCount(app) {
+ return (video) => {
+ if (!video || typeof video !== "object") {
+ return 0;
+ }
+ try {
+ const info =
+ typeof app.deriveVideoPointerInfo === "function"
+ ? app.deriveVideoPointerInfo(video)
+ : null;
+ if (!info?.pointer) {
+ return 0;
+ }
+ const total = getVideoViewCountSnapshot(info.pointer);
+ return Number.isFinite(total) ? Number(total) : 0;
+ } catch (error) {
+ return 0;
+ }
+ };
+}
+
+export function buildTrendingFeedRuntime(app) {
+ const blacklist =
+ app.blacklistedEventIds instanceof Set
+ ? new Set(app.blacklistedEventIds)
+ : new Set();
+ const moderationThresholds =
+ typeof app.getActiveModerationThresholds === "function"
+ ? app.getActiveModerationThresholds()
+ : null;
+ return {
+ blacklistedEventIds: blacklist,
+ isAuthorBlocked: (pubkey) => app.isAuthorBlocked(pubkey),
+ moderationThresholds: moderationThresholds
+ ? { ...moderationThresholds }
+ : undefined,
+ getViewCount: makeGetViewCount(app),
+ };
+}
+
+export function registerTrendingFeed(app) {
+ if (!app?.feedEngine || typeof app.feedEngine.registerFeed !== "function") {
+ return null;
+ }
+ const existing =
+ typeof app.feedEngine.getFeedDefinition === "function"
+ ? app.feedEngine.getFeedDefinition(FEED_TYPES.TRENDING)
+ : null;
+ if (existing) {
+ return existing;
+ }
+
+ const resolveThreshold = (key) => ({ runtimeValue, defaultValue }) => {
+ if (
+ Number.isFinite(runtimeValue) ||
+ runtimeValue === Number.POSITIVE_INFINITY
+ ) {
+ return runtimeValue;
+ }
+ if (typeof app.getActiveModerationThresholds === "function") {
+ const active = app.getActiveModerationThresholds();
+ const candidate =
+ active && typeof active === "object" ? active[key] : undefined;
+ if (Number.isFinite(candidate) || candidate === Number.POSITIVE_INFINITY) {
+ return candidate;
+ }
+ }
+ return defaultValue;
+ };
+
+ try {
+ return app.feedEngine.registerFeed(FEED_TYPES.TRENDING, {
+ source: createActiveNostrSource({ service: app.nostrService }),
+ stages: [
+ createBlacklistFilterStage({
+ shouldIncludeVideo: (video, options) =>
+ app.nostrService.shouldIncludeVideo(video, options),
+ }),
+ createDedupeByRootStage({
+ dedupe: (videos) => app.dedupeVideosByRoot(videos),
+ }),
+ createModerationStage({
+ getService: () => app.nostrService.getModerationService(),
+ autoplayThreshold: resolveThreshold("autoplayBlockThreshold"),
+ blurThreshold: resolveThreshold("blurThreshold"),
+ trustedMuteHideThreshold: resolveThreshold("trustedMuteHideThreshold"),
+ trustedReportHideThreshold: resolveThreshold("trustedSpamHideThreshold"),
+ }),
+ createResolvePostedAtStage(),
+ ],
+ sorter: createTrendingSorter(),
+ hooks: {
+ timestamps: {
+ getKnownVideoPostedAt: (video) => app.getKnownVideoPostedAt(video),
+ resolveVideoPostedAt: (video) => app.resolveVideoPostedAt(video),
+ },
+ },
+ });
+ } catch (error) {
+ return null;
+ }
+}
diff --git a/js/hashChangeHandler.js b/js/hashChangeHandler.js
index 705d0a57..7ccb36ec 100644
--- a/js/hashChangeHandler.js
+++ b/js/hashChangeHandler.js
@@ -1,5 +1,5 @@
import { devLogger as defaultDevLogger, userLogger as defaultUserLogger } from "./utils/logger.js";
-import { FEED_TYPES } from "./constants.js";
+import { FEED_TYPES, FEATURE_TRENDING_FEED } from "./constants.js";
const LEGACY_DOCS_VIEWS = {
about: "about",
@@ -90,8 +90,12 @@ export function createHashChangeHandler({
try {
if (!match || !match[1]) {
+ // Logged in → personalized For You; logged out → Trending (the best
+ // not-personalized landing), falling back to Recent if Trending is off.
const defaultViewName = resolveIsLoggedIn()
? FEED_TYPES.FOR_YOU
+ : FEATURE_TRENDING_FEED
+ ? FEED_TYPES.TRENDING
: FEED_TYPES.RECENT;
if (defaultViewName === currentViewName) {
diff --git a/js/nostr/client.js b/js/nostr/client.js
index 4437e117..4faf16e0 100644
--- a/js/nostr/client.js
+++ b/js/nostr/client.js
@@ -42,6 +42,10 @@ import {
resolveStoragePointerValue,
} from "../utils/storagePointer.js";
import { RelayBatchFetcher } from "./relayBatchFetcher.js";
+// Single source of truth for active-key derivation. The tombstone/zombie-guard
+// logic below relies on it, and a stale local copy (missing the LEGACY: guard)
+// caused deleted legacy videos to resurrect — keep this imported, not duplicated.
+import { getActiveKey } from "./utils.js";
import { createPersistedPlaintextCache } from "./persistedPlaintextCache.js";
import {
createWatchHistoryManager,
@@ -407,17 +411,6 @@ function buildDmFilters(actorPubkey, { since, until, limit } = {}) {
return filters;
}
-function getActiveKey(video) {
- if (video.videoRootId) {
- return `ROOT:${video.videoRootId}`;
- }
- const dTag = video.tags?.find((t) => t[0] === "d");
- if (dTag) {
- return `${video.pubkey}:${dTag[1]}`;
- }
- return `LEGACY:${video.id}`;
-}
-
export {
convertEventToVideo,
Nip46RpcClient,
diff --git a/js/nostr/toolkit.js b/js/nostr/toolkit.js
index 94f46e5a..05d47e0b 100644
--- a/js/nostr/toolkit.js
+++ b/js/nostr/toolkit.js
@@ -151,7 +151,11 @@ function normalizeRelayList(relays) {
// 64-char lowercase hex. A single malformed/odd-length entry makes strict relays
// (e.g. primal) reject the whole REQ with "uneven size input to from_hex",
// silently dropping that subscription's results.
-const HEX64_FILTER_FIELDS = ["ids", "authors", "#e", "#p", "#q"];
+// Includes the NIP-22 UPPERCASE root-scope tags #E (root event id) and #P (root
+// author pubkey) — relays hex-decode these too, and the kind-1111 comment
+// subscriptions query by them, so an odd-length value there was bypassing the
+// sanitizer and getting the whole REQ rejected with "uneven size input to from_hex".
+const HEX64_FILTER_FIELDS = ["ids", "authors", "#e", "#p", "#q", "#E", "#P"];
const HEX64_PATTERN = /^[0-9a-f]{64}$/;
// Strip invalid hex from the hex-only filter fields so one bad value can't get a
diff --git a/js/nostr/viewEvents.js b/js/nostr/viewEvents.js
index d2740263..b38988ba 100644
--- a/js/nostr/viewEvents.js
+++ b/js/nostr/viewEvents.js
@@ -145,11 +145,14 @@ function generateViewEventDedupeTag(actorPubkey, pointer, createdAtSeconds) {
typeof actorPubkey === "string" && actorPubkey.trim()
? actorPubkey.trim().toLowerCase()
: "anon";
- const timestamp = Number.isFinite(createdAtSeconds)
- ? Math.max(0, Math.floor(createdAtSeconds))
- : Math.floor(Date.now() / 1000);
- const entropy = generateViewEventEntropy();
- return `${scope}:${normalizedActor}:${timestamp}:${entropy}`;
+ // DETERMINISTIC + window-bucketed. Kind-30079 view events are parameterized-
+ // replaceable (deduped by kind+pubkey+d-tag), so a stable d-tag per
+ // (viewer, video, dedupe-window) makes the relay collapse a viewer's repeat
+ // views in the same window into ONE event. That keeps both the NIP-45 COUNT and
+ // a list() accurate AND scalable. The old entropy+exact-timestamp tag made every
+ // view a unique event, defeating dedupe and inflating counts (item #4 audit).
+ const bucketIndex = deriveViewEventBucketIndex(createdAtSeconds);
+ return `${scope}:${normalizedActor}:${bucketIndex}`;
}
export function hasRecentViewPublish(scope, bucketIndex, actorPubkey) {
diff --git a/js/nostr/watchHistory.js b/js/nostr/watchHistory.js
index 9c1c07a3..e3056d2b 100644
--- a/js/nostr/watchHistory.js
+++ b/js/nostr/watchHistory.js
@@ -41,6 +41,7 @@ import {
import { pMap } from "../utils/asyncUtils.js";
import { selectNewestListEvent } from "./listEventOrdering.js";
import { dedupeNewestPerReplaceableAddress } from "./watchHistoryDedup.js";
+import { bucketWatchHistoryItemsByMonth } from "./watchHistoryBucketing.js";
import {
getCachedChunkPlaintext,
setCachedChunkPlaintext,
@@ -306,7 +307,7 @@ export function normalizeActorKey(actor) {
return trimmed.toLowerCase();
}
-function canonicalizeWatchHistoryItems(rawItems, maxItems = WATCH_HISTORY_MAX_ITEMS) {
+export function canonicalizeWatchHistoryItems(rawItems, maxItems = WATCH_HISTORY_MAX_ITEMS) {
const seen = new Map();
if (Array.isArray(rawItems)) {
for (const candidate of rawItems) {
@@ -360,20 +361,7 @@ function canonicalizeWatchHistoryItems(rawItems, maxItems = WATCH_HISTORY_MAX_IT
? deduped
: deduped.slice(0, Math.max(0, Math.floor(maxItems)));
- const buckets = {};
- for (const item of limited) {
- const watchedAt = Number.isFinite(item.watchedAt) ? item.watchedAt : 0;
- const date = new Date(watchedAt * 1000);
- const year = date.getUTCFullYear();
- const month = String(date.getUTCMonth() + 1).padStart(2, '0');
- const key = (watchedAt > 0) ? `${year}-${month}` : "1970-01";
-
- if (!buckets[key]) {
- buckets[key] = [];
- }
- buckets[key].push(item);
- }
- return buckets;
+ return bucketWatchHistoryItemsByMonth(limited);
}
diff --git a/js/nostr/watchHistoryBucketing.js b/js/nostr/watchHistoryBucketing.js
new file mode 100644
index 00000000..167a7a1b
--- /dev/null
+++ b/js/nostr/watchHistoryBucketing.js
@@ -0,0 +1,60 @@
+// Watch-history month bucketing. Items are grouped into "YYYY-MM" buckets by their
+// watch time. Legacy/migrated items can arrive with no real watch time
+// (watchedAt 0); those used to silo into a literal "1970-01" month that
+// self-perpetuated (read back as 0 -> re-bucketed -> re-published with 0). bitvid
+// pointer values look like "
+
+
+ Trending
+ +
+
+
+