fedipod-server 0.12.1 → 0.13.0

package/README.md

@@ -9,6 +9,13 @@ account: it accepts follows, delivers their posts, and serves their Mastodon
 client at the pod's own address. Signing up is the only way an account is
 made, and opting out is the only way one ends.
 
+Every delivery to an account is checked as it arrives. The server that stores
+the inbox is the server the other side's POST reaches, so the request's
+signature is verified there and the result is written beside the activity. A
+delivery signed with the wrong key is dropped. One with no signature is kept
+and the account confirms the sender through the sender's own actor document
+before acting on it. There is nothing to configure.
+
 With nothing configured beyond the defaults, installing the component changes
 nothing about how the server serves pods. All pods, whether or not they opt-in
 to being a Fediverse account, behave as Solid pods.

package/dist/claims.d.ts

@@ -2,6 +2,13 @@ export declare function claims(input: {
     host?: string;
     pathname: string;
 }, frontHost: string): boolean;
+/**
+ * The inbox container of an identity this server runs, under the root the
+ * embedded credential uses (lib/server/embed.mjs). A delivery POSTed here is
+ * verified at the door before it is written, so the request is claimed from
+ * the LDP handler; every other method on the container is the pod's.
+ */
+export declare const INBOX_PATH = "/activitypods-js/ap/inbox/";
 /**
  * True when this request belongs to an identity's client surface.
  * `agentHosts` is keyed by host including port, as the Host header carries it.
@@ -9,4 +16,5 @@ export declare function claims(input: {
 export declare function agentClaims(input: {
     host?: string;
     pathname: string;
+    method?: string;
 }, agentHosts: Set<string>, uiPath?: string): boolean;

package/dist/claims.js

@@ -4,6 +4,7 @@
 // front's apex the gateway answers the fediverse routes; a pod subdomain is a
 // real Solid pod and is never claimed.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.INBOX_PATH = void 0;
 exports.claims = claims;
 exports.agentClaims = agentClaims;
 const FRONT_PATHS = new Set(['/', '/signup', '/new-account', '/run', '/roster',
@@ -35,6 +36,13 @@ const AGENT_PATHS = new Set([
     '/.well-known/oauth-authorization-server',
 ]);
 const AGENT_PREFIXES = ['/api/', '/oauth/'];
+/**
+ * The inbox container of an identity this server runs, under the root the
+ * embedded credential uses (lib/server/embed.mjs). A delivery POSTed here is
+ * verified at the door before it is written, so the request is claimed from
+ * the LDP handler; every other method on the container is the pod's.
+ */
+exports.INBOX_PATH = '/activitypods-js/ap/inbox/';
 /**
  * True when this request belongs to an identity's client surface.
  * `agentHosts` is keyed by host including port, as the Host header carries it.
@@ -47,6 +55,8 @@ function agentClaims(input, agentHosts, uiPath = '/fedipod/') {
     const { pathname } = input;
     if (AGENT_PATHS.has(pathname))
         return true;
+    if (pathname === exports.INBOX_PATH)
+        return String(input.method ?? '').toUpperCase() === 'POST';
     if (AGENT_PREFIXES.some((prefix) => pathname.startsWith(prefix)))
         return true;
     // The owner's door, when there is one: '' turns the pages off entirely.

package/dist/handler.d.ts

@@ -138,6 +138,13 @@ export declare class FediPodServerHandler extends HttpHandler implements Initial
     }): Promise<Record<string, unknown> & {
         httpStatus: number;
     }>;
+    /**
+     * A delivery to an identity's own inbox, verified here — the server that
+     * stores the inbox is the one the request reached, so the signature is
+     * checked while its headers exist and the receipt is written beside the
+     * activity. The same door code the front runs; nothing is renamed.
+     */
+    private deliverAtDoor;
     handle({ request, response }: HttpHandlerInput): Promise<void>;
 }
 export {};

package/dist/handler.js

