fedipod 1.10.0 → 1.26.1

package/lib/client/masto/render.mjs

@@ -9,9 +9,25 @@ import { sanitizeHtml, followsNeedApproval, publicHandle } from '../../core/wire
 import { profileUrl, postUrl } from '../../connections/bskyfeed.mjs';
 import { htmlToText } from './body.mjs';
 
-// 1x1 transparent PNG — placeholder avatar/header for accounts without icons.
+// 1x1 transparent PNG — placeholder header, and the instance thumbnail. A
+// banner nobody set should take up no room and show nothing; an avatar is a
+// different matter (below).
 export const TRANSPARENT_PNG = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==';
 
+// The avatar for an account with no icon of its own: a head and shoulders on a
+// slate square, 64x64. It used to be the transparent pixel above, which is
+// correct JSON and invisible on screen — in Sengi's left bar the account button
+// (the one control that opens the account) rendered as an empty square, so
+// clicking it looked like nothing happening.
+//
+// A PNG rather than the SVG this was first written as, and not by preference:
+// Angular sanitizes every `<img src>` binding and trusts raster data URIs only,
+// because an SVG can carry script. An `svg+xml` one comes back out of it as
+// `unsafe:data:image/svg+xml` and draws nothing. Sengi is Angular.
+//
+// Redraw it with `node claude/scratch/make-default-avatar.mjs`.
+export const DEFAULT_AVATAR = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAABd0lEQVR42u3ZoW4CQRDG8Xk6NBLbVCJ5gBpMTQ2iBlFR29RXNsFhz1JHXV9hydfkEkoobW5n2F34i0kIHMfN73ZvdwYbTabpmsMAAAAAAAAAAAAAAAAAAACiY3wzS/ePz+n1bZW6zTZ9fH59h17rPX2mYy4OQEktnl5+JP1b6Bgdey6IcIDb2Ty9r7s/Ez8MfUffbRpACfznrp8aDdEIFjnsh9z5YyMhcjqEAWge5ybfh87VFIDuWM7QPzYVokZBCICWM6/k+9A5mwHQmu4NoHM2A+A5/PenQTMA3sn3AQBTgIcgyyAbIbbCFEOUwzREaInRFKUtDgAAFQLcPSxDCqH9Z4V+o0oAXVhU4ofhiWCtJe+NYKV3e6V3idkAHvv9nDqhKIBnxVeqUrRaav5SvQKrqetTols0GGDdbaoB0LWcFUBP31qS72PoimCtD//caWC1tL1Ltc2ttbXfe08wCKC25HP+OgMAAAAAAAAAAAAAAAAArhNgB1PE/x/JOiuNAAAAAElFTkSuQmCC';
+
 const selfIcon = (api, self, cached) =>
   (self ? api.store.getConfig()?.icon : null) || cached.icon;
 
@@ -46,11 +62,11 @@ export function account(api, actorUrl, { selfAcct } = {}) {
     // asking about itself would be told it was a person.
     bot: false, discoverable: true,
     group: self ? api.store.getConfig()?.kind === 'group' : cached.type === 'Group',
-    created_at: '2026-01-01T00:00:00.000Z',
+    created_at: (self && api.store.getConfig()?.createdAt) || '2026-01-01T00:00:00.000Z',
     note: (self ? api.store.getConfig()?.summary : cached.summary) || '',
     url: actorUrl, uri: actorUrl,
-    avatar: selfIcon(api, self, cached) || TRANSPARENT_PNG,
-    avatar_static: selfIcon(api, self, cached) || TRANSPARENT_PNG,
+    avatar: selfIcon(api, self, cached) || DEFAULT_AVATAR,
+    avatar_static: selfIcon(api, self, cached) || DEFAULT_AVATAR,
     header: (self ? api.store.getConfig()?.image : null) || TRANSPARENT_PNG,
     header_static: (self ? api.store.getConfig()?.image : null) || TRANSPARENT_PNG,
     // A remote actor's counts are whatever its own collections said when we
@@ -217,7 +233,37 @@ export async function acctReply(api, send, body, parent, visibility) {
   } catch (e) { return send(422, { error: e.message }); }
 }
 
