fedipod-server 0.21.0 → 0.28.0

package/lib/core/profile-page.mjs

@@ -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/collections.mjs

@@ -15,7 +15,7 @@ import * as podPrivate from '../../pod/private.mjs';
 // still gets everything, so a missed call site degrades to the old cost rather
 // than silently publishing nothing.
 export const ALL_COLLECTIONS = { followers: true, following: true, outbox: true, acls: true,
-  pending: true, blocked: true };
+  pending: true, blocked: true, featured: true };
 
 // Publish the collections a change actually TOUCHED.
 //
@@ -152,6 +152,11 @@ export async function publishCollections(publisher, which = ALL_COLLECTIONS) {
   }
   if (which.pending) await publisher.publishPending();
   if (which.blocked) await publisher.publishBlocked();
+  // The pinned posts, written even when there are none. The actor names this
+  // collection, and a server showing the profile reads it whether or not
+  // anything was ever pinned; with no document there the pod refused every
+  // reader, a refusal nothing caches, and every server asked again.
+  if (which.featured) await publisher.publishFeatured();
   if (which.outbox) {
     const outbox = publisher.store.read('outbox.json', []);
     // Reconcile reads every published page, which is the expensive part of a

package/lib/core/publisher/index.mjs

@@ -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,
@@ -102,6 +106,9 @@ export class Publisher {
       image: this.config.image || null, fields: this.config.fields || [],
       webId: this.remote.webId || null,
       aliases: this.config.aliases || [],
+      // A group says whether only its moderators may open posts (Lemmy's
+      // term); a person's actor carries nothing of the kind.
+      postingRestrictedToMods: this.config.kind === 'group' ? !!this.config.postingRestrictedToMods : null,
       moderators,
       pendingFollowers: priv ? urls.pendingFollowers : null,
       pendingFollowing: priv ? urls.pendingFollowing : null,
@@ -110,11 +117,11 @@ 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,
     });
   }
 
@@ -177,7 +184,9 @@ 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,
@@ -191,16 +200,21 @@ export class Publisher {
       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);
@@ -218,7 +232,7 @@ export class Publisher {
     // 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}`,
@@ -304,12 +318,13 @@ 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],
       ['following', urls.following],
+      ['featured', urls.featured],
       ['outbox', urls.outbox],
     ];
     const unreachable = [];
@@ -468,6 +483,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

@@ -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

@@ -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

@@ -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/wire-quotes.mjs

@@ -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 } : {}),
+  };
+}