@@ -325,7 +325,7 @@ class FediPodServerHandler extends community_server_1.HttpHandler {
         // starting, and then stop being served once it has.
         if ((0, claims_1.claims)({ host, pathname }, this.frontHost))
             return;
-        if ((0, claims_1.agentClaims)({ host, pathname }, this.agentHosts, this.uiPath))
+        if ((0, claims_1.agentClaims)({ host, pathname, method: request.method }, this.agentHosts, this.uiPath))
             return;
         throw new Error('not a gateway route'); // reject → CSS's LDP handler takes it
     }
@@ -413,6 +413,33 @@ class FediPodServerHandler extends community_server_1.HttpHandler {
         this.logger.info(`runtime opt-out: @${row.handle} on ${base} — the pod serves plain LDP again`);
         return { httpStatus: 200, ok: true, stopped: Boolean(identity) };
     }
+    /**
+     * A delivery to an identity's own inbox, verified here — the server that
+     * stores the inbox is the one the request reached, so the signature is
+     * checked while its headers exist and the receipt is written beside the
+     * activity. The same door code the front runs; nothing is renamed.
+     */
+    async deliverAtDoor(identity, request, response) {
+        const { deliverToInbox } = await esmImport(EMBED);
+        let whatwg;
+        try {
+            // The pod's own origin: the signature covers the path and the Host header, and both are the pod's.
+            whatwg = await (0, adapt_1.nodeToWhatwg)(request, new URL(identity.podHome).origin);
+        }
+        catch (e) {
+            const status = e.statusCode === 413 ? 413 : 400;
+            response.writeHead(status, { 'content-type': 'application/json' });
+            response.end(JSON.stringify({ error: e.message }));
+            return;
+        }
+        const out = await deliverToInbox(identity.agent, whatwg, {
+            podPut: (url, body, ct) => this.podPut(url, body, ct),
+            gatewayWebId: this.args.gatewayWebId ?? null,
+        });
+        this.logger.info(`FediPod: delivery for @${identity.handle} at the door — ${out.reason} (${out.status})`);
+        response.writeHead(out.status, { 'content-type': 'application/json' });
+        response.end(JSON.stringify({ reason: out.reason }));
+    }
     async handle({ request, response }) {
         const host = String(request.headers.host ?? '').toLowerCase();
         if (this.agentHosts.has(host)) {
@@ -432,6 +459,11 @@ class FediPodServerHandler extends community_server_1.HttpHandler {
                 response.end(JSON.stringify({ error: 'this identity is still starting' }));
                 return;
             }
+            const pathname = new URL(request.url ?? '/', `https://${host}`).pathname;
+            if (pathname === claims_1.INBOX_PATH && String(request.method).toUpperCase() === 'POST') {
+                await this.deliverAtDoor(identity, request, response);
+                return;
+            }
             await identity.surface.handler(request, response);
             return;
         }

package/dist/handler.jsonld

@@ -344,6 +344,10 @@
           "@id": "fps:dist/handler.jsonld#FediPodServerHandler__member_optOutPod",
           "memberFieldName": "optOutPod"
         },
