npm - fedipod - Versions diffs - 1.10.0 → 1.26.1 - Mend

fedipod 1.10.0 → 1.26.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7899) hide show

package/lib/core/profile-page.mjs ADDED Viewed

@@ -0,0 +1,104 @@
+// profile-page.mjs — the human page a browser opens for an actor: who the
+// account is, its fields, when it joined, what it pinned, and a remote-follow
+// control. The actor document is for servers; this is the address you hand
+// to a person. The agent writes it beside the actor (publisher
+// publishProfilePage) only when its content changed.
+const HTML_ESCAPES = { '&': '&amp;', '<': '&lt;', '>': '&gt;' };
+// `fields` are the profile's name/value rows, `joined` an ISO date, `pinned`
+// the pinned posts as { content (sanitized HTML), published, url }.
+export function profilePageHtml({ name, address, summary = null, icon = null, image = null,
+  fields = [], joined = null, pinned = [], kind = 'person' }) {
+  const esc = (s) => String(s ?? '').replace(/[&<>"]/g, c => ({ ...HTML_ESCAPES, '"': '&quot;' }[c]));
+  const what = kind === 'group' ? 'a group' : 'an account';
+  const month = (iso) => {
+    const d = new Date(iso);
+    return Number.isNaN(d.getTime()) ? null
+      : d.toLocaleDateString('en', { month: 'long', year: 'numeric', timeZone: 'UTC' });
+  };
+  const day = (iso) => {
+    const d = new Date(iso);
+    return Number.isNaN(d.getTime()) ? '' : d.toISOString().slice(0, 10);
+  };
+  const fieldRows = fields.filter(f => f?.name && f?.value !== undefined && f?.value !== null && String(f.value) !== '');
+  const joinedText = joined ? month(joined) : null;
+  const pins = pinned.filter(x => x && typeof x.content === 'string');
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${esc(name)} (${esc(address)})</title>
+<style>
+:root { color-scheme: light dark; }
+body { font: 112.5%/1.5 system-ui, sans-serif; max-width: 34rem; margin: 3rem auto; padding: 0 1rem; }
+img.header { width: 100%; max-height: 12rem; object-fit: cover; border-radius: 1rem; }
+img.avatar { width: 6rem; height: 6rem; border-radius: 1rem; object-fit: cover; margin-top: 1rem; }
+h1 { margin: .5rem 0 0; }
+.address { font-size: 1.1rem; user-select: all; }
+dl.fields { display: grid; grid-template-columns: max-content 1fr; gap: .4rem 1rem; margin: 1.5rem 0; }
+dl.fields dt { font-weight: 600; }
+dl.fields dd { margin: 0; overflow-wrap: anywhere; }
+.joined { margin: 1rem 0; }
+section.pinned h2 { font-size: 1.1rem; margin: 2rem 0 .5rem; }
+article.pin { border: 1px solid #8884; border-radius: 1rem; padding: 1rem 1.2rem; margin: 1rem 0; }
+article.pin p:last-child { margin-bottom: 0; }
+article.pin .when { font-size: 1rem; }
+form { margin-top: 2rem; }
+label { display: block; margin-bottom: .3rem; }
+input { font: inherit; padding: .5rem; width: 14rem; max-width: 100%; }
+button { font: inherit; padding: .5rem 1rem; }
+.hint { color: #666; font-size: 1rem; }
+.err { color: #b00020; }
+.err:empty { display: none; }
+@media (prefers-color-scheme: dark) {
+  .hint { color: #aaa; }
+  .err { color: #ff8a80; }
+}
+</style>
+</head>
+<body>
+<main>
+${image ? `<img class="header" src="${esc(image)}" alt="">` : ''}
+${icon ? `<img class="avatar" src="${esc(icon)}" alt="">` : ''}
+<h1>${esc(name)}</h1>
+<p class="address">${esc(address)}</p>
+${summary ? `<div>${summary}</div>` : ''}
+${fieldRows.length ? `<dl class="fields">
+${fieldRows.map(f => `<dt>${esc(f.name)}</dt><dd>${esc(f.value)}</dd>`).join('\n')}
+</dl>` : ''}
+${joinedText ? `<p class="joined">Joined ${esc(joinedText)}</p>` : ''}
+${pins.length ? `<section class="pinned">
+<h2>Pinned</h2>
+${pins.map(x => `<article class="pin">
+${x.content}
+<p class="when">${x.url ? `<a href="${esc(x.url)}">${esc(day(x.published))}</a>` : esc(day(x.published))}</p>
+</article>`).join('\n')}
+</section>` : ''}
+<p>This is ${what} on the Fediverse. To follow it, paste the address above
+into the search box of Mastodon or any Fediverse app — or use the form.</p>
+<form id="follow">
+  <label for="server">your server</label>
+  <input id="server" type="text" placeholder="mastodon.social" autocomplete="off"
+    required aria-describedby="follow-err">
+  <button type="submit">Follow</button>
+  <p class="err" id="follow-err" role="alert"></p>
+</form>
+<p class="hint">The form sends you to your own server's follow screen.</p>
+</main>
+<script>
+document.getElementById('follow').addEventListener('submit', (ev) => {
+  ev.preventDefault();
+  const s = document.getElementById('server').value.trim().replace(/^https?:\\/\\//, '').replace(/\\/.*$/, '');
+  const err = document.getElementById('follow-err');
+  const addr = document.querySelector('.address').textContent.trim();
+  if (!s) { err.textContent = 'Enter your server, e.g. mastodon.social'; return; }
+  err.textContent = '';
+  location.href = 'https://' + s + '/authorize_interaction?uri=' + encodeURIComponent(addr);
+});
+</script>
+</body>
+</html>
+`;
+}

package/lib/core/publisher/index.mjs CHANGED Viewed

@@ -91,7 +91,11 @@ export class Publisher {
   // Every actor document this identity publishes, from one place: the
   // profile publish and a Move both write it, and a Move that rebuilt it
   // by hand dropped the gateway inbox, the outbox door and the collections.
-  actorDocFor({ priv = false, moderators = null, inbox = null, movedTo = this.config.movedTo || null } = {}) {
+  // `clientOrigin` is overridden only by the agent serving a client its own
+  // local actor: standalone, the published document cannot name a loopback
+  // address, but a client already talking to that address can be told it.
+  actorDocFor({ priv = false, moderators = null, inbox = null, movedTo = this.config.movedTo || null,
+    clientOrigin = this.clientOrigin } = {}) {
     const { urls } = this;
     return wire.actorDoc({
       urls, handle: wire.publicHandle(this.config), name: this.config.name, publicKeyPem: this.publicKeyPem,
@@ -110,14 +114,60 @@ export class Publisher {
       // The agent's own outbox endpoint, where it is reachable: a client
       // following the actor must arrive somewhere that will take a write.
       // Otherwise the Gateway's outbox door, when one is attached.
-      outbox: this.clientOrigin ? `${this.clientOrigin}ap/outbox` : this.gatewayOutbox(),
+      outbox: clientOrigin ? `${clientOrigin}ap/outbox` : this.gatewayOutbox(),
       // How a client-to-server client finds the way in with nothing configured
       // by hand. Advertised only where the surface is publicly reachable.
-      oauthAuthorize: this.clientOrigin ? `${this.clientOrigin}oauth/authorize` : null,
-      oauthToken: this.clientOrigin ? `${this.clientOrigin}oauth/token` : null,
+      oauthAuthorize: clientOrigin ? `${clientOrigin}oauth/authorize` : null,
+      oauthToken: clientOrigin ? `${clientOrigin}oauth/token` : null,
     });
   }
+  // The human half: a page a browser can open and follow from. The actor
+  // document is for servers; this is the address you hand to a person. It
+  // shows who the account is, its fields, when it joined and what it pinned;
+  // the counts and the posts live in the collections. Written only when its
+  // content changed.
+  async publishProfilePage({ force = false } = {}) {
+    const { urls } = this;
+    const host = new URL(urls.base).host;
+    // When the account was made. Accounts from before this was recorded take
+    // the date of their oldest post, or today.
+    if (!this.config.createdAt) {
+      const oldest = this.store.getStatuses().filter(s => s.kind === 'post' && s.published)
+        .map(s => s.published).sort()[0];
+      this.config.createdAt = oldest || new Date().toISOString();
+      this.store.setConfig?.({ ...this.store.getConfig?.(), createdAt: this.config.createdAt });
+    }
+    const pinned = this.store.getStatuses()
+      .filter(s => s.kind === 'post' && s.pinned && s.visibility !== 'private' && s.visibility !== 'direct')
+      .sort((a, b) => String(b.published).localeCompare(String(a.published)))
+      .slice(0, 5)
+      .map(s => ({ content: s.content, published: s.published, url: s.noteId }));
+    // The address as the world knows it: at the Gateway for a fronted
+    // identity, on the pod's host otherwise, the actor id where no host can
+    // answer for a handle.
+    const frontActor = this.config.gateway?.frontActor;
+    const address = frontActor ? `@${wire.publicHandle(this.config)}@${new URL(frontActor).host}`
+      : (wire.webfingerHost(urls.base) ? `@${this.config.handle}@${host}` : urls.actor);
+    const html = wire.profilePageHtml({
+      name: this.config.name || this.config.handle,
+      address,
+      summary: this.config.summary ? wire.contentHtml(this.config.summary) : null,
+      icon: this.config.icon || null,
+      image: this.config.image || null,
+      fields: this.config.fields || [],
+      joined: this.config.createdAt,
+      pinned,
+      kind: this.config.kind,
+    });
+    const digest = crypto.createHash('sha256').update(html).digest('hex').slice(0, 32);
+    const seen = this.store.read('published.json', {});
+    if (!force && seen.pageDigest === digest) return false;
+    await podActor.writeProfilePage(this.remote, urls, html);
+    this.store.write('published.json', { ...this.store.read('published.json', {}), pageDigest: digest });
+    return true;
+  }
   async publishProfile({ force = false } = {}) {
     const { urls } = this;
     const host = new URL(urls.base).host;
@@ -131,27 +181,37 @@ export class Publisher {
     // actor's inbox; deliveries reach the pod inbox through it. Absent → today.
     const gw = this.config.gateway;
     const gwActive = gw && gw.url && gw.mode && gw.mode !== 'off';
-    const actorDoc = this.actorDocFor({ priv, moderators, inbox: gwActive ? gw.url : null });
+    // A forum's category advertises the forum's one inbox (config.inboxUrl):
+    // deliveries to any category land there, and the forum routes them.
+    const actorDoc = this.actorDocFor({ priv, moderators, inbox: gwActive ? gw.url : (this.config.inboxUrl || null) });
     const surface = crypto.createHash('sha256').update(JSON.stringify({
       actor: actorDoc, handle: this.config.handle, host,
       quiesced: !!this.config.quiescedAt, version: AGENT_VERSION,
       moderators: this.config.moderators || [],
     })).digest('hex').slice(0, 32);
+    // The human page has its own gate: it changes with pins and the joined
+    // date as well as with the profile, and costs one write when it does.
+    await this.publishProfilePage({ force });
     if (!force && this.store.read('published.json', {}).surfaceDigest === surface) {
       this.log('profile unchanged — nothing republished');
       return { unreachable: [], updated: 0, skipped: true };
     }
-    await discovery.writeWebfinger(this.remote, urls,
-      wire.jrd({ handle: this.config.handle, host, actor: urls.actor, page: urls.profileHtml }));
-    await discovery.writeHostMeta(this.remote, urls, wire.hostMeta(urls.base));
+    // Discovery is the pod's, and a pod has one WebFinger document: a forum's
+    // category (config.forum names the forum) is not the pod's identity, so it
+    // writes none — the forum's own actor, or a Gateway, answers for it.
+    if (!this.config.forum) {
+      await discovery.writeWebfinger(this.remote, urls,
+        wire.jrd({ handle: this.config.handle, host, actor: urls.actor, page: urls.profileHtml }));
+      await discovery.writeHostMeta(this.remote, urls, wire.hostMeta(urls.base));
-    const nodeinfoDocUrl = urls.home + 'ap/nodeinfo-2.0';
-    const localPosts = this.store.getStatuses().filter(s => s.kind === 'post').length;
-    await discovery.writeNodeinfo(this.remote, urls, {
-      pointer: wire.nodeinfoPointer(nodeinfoDocUrl),
-      doc: wire.nodeinfoDoc({ version: AGENT_VERSION, localPosts }),
-    });
+      const nodeinfoDocUrl = urls.home + 'ap/nodeinfo-2.0';
+      const localPosts = this.store.getStatuses().filter(s => s.kind === 'post').length;
+      await discovery.writeNodeinfo(this.remote, urls, {
+        pointer: wire.nodeinfoPointer(nodeinfoDocUrl),
+        doc: wire.nodeinfoDoc({ version: AGENT_VERSION, localPosts }),
+      });
+    }
     const actor = actorDoc;                 // built above, for the digest
     await podActor.write(this.remote, urls, actor);
@@ -166,20 +226,10 @@ export class Publisher {
     // what concerns this identity. Written only while a gateway is advertised.
     if (gwActive) await this.publishGatewayPolicy();
-    // The human half: a page a browser can open and follow from. The actor
-    // document is for servers; this is the address you hand to a person.
-    await podActor.writeProfilePage(this.remote, urls, wire.profilePageHtml({
-      name: this.config.name || this.config.handle,
-      address: wire.webfingerHost(urls.base) ? `@${this.config.handle}@${host}` : urls.actor,
-      summary: this.config.summary ? wire.contentHtml(this.config.summary) : null,
-      icon: this.config.icon || null,
-      kind: this.config.kind,
-    }));
     // WebID → actor: the profile card lists the actor as a foaf:account.
     // Best-effort — a profile that cannot be read or edited does not stop the
     // publish, it is logged and the rest of the surface still goes up.
-    try {
+    if (this.config.forum) { /* a category is not the pod owner's account */ } else try {
       const wrote = await podActor.linkInWebIdProfile(this.remote, {
         actorUrl: urls.actor,
         accountName: `@${this.config.handle}@${host}`,
@@ -265,8 +315,8 @@ export class Publisher {
   async verifyPublicSurface() {
     const { urls } = this;
     const targets = [
-      ['webfinger', urls.webfinger],
-      ['host-meta', urls.base + '.well-known/host-meta'],
+      // Discovery documents are the pod's, not a forum category's (see publishProfile).
+      ...(this.config.forum ? [] : [['webfinger', urls.webfinger], ['host-meta', urls.base + '.well-known/host-meta']]),
       ['actor', urls.actor],
       ['notes', urls.notes],
       ['followers', urls.followers],
@@ -429,6 +479,9 @@ export class Publisher {
   privateReady(...a) { return notes.privateReady(this, ...a); }
   _mentionsFor(...a) { return notes.mentionsFor(this, ...a); }
   publishNote(...a) { return notes.publishNote(this, ...a); }
+  authorizeQuote(...a) { return notes.authorizeQuote(this, ...a); }
+  withdrawQuote(...a) { return notes.withdrawQuote(this, ...a); }
+  grantQuote(...a) { return notes.grantQuote(this, ...a); }
   publishObject(...a) { return notes.publishObject(this, ...a); }
   updateNote(...a) { return notes.updateNote(this, ...a); }

package/lib/core/publisher/notes.mjs CHANGED Viewed

@@ -4,6 +4,7 @@
 import crypto from 'node:crypto';
 import * as wire from '../wire.mjs';
+import * as wireQuotes from '../wire-quotes.mjs';
 import * as containers from '../../pod/containers.mjs';
 import * as podNotes from '../../pod/notes.mjs';
@@ -159,7 +160,10 @@ export function rowContent(obj) {
   return `<p><a href="${esc(obj?.id || '')}">${esc(obj?.type || 'object')}</a></p>`;
 }
-export async function publishNote(publisher, content, { inReplyTo, attachments, visibility = 'public', spoilerText = null, sensitive = false, slug: wanted = null, also = [], deliverTo = [] } = {}) {
+// `quote`: the post this one quotes, `{ id, actor }` — the quoted author is
+// asked to allow it (FEP-044f). A quote of one of this actor's own posts is
+// allowed on the spot.
+export async function publishNote(publisher, content, { inReplyTo, attachments, visibility = 'public', spoilerText = null, sensitive = false, slug: wanted = null, also = [], deliverTo = [], quote = null } = {}) {
   const { urls } = publisher;
   const priv = visibility === 'private' || visibility === 'direct';
   if (priv) {
@@ -171,10 +175,16 @@ export async function publishNote(publisher, content, { inReplyTo, attachments,
   const mentions = await publisher._mentionsFor(content, inReplyTo);
   if (visibility === 'direct') assertDirectAddressed(content, mentions);
   const reply = await replyTarget(publisher, inReplyTo, mentions, visibility);
+  const selfQuote = quote?.id && quote.actor === urls.actor;
+  const quoted = quote?.id ? {
+    id: quote.id,
+    // Our own post: the authorization is minted here, before the note goes out.
+    authorization: selfQuote ? await grantQuote(publisher, quote.id, (priv ? urls.privateNotes : urls.notes) + slug) : null,
+  } : null;
   const note = wire.noteDoc({ urls, slug, content, published, inReplyTo, attachments, mentions,
     visibility, summary: spoilerText, sensitive, container: priv ? urls.privateNotes : urls.notes,
-    also: [...also, ...(reply ? [reply.actor] : [])] });
-  const addressedInboxes = await inboxesFor(publisher, [...also, ...deliverTo]);
+    also: [...also, ...(reply ? [reply.actor] : []), ...(quote?.actor && !selfQuote ? [quote.actor] : [])], quote: quoted });
+  const addressedInboxes = await inboxesFor(publisher, [...also, ...deliverTo, ...(quote?.actor && !selfQuote ? [quote.actor] : [])]);
   await podNotes.write(publisher.remote, note.id, note);
   // Empty, but present: a dangling `replies` that 404s is worse than none.
@@ -183,6 +193,9 @@ export async function publishNote(publisher, content, { inReplyTo, attachments,
   // The outbox is the PUBLIC index; a private or direct post is not in it.
   if (!priv) await publisher.recordOutbox(note.id);
+  const request = quote?.id && !selfQuote
+    ? wireQuotes.quoteRequestActivity({ urls, note, quoted: quote.id, quotedActor: quote.actor, serial: Date.now() })
+    : null;
   publisher.store.addStatus({
     noteId: note.id, actor: urls.actor, content: note.content, published, inReplyTo,
     kind: 'post', slug, text: content, visibility,
@@ -190,6 +203,12 @@ export async function publishNote(publisher, content, { inReplyTo, attachments,
     ...(note.sensitive ? { sensitive: true } : {}),
     ...(attachments?.length ? { attachments } : {}),
     ...rowTags(note),
+    ...(quote?.id ? {
+      quote: quote.id,
+      quoteState: selfQuote ? 'accepted' : 'pending',
+      ...(quoted.authorization ? { quoteAuthorization: quoted.authorization } : {}),
+      ...(request ? { quoteRequest: { id: request.id, actor: quote.actor } } : {}),
+    } : {}),
   });
   // The row is what the author's own timeline reads. Land it before answering
   // — the same PUT the debounce would send in 300 ms — so a worker killed or a
@@ -212,6 +231,13 @@ export async function publishNote(publisher, content, { inReplyTo, attachments,
   ].filter(Boolean))];
   await publisher.deliverer.deliverToAll(inboxes, create);
   publisher.log(`note published: ${note.id} → ${inboxes.length} inbox(es)`);
+  // The quoted author is asked after the note is out: their Accept names the
+  // note, so it has to exist where they will look for it.
+  if (request) {
+    const [inbox] = await inboxesFor(publisher, [quote.actor]);
+    if (inbox) await publisher.deliverer.deliver(inbox, request);
+    else publisher.log(`quote of ${quote.id}: no inbox found for ${quote.actor} — the quote stays pending`);
+  }
   // Bluesky mirror: PUBLIC posts only — unlisted, followers-only and direct
   // are never carried off the fediverse. A mirror failure never fails the
@@ -328,6 +354,7 @@ export async function updateNote(publisher, s, { content, spoilerText = null, se
     attachments: atts, mentions, visibility: s.visibility || 'public',
     summary: spoilerText, sensitive: sensitive ?? !!s.sensitive, updated, container,
     also: reply ? [reply.actor] : [],
+    quote: rowQuote(s),
   });
   await podNotes.write(publisher.remote, note.id, note);
   await podNotes.writeCreate(publisher.remote, wire.createActivityId(note.id), wire.createActivity(note, urls));
@@ -350,3 +377,77 @@ export async function updateNote(publisher, s, { content, spoilerText = null, se
   publisher.log(`note edited: ${note.id} → ${inboxes.length} inbox(es)`);
   return patched;
 }
+// What a note's document says about its quote, read off the timeline row: the
+// quoted post and, once granted, the authorization. A quote the author
+// refused is no longer said.
+export function rowQuote(s) {
+  if (!s?.quote || s.quoteState === 'rejected') return null;
+  return { id: s.quote, ...(s.quoteAuthorization ? { authorization: s.quoteAuthorization } : {}) };
+}
+// The note's document again, unchanged in what it says, changed in what it
+// says about its quote. Not an edit — no `updated` stamp — so nobody shows it
+// as edited; the Update goes where the Create went, plus to the quoted author.
+async function restateNote(publisher, s, { quote }) {
+  const { urls } = publisher;
+  const content = s.text ?? '';
+  const mentions = await publisher._mentionsFor(content, s.inReplyTo);
+  const container = String(s.noteId).startsWith(urls.privateNotes) ? urls.privateNotes : urls.notes;
+  const slug = s.slug || String(s.noteId).slice(container.length);
+  const reply = await replyTarget(publisher, s.inReplyTo, mentions, s.visibility || 'public');
+  const note = wire.noteDoc({
+    urls, slug, content, published: s.published, inReplyTo: s.inReplyTo,
+    attachments: s.attachments || [], mentions, visibility: s.visibility || 'public',
+    summary: s.spoiler || null, sensitive: !!s.sensitive, updated: s.editedAt || null, container,
+    also: [...(reply ? [reply.actor] : []), ...(s.quoteRequest?.actor ? [s.quoteRequest.actor] : [])],
+    quote,
+  });
+  await podNotes.write(publisher.remote, note.id, note);
+  await podNotes.writeCreate(publisher.remote, wire.createActivityId(note.id), wire.createActivity(note, urls));
+  const update = wire.updateActivity(note, urls, { serial: Date.now() });
+  const contacts = publisher.store.getContacts();
+  const inboxes = [...new Set([
+    ...(s.visibility === 'direct' ? [] : contacts.followers.map(f => f.sharedInbox || f.inbox)),
+    ...mentions.map(m => m.inbox),
+    reply?.inbox,
+    ...(await inboxesFor(publisher, s.quoteRequest?.actor ? [s.quoteRequest.actor] : [])),
+  ].filter(Boolean))];
+  await publisher.deliverer.deliverToAll(inboxes, update);
+  return inboxes.length;
+}
+// The quoted author said yes: their authorization goes onto the note, and
+// everyone who has the note is told.
+export async function authorizeQuote(publisher, s, authorizationId) {
+  const patched = publisher.store.updateStatus(s.noteId, { quoteState: 'accepted', quoteAuthorization: authorizationId });
+  const n = await restateNote(publisher, patched || s, { quote: { id: s.quote, authorization: authorizationId } });
+  publisher.log(`quote allowed by ${s.quoteRequest?.actor || 'the author'}: ${s.noteId} → ${n} inbox(es)`);
+  return patched;
+}
+// The quoted author said no: the note stops naming their post.
+export async function withdrawQuote(publisher, s) {
+  const patched = publisher.store.updateStatus(s.noteId, { quoteState: 'rejected', quoteAuthorization: undefined });
+  const n = await restateNote(publisher, patched || s, { quote: null });
+  publisher.log(`quote refused by ${s.quoteRequest?.actor || 'the author'}: ${s.noteId} → ${n} inbox(es)`);
+  return patched;
+}
+// Somebody may quote one of this actor's posts: the authorization is written
+// beside the post — public-Read, like the post — and remembered on its row,
+// so a receiver that checks the quote finds it and a re-asked question gets
+// the same answer. Returns the authorization's id.
+const MAX_QUOTED_BY = 200;
+export async function grantQuote(publisher, noteId, instrumentId) {
+  const { urls } = publisher;
+  const id = wireQuotes.quoteAuthorizationId(noteId, instrumentId);
+  await podNotes.write(publisher.remote, id, wireQuotes.quoteAuthorizationDoc({ urls, id, instrument: instrumentId, target: noteId }));
+  const s = publisher.store.getStatuses().find(x => x.noteId === noteId);
+  if (s) {
+    const quotedBy = (s.quotedBy || []).filter(q => q.note !== instrumentId);
+    quotedBy.unshift({ note: instrumentId, authorization: id });
+    publisher.store.updateStatus(noteId, { quotedBy: quotedBy.slice(0, MAX_QUOTED_BY) });
+  }
+  return id;
+}

package/lib/core/shapes/activitystreams.ttl CHANGED Viewed

@@ -127,3 +127,31 @@
     sh:minCount 1 ;
     sh:maxCount 1 ;
   ] .
+<#Update>
+  a sh:NodeShape ;
+  sh:targetClass as:Update ;
+  sh:name "Update" ;
+  sh:description "A change to the object it names, carrying the parts that are now different." ;
+  sh:property [
+    sh:path as:actor ;
+    sh:name "actor" ;
+    sh:description "The one that performed the activity." ;
+    sh:nodeKind sh:BlankNodeOrIRI ;
+    sh:minCount 1 ;
+    sh:maxCount 1 ;
+  ] ;
+  sh:property [
+    sh:path as:object ;
+    sh:name "object" ;
+    sh:description "The thing the activity is about." ;
+    sh:minCount 1 ;
+    sh:maxCount 1 ;
+  ] ;
+  sh:property [
+    sh:path ( as:object as:closed ) ;
+    sh:name "closed" ;
+    sh:description "The time the object stopped taking anything more." ;
+    sh:datatype xsd:dateTime ;
+    sh:maxCount 1 ;
+  ] .

package/lib/core/shapes/index.mjs CHANGED Viewed

@@ -59,6 +59,26 @@ function asTerm(q) {
   return rdf.quad(term(q.subject), term(q.predicate), term(q.object));
 }
+/**
+ * What to call the property that did not fit.
+ *
+ * A single-predicate path names itself: the IRI, shortened. A sequence path is
+ * a list, and its head is a blank node that names nothing — so the failing
+ * property shape is asked for its own `sh:name` instead.
+ */
+const SH_NAME = 'http://www.w3.org/ns/shacl#name';
+function pathName(r) {
+  const direct = r.path?.value ?? null;
+  if (direct && /[#/]/u.test(direct)) return direct;
+  const shape = r.sourceShape;
+  if (shape) {
+    for (const q of shacl().$shapes?.dataset ?? []) {
+      if (q.subject.equals(shape) && q.predicate.value === SH_NAME) return q.object.value;
+    }
+  }
+  return direct;
+}
 /**
  * Check a document's graph against the shapes.
  *
@@ -91,7 +111,12 @@ export async function checkShapes(quads) {
     conforms: false,
     results: report.results.slice(0, 10).map((r) => ({
       focus: r.focusNode?.value ?? null,
-      path: r.path?.value ?? null,
+      // A SEQUENCE path — `( as:object as:closed )` — is an RDF list, so its
+      // node is blank and `.value` is a generated label like "n3-13". Reported
+      // as that, the record named nothing a reader could act on. The shape's
+      // own `sh:name` is what it is called, so that is used when the path
+      // cannot name itself.
+      path: pathName(r),
       message: r.message?.[0]?.value ?? String(r.sourceConstraintComponent?.value ?? 'does not fit the shape'),
       shape: r.sourceShape?.value ?? null,
     })),

package/lib/core/social.mjs CHANGED Viewed

@@ -523,6 +523,9 @@ export async function pinStatus(agent, s, pinned) {
   if (s.actor !== agent.publisher.urls.actor) throw new Error('not your status');
   const updated = agent.store.updateStatus(s.noteId, { pinned: !!pinned });
   await agent.publisher.publishFeatured().catch(e => agent.log?.(`featured: ${e.message}`));
+  if (agent.publisher.publishProfilePage) {
+    await agent.publisher.publishProfilePage().catch(e => agent.log?.(`profile page: ${e.message}`));
+  }
   agent.publisher.publishProfile?.().catch(() => {});
   return updated || s;
 }

package/lib/core/wire-quotes.mjs ADDED Viewed

@@ -0,0 +1,71 @@
+// wire-quotes.mjs — the documents and activities a quote is made of on the
+// wire (FEP-044f): the request to the quoted author, the authorization they
+// publish, and the Accept or Reject that answers. The quote terms a note
+// itself carries live in wire.mjs with the note.
+import crypto from 'node:crypto';
+import { AS_CTX, QUOTE_CTX, POLICY_CTX } from './wire.mjs';
+// The activity and object types, and the two terms an authorization names
+// its parties by — GoToSocial's, declared as Mastodon declares them.
+export const QUOTE_TYPES_CTX = {
+  QuoteRequest: 'https://w3id.org/fep/044f#QuoteRequest',
+  QuoteAuthorization: 'https://w3id.org/fep/044f#QuoteAuthorization',
+  gts: 'https://gotosocial.org/ns#',
+  interactingObject: { '@id': 'gts:interactingObject', '@type': '@id' },
+  interactionTarget: { '@id': 'gts:interactionTarget', '@type': '@id' },
+};
+// FEP-044f: asking the quoted post's author to allow the quote. The whole
+// quoting note rides along as the instrument, so their server can see what
+// is being asked without fetching it; `object` is their post.
+export function quoteRequestActivity({ urls, note, quoted, quotedActor, serial }) {
+  const { '@context': ctx, ...instrument } = note;   // eslint-disable-line no-unused-vars
+  return {
+    '@context': [AS_CTX, { ...QUOTE_CTX, ...POLICY_CTX, QuoteRequest: QUOTE_TYPES_CTX.QuoteRequest }],
+    id: urls.actor + '#quote-request-' + serial,
+    type: 'QuoteRequest',
+    actor: urls.actor,
+    to: [quotedActor],
+    object: quoted,
+    instrument,
+  };
+}
+// The authorization a quoted author publishes (FEP-044f): a document of its
+// own, at the quoted post's origin, naming the quoting post and the quoted
+// one. A receiver checks the quote by fetching this and comparing both.
+export function quoteAuthorizationId(noteId, instrumentId) {
+  return noteId + '-quote-' + crypto.createHash('sha256').update(String(instrumentId)).digest('hex').slice(0, 16);
+}
+export function quoteAuthorizationDoc({ urls, id, instrument, target }) {
+  return {
+    '@context': [AS_CTX, QUOTE_TYPES_CTX],
+    id,
+    type: 'QuoteAuthorization',
+    attributedTo: urls.actor,
+    interactingObject: instrument,
+    interactionTarget: target,
+  };
+}
+// The answer to a QuoteRequest: Accept, carrying the authorization as its
+// result, or Reject. The request is echoed by its id, type, actor, object
+// and the instrument's id — enough for the asker to match it, and nothing a
+// stranger wrote is repeated whole.
+export function quoteAnswerActivity({ urls, type, request, result = null, to, serial }) {
+  const idOf = (v) => (typeof v === 'string' ? v : v?.id);
+  return {
+    '@context': [AS_CTX, { QuoteRequest: QUOTE_TYPES_CTX.QuoteRequest }],
+    id: urls.actor + '#' + type.toLowerCase() + '-' + serial,
+    type,
+    actor: urls.actor,
+    to: [to],
+    object: {
+      id: idOf(request), type: 'QuoteRequest', actor: idOf(request?.actor),
+      object: idOf(request?.object), instrument: idOf(request?.instrument),
+    },
+    ...(result ? { result } : {}),
+  };
+}