-export function status(api, s, { all } = {}) {
+// The post a status quotes, and how the quote stands: `pending` until the
+// quoted author allows it, `accepted` once they have, `rejected` if they
+// refused. The quoted post is shown whenever it is held — a reader wants to
+// see what was quoted, whatever the state says. One level deep: a quote
+// inside a quote is named by id, not rendered, so the shape stays finite.
+export function quoteJson(api, s, { all, depth = 0 } = {}) {
+  if (!s.quote) return null;
+  const state = s.quoteState || 'pending';
+  const quoted = state !== 'rejected' && (all || api.store.getStatuses()).find(x => x.noteId === s.quote);
+  if (depth > 0) return { state, quoted_status_id: quoted ? api.store.idFor(quoted.noteId) : null };
+  return { state, quoted_status: quoted ? api.status(quoted, { all, depth: depth + 1 }) : null };
+}
+
+// Who may quote a post, in the client's words, and what that means for this
+// account. Our own posts: anyone, when the world can read it; nobody
+// otherwise. Another's: whatever policy the post carried — `unknown` when it
+// carried none, which is what a client hides the quote button on.
+export function quoteApproval(api, s) {
+  if (s.actor === api.urls?.actor) {
+    const open = !s.visibility || s.visibility === 'public' || s.visibility === 'unlisted';
+    return { automatic: open ? ['public'] : [], manual: [], current_user: open ? 'automatic' : 'denied' };
+  }
+  const p = s.quotePolicy;
+  if (!p) return { automatic: [], manual: [], current_user: 'unknown' };
+  const follows = () => api.store.getContacts().following.some(f => f.actor === s.actor && f.accepted);
+  const may = (list) => list.includes('public') || (list.includes('followers') && follows());
+  const current = may(p.automatic) ? 'automatic' : may(p.manual) ? 'manual' : 'denied';
+  return { automatic: p.automatic, manual: p.manual, current_user: current };
+}
+
+export function status(api, s, { all, depth = 0 } = {}) {
   const replies = (all || api.store.getStatuses()).filter(x => x.inReplyTo === s.noteId).length;
   return {
     id: api.store.idFor(s.noteId),
@@ -258,6 +304,8 @@ export function status(api, s, { all } = {}) {
       shortcode: e.shortcode, url: e.url, static_url: e.url, visible_in_picker: false,
     })),
     card: null, poll: s.poll ? api.pollJson(s) : null,
+    quote: quoteJson(api, s, { all, depth }),
+    quote_approval: quoteApproval(api, s),
     // What a filter matched, if any. Mastodon's clients read this and do the
     // hiding or warning; they do NOT match keywords themselves — Phanpy does
     // not — so filters that were stored and served but never applied were a
@@ -346,6 +394,7 @@ export function pushNotify(api, n) {
     mention: 'mentioned you', favourite: 'favourited your post',
     reblog: 'boosted your post', follow: 'followed you',
     'follow-request': 'asked to follow you', move: 'moved account',
+    reaction: `reacted ${n.emoji || ''} to your post`, quote: 'quoted your post',
   };
   const s = n.noteId && api.store.getStatuses().find(x => x.noteId === n.noteId);
   return api.push.notify(n, {
@@ -419,10 +468,18 @@ export function relationship(api, actorUrl) {
 // and a client that does not know the type shows "Unknown notification type"
 // — which is what every Mastodon client did with a follow request here. The
 // stored spelling is left alone so existing state keeps reading.
-export function notificationType(api, t) { return t === 'follow-request' ? 'follow_request' : t; }
+// Mastodon's spellings for what is stored here. A reaction is what Pleroma's
+// API calls an emoji reaction, and what clients render as one.
+export function notificationType(api, t) {
+  return t === 'follow-request' ? 'follow_request' : t === 'reaction' ? 'emoji_reaction' : t;
+}
 
 export function notification(api, n) {
   const out = { id: n.id, type: api.notificationType(n.type), created_at: n.at, account: api.account(n.actor) };
+  if (n.type === 'reaction') {
+    out.emoji = n.emoji;
+    if (n.url) out.emoji_url = n.url;
+  }
   if (n.noteId) {
     const s = api.store.getStatuses().find(x => x.noteId === n.noteId);
     if (s) out.status = api.status(s);

package/lib/client/masto/statuses.mjs

@@ -42,10 +42,28 @@ export async function handle(api, ctx) {
     const media = api.store.getMedia();
     const attachments = mediaIds.map(id => media[id] && { id, ...media[id] }).filter(Boolean);
 
+    // A quote: the post named is one this account holds, and its author has
+    // said it may be quoted. The author's answer decides what the reader sees;
+    // the reasons a quote cannot even be asked for are the client's to show.
+    let quote = null;
+    if (body.quoted_status_id) {
+      const quotedUrl = api.store.urlFor(String(body.quoted_status_id));
+      const quoted = quotedUrl && api.store.getStatuses().find(x => x.noteId === quotedUrl);
+      if (!quoted) return send(404, { error: 'Record not found' });
+      if (['bsky', 'acct'].includes(quoted.kind)) return send(422, { error: 'that post cannot be quoted from this account' });
+      if (visibility === 'private' || visibility === 'direct') return send(422, { error: 'a quote post is public or unlisted' });
+      const may = api.quoteApproval(quoted).current_user;
+      if (may === 'denied') return send(422, { error: 'the author of that post does not allow quotes' });
+      if (may === 'unknown') return send(422, { error: 'the author of that post has not said whether it may be quoted' });
+      if (body.scheduled_at) return send(422, { error: 'a quote cannot be scheduled' });
+      quote = { id: quoted.noteId, actor: quoted.actor };
+    }
+
     const asking = pollParams(body);
     if (asking) {
       // Mastodon's own rules, stated here rather than discovered inside the
       // publisher, so a client gets the reason back on the request it made.
+      if (quote) return send(422, { error: 'a poll cannot quote a post' });
       if (attachments.length) return send(422, { error: 'a poll cannot carry media' });
       if (body.scheduled_at) return send(422, { error: 'a poll cannot be scheduled' });
       if (asking.options.length < 2) return send(422, { error: 'a poll needs at least two options' });
@@ -99,7 +117,7 @@ export async function handle(api, ctx) {
     let note;
     try {
       note = await api.agent.publisher.publishNote(body.status,
-        { inReplyTo, attachments, visibility, spoilerText, sensitive });
+        { inReplyTo, attachments, visibility, spoilerText, sensitive, quote });
     } catch (e) {
       // A direct message nobody could be found for: the sender's mistake to
       // fix, said in the client, not a fault of the server.
@@ -110,6 +128,12 @@ export async function handle(api, ctx) {
     return send(200, api.status(s));
   }
 
+  // Who may quote a post is the same for every post here — anyone, when the
+  // world can read it — and is not set per post.
+  if (/^\/api\/v1\/statuses\/[a-f0-9]+\/interaction_policy$/.test(pathname) && req.method === 'PUT') {
+    return send(422, { error: 'the quote policy is the same for every post here: anyone may quote a public or unlisted post, nobody a followers-only or direct one' });
+  }
+
   // The composer reads the raw text back before an edit.
   const mSource = /^\/api\/v1\/statuses\/([a-f0-9]+)\/source$/.exec(pathname);
   if (mSource && req.method === 'GET') {

package/lib/client/masto/timelines.mjs

@@ -62,6 +62,49 @@ export async function handle(api, ctx) {
     const following = (api.agent.tagfeed?.config().tags || []).includes(name);
     return send(200, api.tagObject(name, following, req));
   }
+  // --- trending tags: counted off the notes already mirrored ---
+  //
+  // A single-actor instance has no firehose to measure, so "trending" here can
+  // only mean what the tag feed has actually brought in — which is the honest
+  // answer, and the one that makes a client's Explore surface show something
+  // instead of an empty list. `/api/v1/trends` is Mastodon's older name for the
+  // same thing.
+  if (pathname === '/api/v1/trends/tags' || pathname === '/api/v1/trends') {
+    const DAY = 86400000;
+    const today = Math.floor(Date.now() / DAY) * DAY;
+    // tag -> day -> { uses, accounts }. Accounts are counted distinctly, which
+    // is what the number means in Mastodon: one person posting nine times is
+    // nine uses by one account, and a client shows the second number.
+    const seen = new Map();
+    for (const st of api.store.getStatuses()) {
+      if (st.kind !== 'tag' || !st.tag) continue;
+      const at = Date.parse(st.published || '');
+      if (!Number.isFinite(at) || at < today - 6 * DAY) continue;
+      const day = Math.floor(at / DAY) * DAY;
+      if (!seen.has(st.tag)) seen.set(st.tag, new Map());
+      const days = seen.get(st.tag);
+      if (!days.has(day)) days.set(day, { uses: 0, accounts: new Set() });
+      const rec = days.get(day);
+      rec.uses++;
+      if (st.actor) rec.accounts.add(st.actor);
+    }
+    const followed = new Set(api.agent.tagfeed?.config().tags || []);
+    const ranked = [...seen.entries()].map(([name, days]) => {
+      // Seven entries, newest first, gaps filled with zeroes — a client draws
+      // the sparkline straight off this and a short array draws a short line.
+      const history = [];
+      for (let i = 0; i < 7; i++) {
+        const rec = days.get(today - i * DAY);
+        history.push({ day: String(Math.floor((today - i * DAY) / 1000)),
+          uses: String(rec ? rec.uses : 0), accounts: String(rec ? rec.accounts.size : 0) });
+      }
+      return { total: history.reduce((n, h) => n + Number(h.uses), 0),
+        tag: api.tagObject(name, followed.has(name), req, history) };
+    }).sort((a, b) => b.total - a.total);
+    const limit = Math.min(Math.max(Number(url.searchParams.get('limit')) || 10, 1), 40);
+    return send(200, ranked.slice(0, limit).map(x => x.tag));
+  }
+
   const mTagTl = pathname.match(/^\/api\/v1\/timelines\/tag\/([^/]+)$/);
   if (mTagTl && req.method === 'GET') {
     const name = decodeURIComponent(mTagTl[1]).replace(/^#/, '').toLowerCase();
@@ -208,7 +251,83 @@ export async function handle(api, ctx) {
     })));
   }
 
+  // The direct timeline: every direct post, newest first, paged like the rest.
+  if (pathname === '/api/v1/timelines/direct' && req.method === 'GET') {
+    const all = api.store.getStatuses();
+    const items = all.filter(s => s.direct || s.visibility === 'direct');
+    const { items: page, headers } = api.page(items, url);
+    return send(200, page.map(s => api.status(s, { all })), headers);
+  }
+
+  // One notification by id — what a push notification tap opens — and the
+  // two ways of being rid of them.
+  if (pathname === '/api/v1/notifications/clear' && req.method === 'POST') {
+    api.store.removeNotifications(() => true);
+    return send(200, {});
+  }
+  const mNotif = /^\/api\/v1\/notifications\/([A-Za-z0-9_-]+)(\/dismiss)?$/.exec(pathname);
+  if (mNotif) {
+    const n = api.store.getNotifications().find(x => x.id === mNotif[1]);
+    if (!n) return send(404, { error: 'Record not found' });
+    if (mNotif[2] && req.method === 'POST') { api.store.removeNotifications(x => x.id === n.id); return send(200, {}); }
+    if (!mNotif[2] && req.method === 'GET') return send(200, api.notification(n));
+  }
+
+  // Grouped notifications, the shape a client reads from API version 2 on.
+  // One group per notification: the client does its own gathering of
+  // favourites and boosts on a post, and every field it joins on — the
+  // account and status ids — is here.
+  const mGroup = /^\/api\/v2\/notifications\/([A-Za-z0-9_-]+)(\/accounts|\/dismiss)?$/.exec(pathname);
+  if (mGroup) {
+    const n = api.store.getNotifications().find(x => x.id === mGroup[1]);
+    if (!n) return send(404, { error: 'Record not found' });
+    if (mGroup[2] === '/dismiss' && req.method === 'POST') { api.store.removeNotifications(x => x.id === n.id); return send(200, {}); }
+    if (mGroup[2] === '/accounts' && req.method === 'GET') return send(200, [api.account(n.actor)]);
+    if (!mGroup[2] && req.method === 'GET') return send(200, groupedNotifications(api, [n]));
+  }
+  if (pathname === '/api/v2/notifications') {
+    const { page, headers } = notificationPage(api, ctx);
+    return send(200, groupedNotifications(api, page), headers);
+  }
+
   if (pathname === '/api/v1/notifications') {
+    const { page, headers } = notificationPage(api, ctx);
+    return send(200, page.map((n) => api.notification(n)), headers);
+  }
+
+  // Search: @user@host → webfinger resolve; URL → actor or note ingest;
+  // plain text → local mirror + actor-cache scan.
+  if (pathname === '/api/v2/search' || pathname === '/api/v1/search') {
+    return searchHandler(api, ctx);
+  }
+  return false;
+}
+
+function groupedNotifications(api, page) {
+  const accounts = new Map();
+  const statuses = new Map();
+  const groups = page.map((n) => {
+    const acct = api.account(n.actor);
+    accounts.set(acct.id, acct);
+    const s = n.noteId && api.store.getStatuses().find(x => x.noteId === n.noteId);
+    let statusId = null;
+    if (s) { const j = api.status(s); statuses.set(j.id, j); statusId = j.id; }
+    return {
+      group_key: n.id, notifications_count: 1, type: api.notificationType(n.type),
+      most_recent_notification_id: n.id, page_min_id: n.id, page_max_id: n.id,
+      latest_page_notification_at: n.at, sample_account_ids: [acct.id],
+      ...(statusId ? { status_id: statusId } : {}),
+      ...(n.type === 'reaction' ? { emoji: n.emoji, ...(n.url ? { emoji_url: n.url } : {}) } : {}),
+    };
+  });
+  return { accounts: [...accounts.values()], statuses: [...statuses.values()], notification_groups: groups };
+}
+
+// The slice of notifications a request asks for, and the Link header that
+// pages it. Shared by the flat list and the grouped one.
+function notificationPage(api, ctx) {
+  const { req, pathname, url } = ctx;
+  {
     const limit = Math.min(Number(url.searchParams.get('limit')) || 30, 60);
     const q = url.searchParams;
     // Newest first, which is what every id rule below assumes.
@@ -261,17 +380,20 @@ export async function handle(api, ctx) {
         for (const [k, v] of Object.entries(params)) u.searchParams.set(k, v);
         return u.href;
       };
-      return send(200, page.map((n) => api.notification(n)), {
+      return { page, headers: {
         link: `<${link({ max_id: page[page.length - 1].id })}>; rel="next", `
           + `<${link({ min_id: page[0].id })}>; rel="prev"`,
-      });
+      } };
     }
-    return send(200, []);
+    return { page: [], headers: undefined };
   }
+}
 
-  // Search: @user@host → webfinger resolve; URL → actor or note ingest;
-  // plain text → local mirror + actor-cache scan.
-  if (pathname === '/api/v2/search' || pathname === '/api/v1/search') {
+// Search: @user@host → webfinger resolve; URL → actor or note ingest;
+// plain text → local mirror + actor-cache scan.
+async function searchHandler(api, ctx) {
+  const { req, res, pathname, url, send } = ctx;   // eslint-disable-line no-unused-vars
+  {
     const q = String(url.searchParams.get('q') || '').trim();
     const type = url.searchParams.get('type');
     const out = { accounts: [], statuses: [], hashtags: [] };

package/lib/connections/tagfeed.mjs

@@ -12,13 +12,36 @@ import { isContentType, authorOf } from '../core/intake/index.mjs';
 // and a bound where there was none.
 const MAX_TIMELINE_BYTES = 2 * 1024 * 1024;
 
+// Two tags from each of six subjects, so a new account reads something on the
+// first morning without having followed anybody. Deliberately even: a busy
+// subject and a quiet one get the same number of places, and the sweep below
+// makes sure the busy ones cannot take the quiet ones' turns as well.
 const DEFAULTS = {
   instance: 'https://mastodon.social',
-  tags: ['solidproject', 'linkeddata', 'rdf'],
+  tags: [
+    'fediverse', 'activitypub',                  // the network this account is on
+    'opensource', 'foss',                        // how the software gets made
+    'solidproject', 'linkeddata',                // where the data lives
+    'privacy', 'digitalrights',                  // what is at stake
+    'indieweb', 'smallweb',                      // publishing for yourself
+    'commons', 'platformcooperativism',          // owning it together
+  ],
   intervalMin: 15,
 };
 const PER_TAG = 20;              // statuses requested per tag per sweep
-const MAX_NEW_PER_SWEEP = 12;    // dereference budget per sweep — stay light
+const MAX_NEW_PER_SWEEP = 8;     // dereference budget per sweep — stay light
+// …and no one tag may take more than this much of it. Without a per-tag share
+// the budget was spent in list order: the first two or three busy tags used it
+// all and everything below them never appeared once, however long you waited.
+const MAX_NEW_PER_TAG = 2;
+// Only this many tags are polled in any one sweep, taken in turn. A sweep holds
+// its writes until it finishes — so on the browser build, where the agent lives
+// in a service worker the browser is free to kill whenever it likes, a sweep
+// that runs long enough to be killed contributes NOTHING. Twelve tags was long
+// enough: a new account could open the app repeatedly and still see an empty
+// timeline. Four finishes. The list is still covered, three sweeps at a time,
+// and a sweep now costs the gateway less than the three-tag one it replaced.
+const TAGS_PER_SWEEP = 4;
 const MAX_TAG_ENTRIES = 200;     // oldest tag entries pruned beyond this
 // The instance here is a stranger's server we poll on our own schedule, and it
 // has no other way to tell us to stop.
@@ -31,6 +54,9 @@ export class TagFeed {
     Object.assign(this, { store, intake, log, fetcher });
     this.lastSweep = null;
     this.lastAdded = 0;
+    // Where this sweep starts in the tag list. It moves on by one each time, so
+    // when the budget does run out it is a different tag that goes without.
+    this.cursor = 0;
   }
 
   config() { return { ...DEFAULTS, ...this.store.read('tagfeed.json', {}) }; }
@@ -91,6 +117,11 @@ export class TagFeed {
     const known = new Set(this.store.getStatuses().map(s => s.noteId));
     let budget = MAX_NEW_PER_SWEEP;
     let added = 0;
+    // A different handful every time, taken in turn, so no tag is permanently
+    // first and none is permanently last.
+    const start = this.cursor % tags.length;
+    this.cursor = (start + TAGS_PER_SWEEP) % tags.length;
+    const order = [...tags, ...tags].slice(start, start + Math.min(TAGS_PER_SWEEP, tags.length));
     // The store's 300ms debounce cannot coalesce a sweep that awaits between
     // items — every note costs a fetch to somebody else's server, which outlives
     // the timer — so statuses.json and actors.json, the two largest documents,
@@ -99,7 +130,8 @@ export class TagFeed {
     // acctfeed has done it this way since 2026-08-03; this is the same fix.
     this.store.hold?.();
     try {
-    for (const tag of tags) {
+    for (const tag of order) {
+      let perTag = MAX_NEW_PER_TAG;
       let list;
       try {
         const { safeFetch, retryAfterMs, readCapped } = await import('../shared/safefetch.mjs');
@@ -129,7 +161,8 @@ export class TagFeed {
       for (const st of Array.isArray(list) ? list : []) {
         const noteId = st?.uri;
         if (!noteId || known.has(noteId) || this.store.isBlocked(noteId)) continue;
-        if (budget-- <= 0) break;
+        if (perTag <= 0 || budget <= 0) break;
+        perTag--; budget--;
         const note = await this.intake.fetchAP(noteId).catch(() => null);
         if (!note || note.id !== noteId || !isContentType(note.type)) continue;
         // The author is only known once the note is dereferenced, and this
@@ -159,6 +192,10 @@ export class TagFeed {
         known.add(noteId);
         added++;
       }
+      // Nothing left to take, so stop asking. Every remaining tag would be a
+      // request whose answer is thrown away — and in the browser build every
+      // one of those goes out through the gateway.
+      if (budget <= 0) break;
     }
     const all = this.store.getStatuses();
     const tagged = all.filter(s => s.kind === 'tag');
@@ -170,6 +207,6 @@ export class TagFeed {
       this.store.release?.();
     }
     this.lastAdded = added;
-    if (added) this.log(`tagfeed: +${added} from #${tags.join(' #')}`);
+    if (added) this.log(`tagfeed: +${added} from #${order.join(' #')}`);
   }
 }

package/lib/core/as2.mjs

@@ -19,7 +19,7 @@
 // common shape: one that skipped it would not be read as JSON-LD, and would
 // produce no graph, so nothing could be validated against it.
 //
-// CONTEXTS ARE NEVER FETCHED. The loader serves the fifteen the fediverse
+// CONTEXTS ARE NEVER FETCHED. The loader serves the ones the fediverse
 // actually uses and refuses every other URL. That refusal is the point: this
 // code runs on documents a stranger wrote, in the same path the SSRF guards
 // protect, and expanding one would otherwise mean dereferencing a URL of their
@@ -50,8 +50,14 @@ export class AS2Error extends Error {
  * the map throws rather than being fetched, so a document cannot make this
  * process reach out to an address its sender picked.
  */
+// Pleroma and Akkoma name their own copy of the litepub schema, one URL per
+// instance. Every copy is the same document, held here under the litepub
+// namespace, so a per-instance URL names that entry.
+const LITEPUB = 'http://litepub.social/ns';
+export const heldKey = (url) => (typeof url === 'string' && /\/schemas\/litepub-0\.1\.jsonld$/u.test(url) ? LITEPUB : url);
+
 export function contextLoader(url) {
-  const doc = CONTEXTS[url];
+  const doc = CONTEXTS[heldKey(url)];
   if (!doc) {
     return Promise.reject(new AS2Error(`context not held here: ${url}`, { context: url }));
   }
@@ -120,7 +126,7 @@ export async function parseAS2(raw) {
  */
 export function groundContext(input) {
   const ctx = input['@context'];
-  const held = (c) => typeof c === 'string' ? Object.hasOwn(CONTEXTS, c) : (c && typeof c === 'object');
+  const held = (c) => typeof c === 'string' ? Object.hasOwn(CONTEXTS, heldKey(c)) : (c && typeof c === 'object');
   let kept;
   if (ctx === undefined || ctx === null) kept = [];
   else if (Array.isArray(ctx)) kept = ctx.filter(held);
@@ -143,6 +149,31 @@ export function groundContext(input) {
  * `doc` and `graph` are null only when the bytes are not JSON at all, which is
  * what the plain read would have concluded too.
  */
+/**
+ * What a `null` in the document meant, carried onto the reading of it.
+ *
+ * ActivityPub §6.3.1: in an Update, a key set to `null` says REMOVE that
+ * property. JSON-LD has no way to carry that — expansion drops a null outright
+ * — so a partial update that takes something away arrives through the graph
+ * saying nothing at all, and is indistinguishable from an Update that never
+ * mentioned the property. The document plainly said it, so it is put back.
+ *
+ * Only nulls, only on the activity and its object, and only where the reading
+ * does not already have the key: nothing here overrides what the graph carried.
+ */
+function carryRemovals(input, view) {
+  if (!input || typeof input !== 'object' || !view || typeof view !== 'object') return view;
+  for (const [key, value] of Object.entries(input)) {
+    if (value === null) {
+      if (!(key in view)) view[key] = null;
+    } else if (key === 'object' && typeof value === 'object' && !Array.isArray(value)
+      && view.object && typeof view.object === 'object' && !Array.isArray(view.object)) {
+      carryRemovals(value, view.object);
+    }
+  }
+  return view;
+}
+
 export async function readLenient(raw) {
   // The document's own node is the one its `id` names. Handed to the view
   // as the root, so a document that points at itself — every actor does,
@@ -153,7 +184,7 @@ export async function readLenient(raw) {
   const root = typeof own === 'string' && /^https?:\/\//u.test(own) ? own : null;
   try {
     const { doc, graph } = await parseAS2(raw);
-    return { doc, graph, view: graphView(graph, { root }), degraded: null };
+    return { doc, graph, view: carryRemovals(input, graphView(graph, { root })), degraded: null };
   } catch (e) {
     if (!input || typeof input !== 'object') return { doc: null, graph: null, view: null, degraded: e.message };
     // Grounded, so a graph exists for every document that is JSON at all.
@@ -164,7 +195,7 @@ export async function readLenient(raw) {
     // what they read, so rewriting it here silently changed what they posted.
     try {
       const { graph } = await parseAS2(groundContext(input));
-      return { doc: input, graph, view: graphView(graph, { root }), degraded: e.message };
+      return { doc: input, graph, view: carryRemovals(input, graphView(graph, { root })), degraded: e.message };
     } catch (inner) {
       // Grounding names only held contexts, so reaching here means the document
       // is malformed JSON-LD rather than unfetchable. Hand back what a plain

package/lib/core/contexts/index.mjs

@@ -28,6 +28,18 @@ import ctx13 from './miscellany.json' with { type: 'json' };
 // Not from fedify: the W3C Web Annotation context, which a client such as
 // dokieli names on the annotations it posts to the outbox.
 import ctx14 from './anno.json' with { type: 'json' };
+// Not from fedify either. Pleroma and Akkoma name a copy of the litepub schema
+// served by each instance itself, at /schemas/litepub-0.1.jsonld; every copy
+// is the same document, and this is one of them. It is what declares
+// EmojiReact, and the older quote spellings quoteUrl and quoteUri. Held under
+// the litepub namespace, since no one URL names it; groundContext maps a
+// per-instance URL onto this entry.
+import ctx15 from './litepub-0.1.json' with { type: 'json' };
+// The quote terms as Mastodon declares them inline on a post: FEP-044f's
+// quote, quoteAuthorization, QuoteRequest and QuoteAuthorization, and
+// Misskey's _misskey_quote. No document at the FEP's URL serves a context;
+// the key is what lets the terms be named when reading.
+import ctx16 from './quotes.json' with { type: 'json' };
 
 /** URL → the context document itself. Nothing outside this map is ever resolved. */
 export const CONTEXTS = {
@@ -46,4 +58,6 @@ export const CONTEXTS = {
   'http://joinmastodon.org/ns': ctx12,
   'https://purl.archive.org/miscellany': ctx13,
   'http://www.w3.org/ns/anno.jsonld': ctx14,
+  'http://litepub.social/ns': ctx15,
+  'https://w3id.org/fep/044f': ctx16,
 };

package/lib/core/contexts/litepub-0.1.json

@@ -0,0 +1,60 @@
+{
+    "@context": [
+        "https://www.w3.org/ns/activitystreams",
+        "https://w3id.org/security/v1",
+        {
+            "Emoji": "toot:Emoji",
+            "Hashtag": "as:Hashtag",
+            "PropertyValue": "schema:PropertyValue",
+            "atomUri": "ostatus:atomUri",
+            "conversation": {
+                "@id": "ostatus:conversation",
+                "@type": "@id"
+            },
+            "discoverable": "toot:discoverable",
+            "manuallyApprovesFollowers": "as:manuallyApprovesFollowers",
+            "capabilities": "litepub:capabilities",
+            "ostatus": "http://ostatus.org#",
+            "schema": "http://schema.org#",
+            "toot": "http://joinmastodon.org/ns#",
+            "misskey": "https://misskey-hub.net/ns#",
+            "fedibird": "http://fedibird.com/ns#",
+            "sharkey": "https://joinsharkey.org/ns#",
+            "value": "schema:value",
+            "sensitive": "as:sensitive",
+            "litepub": "http://litepub.social/ns#",
+            "invisible": "litepub:invisible",
+            "directMessage": "litepub:directMessage",
+            "listMessage": {
+                "@id": "litepub:listMessage",
+                "@type": "@id"
+            },
+            "quoteUrl": "as:quoteUrl",
+            "quoteUri": "fedibird:quoteUri",
+            "oauthRegistrationEndpoint": {
+                "@id": "litepub:oauthRegistrationEndpoint",
+                "@type": "@id"
+            },
+            "EmojiReact": "litepub:EmojiReact",
+            "ChatMessage": "litepub:ChatMessage",
+            "alsoKnownAs": {
+                "@id": "as:alsoKnownAs",
+                "@type": "@id"
+            },
+            "vcard": "http://www.w3.org/2006/vcard/ns#",
+            "formerRepresentations": "litepub:formerRepresentations",
+            "contentMap": {
+                "@id": "as:content",
+                "@container": "@language"
+            },
+            "featured": {
+                "@id": "toot:featured",
+                "@type": "@id"
+            },
+            "backgroundUrl": {
+                "@id": "sharkey:backgroundUrl",
+                "@type": "@id"
+            }
+        }
+    ]
+}

package/lib/core/contexts/map.json

@@ -13,5 +13,7 @@
   "https://join-lemmy.org/context.json": "join-lemmy.json",
   "http://joinmastodon.org/ns": "joinmastodon.json",
   "https://purl.archive.org/miscellany": "miscellany.json",
-  "http://www.w3.org/ns/anno.jsonld": "anno.json"
+  "http://www.w3.org/ns/anno.jsonld": "anno.json",
+  "http://litepub.social/ns": "litepub-0.1.json",
+  "https://w3id.org/fep/044f": "quotes.json"
 }

package/lib/core/contexts/quotes.json

@@ -0,0 +1,18 @@
+{
+  "@context": {
+    "quote": {
+      "@id": "https://w3id.org/fep/044f#quote",
+      "@type": "@id"
+    },
+    "quoteAuthorization": {
+      "@id": "https://w3id.org/fep/044f#quoteAuthorization",
+      "@type": "@id"
+    },
+    "QuoteRequest": "https://w3id.org/fep/044f#QuoteRequest",
+    "QuoteAuthorization": "https://w3id.org/fep/044f#QuoteAuthorization",
+    "_misskey_quote": {
+      "@id": "https://misskey-hub.net/ns#_misskey_quote",
+      "@type": "@id"
+    }
+  }
+}