+        {
+          "@id": "fps:dist/handler.jsonld#FediPodServerHandler__member_deliverAtDoor",
+          "memberFieldName": "deliverAtDoor"
+        },
         {
           "@id": "fps:dist/handler.jsonld#FediPodServerHandler__member_handle",
           "memberFieldName": "handle"

package/lib/client/c2s.mjs

@@ -192,12 +192,14 @@ export class C2S {
     }
 
     // Read as JSON-LD, so a client may send its activity with whatever context
-    // it likes and still be understood. One we cannot read that way is read as
-    // plain JSON rather than refused, which is what a client sending ordinary
-    // ActivityStreams has always got.
+    // it likes and still be understood. What is read is the GRAPH: `dispatch`
+    // takes decisions from it and the publisher builds the document that is
+    // actually posted, so nothing a client sent is republished verbatim and a
+    // term it aliased still means what it says.
     let activity;
     try {
-      activity = (await readLenient(await readBody(req))).doc;
+      const read = await readLenient(await readBody(req));
+      activity = read.view ?? read.doc;
     } catch (e) {
       return this.send(res, 400, { error: `unreadable body: ${e.message}` });
     }

package/lib/core/as2.mjs

@@ -4,8 +4,12 @@
 // read it as one. Expanding it to a graph is what makes the document mean the
 // same thing however its sender chose to write it — `"type": "Create"` and
 // `"@type": "as:Create"` are the same statement, and only a JSON-LD reader
-// knows that. Compacting it back against the standard context is what lets the
-// handlers stay as they are: whatever arrived, they see an ordinary document.
+// knows that.
+//
+// The graph is what the handlers read, through lib/core/graphview.mjs. `doc`,
+// the copy compacted against the standard context, is kept for the callers
+// that republish what they read rather than act on it — compaction alone drops
+// any term the sender defined in its own context, so it is the weaker read.
 //
 // What we STORE and SEND is untouched by any of this. Bytes go into the pod as
 // they arrived, and lib/core/wire.mjs builds what we send as compacted AS2
@@ -15,16 +19,18 @@
 // 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. `contextsFor` serves the fourteen the fediverse
+// CONTEXTS ARE NEVER FETCHED. The loader serves the fourteen 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
-// choosing. A document naming a context we do not hold is refused with a
-// reason, which is a visible drop rather than a silent one.
+// choosing. A document naming a context we do not hold is not lost for it —
+// `groundContext` reads it against the contexts we hold and says so in
+// `degraded` — but nothing is ever fetched to make that happen.
 
 import jsonld from 'jsonld';
 import { AS_CTX } from './wire.mjs';
 import { CONTEXTS } from './contexts/index.mjs';
+import { graphView } from './graphview.mjs';
 
 export { CONTEXTS };
 
@@ -99,26 +105,66 @@ export async function parseAS2(raw) {
 }
 
 /**
- * Read AS2 bytes, and when they cannot be read as JSON-LD, read them the way
- * this project always did.
+ * Rewrite a document's `@context` to one we can read without fetching anything.
+ *
+ * A document carrying no `@context` is not a puzzle: AS2 Core §2.1 says a
+ * consumer meeting `application/activity+json` without one MUST assume the
+ * normative context still applies. That is what this does. A document naming a
+ * context we do not hold keeps every entry we DO hold — inline objects
+ * included, since those need no fetch — and loses only the unfetchable ones,
+ * so a Mastodon post with an unknown extension still reads as a post.
+ *
+ * Nothing here dereferences a URL. The result names only contexts already on
+ * disk, so the guarantee that a stranger's document cannot make us reach out
+ * survives the fallback.
+ */
+export function groundContext(input) {
+  const ctx = input['@context'];
+  const held = (c) => typeof c === 'string' ? Object.hasOwn(CONTEXTS, c) : (c && typeof c === 'object');
+  let kept;
+  if (ctx === undefined || ctx === null) kept = [];
+  else if (Array.isArray(ctx)) kept = ctx.filter(held);
+  else kept = held(ctx) ? [ctx] : [];
+  if (!kept.some(c => c === AS_CTX)) kept.unshift(AS_CTX);
+  return { ...input, '@context': kept.length === 1 ? kept[0] : kept };
+}
+
+/**
+ * Read AS2 bytes, and when they cannot be read as JSON-LD as written, read
+ * them against the contexts we do hold.
  *
  * A delivery naming a context we do not hold, or carrying none at all, is
- * still a delivery somebody sent. Refusing it here would lose mail that
- * arrives perfectly well today, so the JSON-LD read is an improvement on the
- * plain one and never a gate in front of it. `degraded` carries the reason
- * when the improvement did not happen, so a caller can record it instead of
- * letting it pass unnoticed.
+ * still a delivery somebody sent. It is now grounded rather than refused, so
+ * `graph` is present for anything that is JSON at all — which is what lets the
+ * handlers read the graph instead of the document. `degraded` still carries
+ * the reason the document could not be read exactly as written, so a caller
+ * records what happened instead of letting it pass unnoticed.
  *
- * `doc` is null only when the bytes are not JSON at all, which is what the
- * plain read would have concluded too.
+ * `doc` and `graph` are null only when the bytes are not JSON at all, which is
+ * what the plain read would have concluded too.
  */
 export async function readLenient(raw) {
   try {
     const { doc, graph } = await parseAS2(raw);
-    return { doc, graph, degraded: null };
+    return { doc, graph, view: graphView(graph), degraded: null };
   } catch (e) {
-    let doc = null;
-    try { doc = typeof raw === 'string' ? JSON.parse(raw) : (raw ?? null); } catch { /* not JSON either */ }
-    return { doc: (doc && typeof doc === 'object') ? doc : null, graph: null, degraded: e.message };
+    let input = null;
+    try { input = typeof raw === 'string' ? JSON.parse(raw) : (raw ?? null); } catch { /* not JSON either */ }
+    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.
+    //
+    // `doc` stays the bytes as they were parsed, NOT the grounded compaction.
+    // Compacting shortens an IRI to whatever term names it — `#Public` comes
+    // back as `as:Public` — and the callers that still read `doc` republish
+    // 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), 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
+      // read would have seen, with no graph, as this always did.
+      return { doc: input, graph: null, view: null, degraded: `${e.message}; grounded read also failed: ${inner.message}` };
+    }
   }
 }

package/lib/core/graphview.mjs

@@ -0,0 +1,269 @@
+// graphview.mjs — what the handlers read.
+//
+// `parseAS2` produces quads. This turns them back into something a handler can
+// read by name, so the thing being read is the GRAPH: every property access
+// here is a lookup over statements, not a key on the JSON a stranger sent.
+//
+// That distinction is the whole point. A document can say the same thing in
+// many ways — `"type": "Create"`, `"@type": "as:Create"`, a term aliased by the
+// sender's own context — and all of them leave the same statement in the
+// graph. Reading the graph means a handler sees one answer without knowing any
+// of that happened.
+//
+// Names are resolved through the contexts we already hold, AS2 first. They are
+// not hardcoded: `movedTo` is not in the AS2 context at all (it lives in
+// miscellany), and `inbox` is `ldp:inbox` rather than an `as:` term, so a map
+// written by hand would get both wrong.
+
+import { CONTEXTS } from './contexts/index.mjs';
+import { AS_CTX } from './wire.mjs';
+
+const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+const RDF_FIRST = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#first';
+const RDF_REST = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#rest';
+const RDF_NIL = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#nil';
+
+// Properties a handler treats as a collection. JSON-LD compaction would hand
+// back a bare value when there is only one, and `Array.isArray` checks in the
+// handlers then read it as empty. These always answer with an array.
+// A stranger's document decides the shape of this graph, so the walk is capped
+// rather than trusted to terminate on its own.
+const MAX_DEPTH = 12;
+
+const ALWAYS_LIST = new Set([
+  'items', 'orderedItems', 'to', 'cc', 'bto', 'bcc', 'tag', 'attachment',
+  'anyOf', 'oneOf', 'audience', 'attributedTo', 'alsoKnownAs',
+]);
+
+/** Expand `as:object` against a context's own prefix declarations. */
+function expandIri(value, prefixes) {
+  if (typeof value !== 'string') return null;
+  if (/^https?:\/\//.test(value)) return value;
+  const colon = value.indexOf(':');
+  if (colon < 1) return null;
+  const base = prefixes[value.slice(0, colon)];
+  return base ? base + value.slice(colon + 1) : null;
+}
+
+/**
+ * term -> { iri, list } over every context we hold, AS2 winning ties.
+ *
+ * Built once. A term already claimed by an earlier context is not overwritten,
+ * and AS2 is walked first, so an extension cannot quietly redefine `object`.
+ */
+function buildTerms() {
+  const terms = new Map();
+  const order = [AS_CTX, ...Object.keys(CONTEXTS).filter(u => u !== AS_CTX)];
+  for (const url of order) {
+    const ctx = CONTEXTS[url]?.['@context'];
+    if (!ctx || typeof ctx !== 'object') continue;
+    const prefixes = {};
+    for (const [k, v] of Object.entries(ctx)) {
+      if (typeof v === 'string' && /^https?:\/\//.test(v)) prefixes[k] = v;
+    }
+    for (const [name, def] of Object.entries(ctx)) {
+      if (name.startsWith('@') || terms.has(name)) continue;
+      const raw = typeof def === 'string' ? def : def?.['@id'];
+      const iri = expandIri(raw, prefixes);
+      if (!iri) continue;
+      terms.set(name, { iri, list: def?.['@container'] === '@list', container: def?.['@container'] ?? null });
+    }
+  }
+  return terms;
+}
+
+const TERMS = buildTerms();
+
+/** iri -> shortest term naming it, so a type comes back as `Create`. */
+const BY_IRI = (() => {
+  const m = new Map();
+  for (const [name, { iri }] of TERMS) {
+    const held = m.get(iri);
+    if (!held || name.length < held.length) m.set(iri, name);
+  }
+  return m;
+})();
+
+/**
+ * iri -> every term naming it.
+ *
+ * More than one term can mean the same predicate: `items` and `orderedItems`
+ * are both `as:items`, and only the list tells them apart. Emitting just the
+ * shorter name would lose `orderedItems` — and with it the ordering, which is
+ * the one thing an OrderedCollection is for.
+ */
+const NAMES_BY_IRI = (() => {
+  const m = new Map();
+  for (const [name, { iri, container }] of TERMS) {
+    // `contentMap` and `content` are the same predicate, but a language map is
+    // not another spelling of the plain term — emitting one as a bare string
+    // would invent a value the document never carried.
+    if (container === '@language' || container === '@index') continue;
+    const held = m.get(iri);
+    if (held) held.push(name); else m.set(iri, [name]);
+  }
+  return m;
+})();
+
+/** Index quads by subject, then by predicate. */
+function indexQuads(quads) {
+  const bySubject = new Map();
+  const objects = new Set();
+  // A BlankNode's `.value` has no `_:` on it, so blankness is recorded here
+  // rather than guessed from the string. A blank node has no id, and handing a
+  // handler `id: "b0"` would be handing it an identifier that means nothing.
+  const blanks = new Set();
+  for (const q of quads) {
+    if (q.subject.termType === 'BlankNode') blanks.add(q.subject.value);
+    if (q.object.termType === 'BlankNode') blanks.add(q.object.value);
+    const s = q.subject.value;
+    let preds = bySubject.get(s);
+    if (!preds) bySubject.set(s, preds = new Map());
+    let vals = preds.get(q.predicate.value);
+    if (!vals) preds.set(q.predicate.value, vals = []);
+    vals.push(q.object);
+    if (q.object.termType === 'NamedNode' || q.object.termType === 'BlankNode') {
+      objects.add(q.object.value);
+    }
+  }
+  return { bySubject, objects, blanks };
+}
+
+/**
+ * The document's own node: a subject nothing else points at. A document that
+ * points back at itself leaves no such subject, so the first typed subject is
+ * the fallback rather than nothing at all.
+ */
+function findRoot({ bySubject, objects }) {
+  for (const s of bySubject.keys()) if (!objects.has(s)) return s;
+  for (const [s, preds] of bySubject) if (preds.has(RDF_TYPE)) return s;
+  return bySubject.keys().next().value ?? null;
+}
+
+/** Walk an rdf:List into an ordered array. `orderedItems` depends on this. */
+function readList(head, ctx, depth, path) {
+  const out = [];
+  const walked = new Set();
+  let node = head;
+  while (node && node !== RDF_NIL && !walked.has(node)) {
+    walked.add(node);
+    const preds = ctx.bySubject.get(node);
+    if (!preds) break;
+    const first = preds.get(RDF_FIRST)?.[0];
+    if (first) {
+      const value = toValue(first, ctx, depth, path);
+      if (value !== null) out.push(value);
+    }
+    node = preds.get(RDF_REST)?.[0]?.value ?? null;
+  }
+  return out;
+}
+
+function isListHead(term, ctx) {
+  if (term.termType !== 'BlankNode' && term.termType !== 'NamedNode') return false;
+  return !!ctx.bySubject.get(term.value)?.has(RDF_FIRST);
+}
+
+/**
+ * A term becomes what a handler expects to find there.
+ *
+ * A node we hold statements about becomes a nested view, which is what an
+ * embedded object was in the JSON. A node we hold nothing about becomes its
+ * IRI, which is what a bare reference was. Handlers already test which they
+ * got (`typeof activity.object === 'object'`), so both stay readable.
+ */
+function toValue(term, ctx, depth, path) {
+  if (term.termType === 'Literal') return term.value;
+  if (isListHead(term, ctx)) return readList(term.value, ctx, depth, path);
+  const preds = ctx.bySubject.get(term.value);
+  if (preds && preds.size) return makeView(term.value, ctx, depth + 1, path);
+  return term.termType === 'BlankNode' ? null : term.value;
+}
+
+function readProperty(subject, name, ctx, depth = 0, path = new Set()) {
+  const preds = ctx.bySubject.get(subject);
+  if (!preds) return undefined;
+
+  if (name === 'id') return ctx.blanks.has(subject) ? undefined : subject;
+  if (name === 'type') {
+    const types = (preds.get(RDF_TYPE) ?? []).map(t => BY_IRI.get(t.value) ?? t.value);
+    if (!types.length) return undefined;
+    return types.length === 1 ? types[0] : types;
+  }
+
+  const term = TERMS.get(name);
+  if (!term) return undefined;
+  const values = preds.get(term.iri);
+  if (!values || !values.length) return undefined;
+
+  // `items` and `orderedItems` are the same predicate; the list is what tells
+  // them apart, so asking for the ordered one only answers when it is ordered.
+  const listed = values.filter(v => isListHead(v, ctx));
+  if (term.list) {
+    if (!listed.length) return undefined;
+    return readList(listed[0].value, ctx, depth, path);
+  }
+  if (listed.length === values.length && listed.length === 1) return readList(listed[0].value, ctx, depth, path);
+
+  const out = values.map(v => toValue(v, ctx, depth, path)).filter(v => v !== null);
+  if (ALWAYS_LIST.has(name)) return out.flat();
+  return out.length === 1 ? out[0] : out;
+}
+
+/**
+ * Build the plain object for one node.
+ *
+ * Materialised rather than proxied on purpose. A lazy reader would still be
+ * reading the graph, but it would be an exotic object, and the handlers pass
+ * what they read on to things that spread it, serialise it and structuredClone
+ * it into the store — all of which a Proxy either breaks or quietly truncates.
+ * What comes out here is an ordinary object whose every value came from a
+ * statement.
+ *
+ * `depth` and `seen` are the guards. The graph is built from a stranger's
+ * document, so it can be cyclic or enormous; a node already on the path
+ * becomes its IRI rather than being walked again.
+ */
+function makeView(subject, ctx, depth = 0, seen = new Set()) {
+  if (depth > MAX_DEPTH || seen.has(subject)) {
+    return ctx.blanks.has(subject) ? null : subject;
+  }
+  const preds = ctx.bySubject.get(subject);
+  if (!preds) return ctx.blanks.has(subject) ? null : subject;
+
+  const path = new Set(seen).add(subject);
+  const out = {};
+  const id = readProperty(subject, 'id', ctx, depth, path);
+  if (id !== undefined) out.id = id;
+  const type = readProperty(subject, 'type', ctx, depth, path);
+  if (type !== undefined) out.type = type;
+
+  for (const predicate of preds.keys()) {
+    if (predicate === RDF_TYPE || predicate === RDF_FIRST || predicate === RDF_REST) continue;
+    // A predicate no context we hold names cannot be asked for by name, so it
+    // is left out rather than carried under an IRI no handler would look up.
+    for (const name of NAMES_BY_IRI.get(predicate) ?? []) {
+      if (name === 'id' || name === 'type') continue;
+      const value = readProperty(subject, name, ctx, depth, path);
+      if (value !== undefined) out[name] = value;
+    }
+  }
+  return out;
+}
+
+/**
+ * A reader over `parseAS2`'s quads.
+ *
+ * Returns null when there is nothing to read, which is the same answer the
+ * document-shaped read gave for bytes that were not a document.
+ */
+export function graphView(quads, { root = null } = {}) {
+  if (!quads || !quads.length) return null;
+  const ctx = indexQuads(quads);
+  const subject = root ?? findRoot(ctx);
+  if (!subject) return null;
+  const view = makeView(subject, ctx);
+  return (view && typeof view === 'object') ? view : null;
+}
+
+export { TERMS, BY_IRI };

package/lib/core/intake/index.mjs

@@ -223,8 +223,8 @@ export class Intake {
           // failed and stays for the next pass.
           const got = await podInbox.readItem(this.remote, item.url, { maxBytes: MAX_ITEM_BYTES, readCapped });
           const read = got.raw === null ? null : await readLenient(got.raw);
-          if (read?.degraded) this.log(`inbox item ${item.url} read as plain JSON: ${read.degraded}`);
-          const activity = read?.doc ?? null;
+          if (read?.degraded) this.log(`inbox item ${item.url} grounded to read: ${read.degraded}`);
+          const activity = read?.view ?? read?.doc ?? null;
           // A Create is the content the owner just asked to be rid of. Anything
           // else changes state and is applied exactly as a drain would.
           if (keepConcerning) {
@@ -407,8 +407,8 @@ export class Intake {
         // says. A document we cannot read that way is read the way it always
         // was rather than lost, and the reason is logged.
         const read = raw ? await readLenient(raw) : null;
-        if (read?.degraded) this.log(`inbox item ${url} read as plain JSON: ${read.degraded}`);
-        activity = read?.doc ?? null;
+        if (read?.degraded) this.log(`inbox item ${url} grounded to read: ${read.degraded}`);
+        activity = read?.view ?? read?.doc ?? null;
         // What the shapes make of it. This decides NOTHING — the activity is
         // handled either way. It is written down so that which shapes fire on
         // real traffic is a question with an answer, rather than a guess made

package/lib/core/intake/verify.mjs

@@ -25,8 +25,8 @@ export async function fetchAP(intake, url) {
   let doc = null;
   try {
     const read = await readLenient(await readCapped(res));
-    if (read.degraded) intake.log(`fetch ${url} read as plain JSON: ${read.degraded}`);
-    doc = read.doc;
+    if (read.degraded) intake.log(`fetch ${url} grounded to read: ${read.degraded}`);
+    doc = read.view ?? read.doc;
   } catch (e) { intake.log(`fetch ${url}: unreadable — ${e.message}`); return null; }
   if (!doc) { intake.log(`fetch ${url}: unreadable as JSON`); return null; }
   // A document is only evidence about its OWN origin.
@@ -134,7 +134,8 @@ export async function isGone(intake, url) {
     // A Tombstone answers 200 and still means deleted.
     try {
       const { readCapped } = await import('../../shared/safefetch.mjs');
-      return (await readLenient(await readCapped(res))).doc?.type === 'Tombstone';
+      const read = await readLenient(await readCapped(res));
+      return (read.view ?? read.doc)?.type === 'Tombstone';
     } catch { return false; }
   }
   return null;                       // 401/403/5xx — no answer, not a denial

package/lib/core/publisher/restore.mjs

@@ -37,11 +37,14 @@ export async function reconcileFollowers(publisher, contacts) {
     try {
       const res = await publisher.deliverer.signedFetch(actor, { headers: { accept: ACCEPT_AP } });
       if (!res.ok) continue;
-      const { doc, degraded } = await readLenient(await res.json());
-      if (degraded) publisher.log?.(`actor ${actor} read as plain JSON: ${degraded}`);
-      if (!doc?.inbox) continue;
+      // The graph, not the compacted copy: `inbox` is `ldp:inbox` rather than
+      // an `as:` term, and what is wanted here is the statement, not a key.
+      const { doc, view, degraded } = await readLenient(await res.json());
+      const actorDoc = view ?? doc;
+      if (degraded) publisher.log?.(`actor ${actor} grounded to read: ${degraded}`);
+      if (!actorDoc?.inbox) continue;
       contacts.followers.push({
-        actor, inbox: doc.inbox, sharedInbox: doc.endpoints?.sharedInbox || null, recovered: true,
+        actor, inbox: actorDoc.inbox, sharedInbox: actorDoc.endpoints?.sharedInbox || null, recovered: true,
         // Said explicitly, because onUndo reads it: the pod publishes WHO
         // follows, never the id of the Follow that did it, so a recovered
         // record has nothing an Undo can be matched against and must not be