@fedify/backfill 2.3.0-dev.0

package/dist/backfill.test.js

@@ -0,0 +1,1541 @@
+import { deepStrictEqual, ok, rejects, strictEqual } from "node:assert/strict";
+import test, { describe } from "node:test";
+import { Activity, Announce, Collection, CollectionPage, Create, Note, Object as Object$1, OrderedCollection, OrderedCollectionPage } from "@fedify/vocab";
+//#region src/backfill.ts
+const defaultStrategies = ["context-auto"];
+const DEFAULT_MAX_DEPTH = 10;
+/**
+* Thrown when backfill traversal exceeds the configured request budget.
+*
+* @since 2.3.0
+*/
+var MaxRequestsExceeded = class extends Error {};
+/**
+* Backfills post-like objects related to a seed object.
+*
+* The seed object is not yielded by default, but its ID is treated as already
+* seen so it will not be yielded again if the collection contains it.
+*
+* @since 2.3.0
+*/
+async function* backfill(context, note, options = {}) {
+	if (options.maxItems != null && options.maxItems <= 0) return;
+	const strategies = normalizeStrategies(options.strategies);
+	if (strategies.length < 1) return;
+	const budget = {
+		signal: options.signal,
+		requestCount: 0,
+		documents: /* @__PURE__ */ new Map()
+	};
+	const seenIds = /* @__PURE__ */ new Set();
+	if (note.id != null) seenIds.add(note.id.href);
+	let yielded = 0;
+	try {
+		for (let i = 0; i < strategies.length; i++) {
+			const strategy = strategies[i];
+			let items;
+			if (isContextStrategy(strategy)) {
+				const contextStrategies = [strategy];
+				while (true) {
+					const nextStrategy = strategies[i + 1];
+					if (nextStrategy == null || !isContextStrategy(nextStrategy)) break;
+					contextStrategies.push(nextStrategy);
+					i++;
+				}
+				items = getContextStrategyItems(context, note, contextStrategies, options, budget, seenIds);
+			} else items = getStrategyItems(context, note, strategy, options, budget, seenIds);
+			for await (const item of items) {
+				const id = item.object.id ?? void 0;
+				if (id != null) {
+					if (seenIds.has(id.href)) continue;
+					seenIds.add(id.href);
+				}
+				options.signal?.throwIfAborted();
+				yield {
+					object: item.object,
+					id,
+					strategy: item.strategy,
+					origin: item.origin,
+					depth: item.depth
+				};
+				yielded++;
+				if (options.maxItems != null && yielded >= options.maxItems) return;
+			}
+		}
+	} catch (error) {
+		if (error instanceof MaxRequestsExceeded) return;
+		throw error;
+	}
+}
+function normalizeStrategies(strategies = defaultStrategies) {
+	const normalized = [];
+	for (const strategy of strategies) if (strategy === "context-auto") {
+		for (let i = normalized.length - 1; i >= 0 && isContextStrategy(normalized[i]); i--) normalized.splice(i, 1);
+		if (!normalized.includes(strategy)) normalized.push(strategy);
+	} else if (isContextStrategy(strategy)) {
+		if (!currentContextGroupHasAuto(normalized) && !normalized.includes(strategy)) normalized.push(strategy);
+	} else if (!normalized.includes(strategy)) normalized.push(strategy);
+	return normalized;
+}
+function isContextStrategy(strategy) {
+	return strategy === "context-objects" || strategy === "context-activities" || strategy === "context-auto";
+}
+function currentContextGroupHasAuto(strategies) {
+	for (let i = strategies.length - 1; i >= 0; i--) {
+		const strategy = strategies[i];
+		if (!isContextStrategy(strategy)) return false;
+		if (strategy === "context-auto") return true;
+	}
+	return false;
+}
+async function* getContextStrategyItems(context, note, strategies, options, budget, seenIds) {
+	const contextId = note.contextIds[0];
+	if (contextId == null) return;
+	const collection = await loadObject(context, contextId, options, budget);
+	if (!isCollection(collection)) return;
+	for await (const object of getCollectionItems(context, collection, options, budget, seenIds)) for (const strategy of strategies) for await (const item of getContextBackfillItems(context, object, strategy, options, budget)) yield {
+		object: item.object,
+		strategy: item.strategy,
+		origin: "collection",
+		depth: 0
+	};
+}
+async function* getStrategyItems(context, note, strategy, options, budget, seenIds) {
+	if (isContextStrategy(strategy)) yield* getContextStrategyItems(context, note, [strategy], options, budget, seenIds);
+	else if (strategy === "reply-tree") yield* getReplyTreeItems(context, note, options, budget);
+}
+async function* getReplyTreeItems(context, note, options, budget) {
+	const visitedObjectIds = /* @__PURE__ */ new Set();
+	const visitedObjects = /* @__PURE__ */ new WeakSet();
+	const visitedCollectionIds = /* @__PURE__ */ new Set();
+	const visitedCollections = /* @__PURE__ */ new WeakSet();
+	if (note.id != null) visitedObjectIds.add(note.id.href);
+	visitedObjects.add(note);
+	const ancestors = [];
+	for await (const item of getReplyAncestors(context, note, options, budget, {
+		depth: 1,
+		visitedObjectIds,
+		visitedObjects,
+		visitedCollectionIds,
+		visitedCollections
+	})) {
+		ancestors.push({
+			object: item.object,
+			depth: item.depth
+		});
+		yield item;
+	}
+	for (const ancestor of ancestors.toReversed()) yield* getReplyDescendants(context, ancestor.object, options, budget, {
+		depth: ancestor.depth + 1,
+		visitedObjectIds,
+		visitedObjects,
+		visitedCollectionIds,
+		visitedCollections
+	});
+	yield* getReplyDescendants(context, note, options, budget, {
+		depth: 1,
+		visitedObjectIds,
+		visitedObjects,
+		visitedCollectionIds,
+		visitedCollections
+	});
+}
+async function* getReplyAncestors(context, object, options, budget, traversal) {
+	if (traversal.depth > (options.maxDepth ?? DEFAULT_MAX_DEPTH)) return;
+	for await (const target of getReplyTargets(context, object, options, budget)) {
+		if (!isContextPostObject(target)) continue;
+		if (!visitReplyTreeObject(target, traversal)) continue;
+		yield {
+			object: target,
+			strategy: "reply-tree",
+			origin: "in-reply-to",
+			depth: traversal.depth
+		};
+		yield* getReplyAncestors(context, target, options, budget, {
+			depth: traversal.depth + 1,
+			visitedObjectIds: traversal.visitedObjectIds,
+			visitedObjects: traversal.visitedObjects,
+			visitedCollectionIds: traversal.visitedCollectionIds,
+			visitedCollections: traversal.visitedCollections
+		});
+	}
+}
+async function* getReplyDescendants(context, object, options, budget, traversal) {
+	if (traversal.depth > (options.maxDepth ?? DEFAULT_MAX_DEPTH)) return;
+	const repliesId = object.repliesId;
+	if (repliesId != null && traversal.visitedCollectionIds.has(repliesId.href)) return;
+	const replies = await getRepliesCollection(context, object, options, budget);
+	if (replies == null) return;
+	const unvisited = visitReplyTreeCollection(replies, traversal);
+	if (repliesId != null) traversal.visitedCollectionIds.add(repliesId.href);
+	if (!unvisited) return;
+	for await (const reply of getCollectionItems(context, replies, options, budget, traversal.visitedObjectIds)) {
+		if (!isContextPostObject(reply)) continue;
+		if (!visitReplyTreeObject(reply, traversal)) continue;
+		yield {
+			object: reply,
+			strategy: "reply-tree",
+			origin: "replies",
+			depth: traversal.depth
+		};
+		yield* getReplyDescendants(context, reply, options, budget, {
+			depth: traversal.depth + 1,
+			visitedObjectIds: traversal.visitedObjectIds,
+			visitedObjects: traversal.visitedObjects,
+			visitedCollectionIds: traversal.visitedCollectionIds,
+			visitedCollections: traversal.visitedCollections
+		});
+	}
+}
+async function* getReplyTargets(context, object, options, budget) {
+	try {
+		yield* object.getReplyTargets({
+			documentLoader: async (url) => {
+				return await loadCollectionItemDocument(context, url, options, budget);
+			},
+			crossOrigin: "trust"
+		});
+	} catch (error) {
+		if (error instanceof MaxRequestsExceeded) throw error;
+		budget.signal?.throwIfAborted();
+	}
+}
+async function getRepliesCollection(context, object, options, budget) {
+	try {
+		return await object.getReplies({
+			documentLoader: async (url) => {
+				return await loadCollectionItemDocument(context, url, options, budget);
+			},
+			crossOrigin: "trust"
+		});
+	} catch (error) {
+		if (error instanceof MaxRequestsExceeded) throw error;
+		budget.signal?.throwIfAborted();
+		return null;
+	}
+}
+function visitReplyTreeObject(object, traversal) {
+	if (object.id != null) {
+		if (traversal.visitedObjectIds.has(object.id.href)) return false;
+		traversal.visitedObjectIds.add(object.id.href);
+	} else if (traversal.visitedObjects.has(object)) return false;
+	traversal.visitedObjects.add(object);
+	return true;
+}
+function visitReplyTreeCollection(collection, traversal) {
+	if (collection.id != null) return visitReplyTreeCollectionId(collection.id, traversal);
+	else if (traversal.visitedCollections.has(collection)) return false;
+	traversal.visitedCollections.add(collection);
+	return true;
+}
+function visitReplyTreeCollectionId(id, traversal) {
+	if (traversal.visitedCollectionIds.has(id.href)) return false;
+	traversal.visitedCollectionIds.add(id.href);
+	return true;
+}
+async function* getContextBackfillItems(context, object, strategy, options, budget) {
+	if (strategy === "context-objects" && isContextPostObject(object)) yield {
+		object,
+		strategy
+	};
+	else if (strategy === "context-activities") {
+		const activityObject = await getCreateActivityObject(context, object, options, budget);
+		if (activityObject != null && isContextPostObject(activityObject)) yield {
+			object: activityObject,
+			strategy
+		};
+	} else if (strategy === "context-auto") {
+		if (object instanceof Activity) {
+			const activityObject = await getCreateActivityObject(context, object, options, budget);
+			if (activityObject != null && isContextPostObject(activityObject)) yield {
+				object: activityObject,
+				strategy
+			};
+		} else if (isContextPostObject(object)) yield {
+			object,
+			strategy
+		};
+	}
+}
+async function* getCollectionItems(context, collection, options, budget, skipIds) {
+	yield* collection.getItems({
+		documentLoader: async (url) => {
+			return await loadCollectionItemDocument(context, url, options, budget, skipIds);
+		},
+		crossOrigin: "trust"
+	});
+}
+async function getCreateActivityObject(context, object, options, budget) {
+	if (!(object instanceof Create)) return null;
+	try {
+		return await object.getObject({
+			documentLoader: async (url) => {
+				return await loadCollectionItemDocument(context, url, options, budget);
+			},
+			crossOrigin: "trust"
+		});
+	} catch (error) {
+		if (error instanceof MaxRequestsExceeded) throw error;
+		budget.signal?.throwIfAborted();
+		return null;
+	}
+}
+async function loadCollectionItemDocument(context, url, options, budget, skipIds) {
+	let object;
+	try {
+		const iri = new URL(url);
+		if (skipIds?.has(iri.href)) return skippedCollectionItemDocument(url);
+		object = await loadObject(context, iri, options, budget, true);
+	} catch (error) {
+		if (error instanceof MaxRequestsExceeded) throw error;
+		budget.signal?.throwIfAborted();
+		return skippedCollectionItemDocument(url);
+	}
+	if (object == null) return skippedCollectionItemDocument(url);
+	return {
+		contextUrl: null,
+		documentUrl: url,
+		document: await object.toJsonLd()
+	};
+}
+function skippedCollectionItemDocument(url) {
+	return {
+		contextUrl: null,
+		documentUrl: url,
+		document: {
+			"@context": "https://www.w3.org/ns/activitystreams",
+			type: "Activity"
+		}
+	};
+}
+async function loadObject(context, iri, options, budget, throwOnBudgetExceeded = false) {
+	budget.signal?.throwIfAborted();
+	const cacheKey = iri.href;
+	const cached = budget.documents.get(cacheKey);
+	if (cached != null) return await cached;
+	if (options.maxRequests != null && budget.requestCount >= options.maxRequests) {
+		if (throwOnBudgetExceeded) throw new MaxRequestsExceeded();
+		return null;
+	}
+	await waitForInterval(options, budget);
+	budget.signal?.throwIfAborted();
+	budget.requestCount++;
+	const document = context.documentLoader(iri, { signal: budget.signal });
+	budget.documents.set(cacheKey, document);
+	try {
+		return await document;
+	} catch (error) {
+		if (budget.documents.get(cacheKey) === document) budget.documents.delete(cacheKey);
+		throw error;
+	}
+}
+async function waitForInterval(options, budget) {
+	if (options.interval == null) return;
+	const milliseconds = durationToMilliseconds(typeof options.interval === "function" ? options.interval(budget.requestCount) : options.interval);
+	if (milliseconds <= 0) return;
+	await new Promise((resolve, reject) => {
+		if (budget.signal?.aborted) {
+			reject(budget.signal.reason);
+			return;
+		}
+		const timeout = setTimeout(() => {
+			budget.signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, milliseconds);
+		const onAbort = () => {
+			clearTimeout(timeout);
+			reject(budget.signal?.reason);
+		};
+		budget.signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function durationToMilliseconds(duration) {
+	if (typeof duration === "string") {
+		if (typeof Temporal === "undefined") throw new TypeError("Temporal is not globally available; pass interval as a Temporal.DurationLike object instead of a string, or provide a Temporal polyfill.");
+		return Temporal.Duration.from(duration).total({ unit: "milliseconds" });
+	}
+	return (duration.milliseconds ?? 0) + (duration.seconds ?? 0) * 1e3 + (duration.minutes ?? 0) * 60 * 1e3 + (duration.hours ?? 0) * 60 * 60 * 1e3 + (duration.days ?? 0) * 24 * 60 * 60 * 1e3;
+}
+function isCollection(object) {
+	return object instanceof Collection || object instanceof OrderedCollection || object instanceof CollectionPage || object instanceof OrderedCollectionPage;
+}
+function isContextPostObject(object) {
+	return object instanceof Object$1 && !(object instanceof Activity) && !isCollection(object);
+}
+//#endregion
+//#region src/backfill.test.ts
+async function collect(context, note, options = {}) {
+	return await Array.fromAsync(backfill(context, note, options));
+}
+describe("backfill", () => {
+	test("package exports backfill", () => {
+		strictEqual(typeof backfill, "function");
+		strictEqual(typeof MaxRequestsExceeded, "function");
+	});
+	test("context missing yields nothing", async () => {
+		deepStrictEqual(await collect({ documentLoader: () => {
+			throw new Error("documentLoader should not be called");
+		} }, new Note({ id: new URL("https://example.com/notes/1") })), []);
+	});
+	test("context resolves to non-collection yields nothing", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		deepStrictEqual(await collect({ documentLoader: () => Promise.resolve(new Note({ id: new URL("https://example.com/notes/2") })) }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		})), []);
+	});
+	test("context collection with embedded objects yields items", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const item = new Note({
+			id: new URL("https://example.com/notes/2"),
+			content: "hello"
+		});
+		const items = await collect({ documentLoader: () => Promise.resolve(new Collection({
+			id: contextId,
+			items: [item]
+		})) }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		}));
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object, item);
+		deepStrictEqual(items[0].id, item.id);
+		strictEqual(items[0].strategy, "context-auto");
+		strictEqual(items[0].origin, "collection");
+	});
+	test("context object strategy yields embedded objects", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const item = new Note({
+			id: new URL("https://example.com/notes/2"),
+			content: "hello"
+		});
+		const items = await collect({ documentLoader: () => Promise.resolve(new Collection({
+			id: contextId,
+			items: [item]
+		})) }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		}), { strategies: ["context-objects"] });
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object, item);
+		strictEqual(items[0].strategy, "context-objects");
+	});
+	test("embedded object without id is yielded without id", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const item = new Note({ content: "anonymous" });
+		const items = await collect({ documentLoader: () => Promise.resolve(new Collection({
+			id: contextId,
+			items: [item]
+		})) }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		}));
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object, item);
+		strictEqual(items[0].id, void 0);
+	});
+	test("context object strategy skips activity objects", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const activity = new Create({
+			id: new URL("https://example.com/activities/1"),
+			object: new Note({ id: new URL("https://example.com/notes/2") })
+		});
+		deepStrictEqual(await collect({ documentLoader: () => Promise.resolve(new Collection({
+			id: contextId,
+			items: [activity]
+		})) }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		}), { strategies: ["context-objects"] }), []);
+	});
+	test("context auto strategy yields object from embedded Create", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const item = new Note({
+			id: new URL("https://example.com/notes/2"),
+			content: "hello"
+		});
+		const activity = new Create({
+			id: new URL("https://example.com/activities/1"),
+			object: item
+		});
+		const items = await collect({ documentLoader: () => Promise.resolve(new Collection({
+			id: contextId,
+			items: [activity]
+		})) }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		}));
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object, item);
+		strictEqual(items[0].strategy, "context-auto");
+	});
+	test("empty strategies yield nothing without dereferencing context", async () => {
+		deepStrictEqual(await collect({ documentLoader: () => {
+			throw new Error("documentLoader should not be called");
+		} }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [new URL("https://example.com/contexts/1")]
+		}), { strategies: [] }), []);
+	});
+	test("reply tree strategy does not require context collection", async () => {
+		deepStrictEqual(await collect({ documentLoader: () => {
+			throw new Error("documentLoader should not be called");
+		} }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [new URL("https://example.com/contexts/1")]
+		}), { strategies: ["reply-tree"] }), []);
+	});
+	test("reply tree yields embedded ancestor", async () => {
+		const parent = new Note({
+			id: new URL("https://example.com/notes/1"),
+			content: "parent"
+		});
+		const items = await collect({ documentLoader: () => {
+			throw new Error("documentLoader should not be called");
+		} }, new Note({
+			id: new URL("https://example.com/notes/2"),
+			replyTarget: parent
+		}), { strategies: ["reply-tree"] });
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object, parent);
+		deepStrictEqual(items[0].id, parent.id);
+		strictEqual(items[0].strategy, "reply-tree");
+		strictEqual(items[0].origin, "in-reply-to");
+		strictEqual(items[0].depth, 1);
+	});
+	test("reply tree dereferences ancestor URL", async () => {
+		const parentId = new URL("https://example.com/notes/1");
+		const parent = new Note({
+			id: parentId,
+			content: "parent"
+		});
+		const items = await collect({ documentLoader: (iri) => Promise.resolve(iri.href === parentId.href ? parent : null) }, new Note({
+			id: new URL("https://example.com/notes/2"),
+			replyTarget: parentId
+		}), { strategies: ["reply-tree"] });
+		strictEqual(items.length, 1);
+		deepStrictEqual(items[0].object.id, parent.id);
+		strictEqual(items[0].origin, "in-reply-to");
+		strictEqual(items[0].depth, 1);
+	});
+	test("reply tree maxDepth limits ancestors", async () => {
+		const rootId = new URL("https://example.com/notes/1");
+		const parentId = new URL("https://example.com/notes/2");
+		const root = new Note({
+			id: rootId,
+			content: "root"
+		});
+		const parent = new Note({
+			id: parentId,
+			content: "parent",
+			replyTarget: rootId
+		});
+		const items = await collect({ documentLoader: (iri) => {
+			if (iri.href === parentId.href) return Promise.resolve(parent);
+			if (iri.href === rootId.href) return Promise.resolve(root);
+			return Promise.resolve(null);
+		} }, new Note({
+			id: new URL("https://example.com/notes/3"),
+			replyTarget: parentId
+		}), {
+			strategies: ["reply-tree"],
+			maxDepth: 1
+		});
+		strictEqual(items.length, 1);
+		deepStrictEqual(items[0].object.id, parent.id);
+		strictEqual(items[0].depth, 1);
+	});
+	test("reply tree defaults maxDepth to 10 for ancestors", async () => {
+		let note = new Note({ id: new URL("https://example.com/notes/0") });
+		for (let i = 1; i <= 12; i++) note = new Note({
+			id: new URL(`https://example.com/notes/${i}`),
+			replyTarget: note
+		});
+		const items = await collect({ documentLoader: () => {
+			throw new Error("documentLoader should not be called");
+		} }, note, { strategies: ["reply-tree"] });
+		strictEqual(items.length, 10);
+		strictEqual(items.at(-1)?.depth, 10);
+	});
+	test("maxRequests limits reply tree ancestor dereferencing", async () => {
+		const parentId = new URL("https://example.com/notes/1");
+		deepStrictEqual(await collect({ documentLoader: () => {
+			throw new Error("documentLoader should not be called");
+		} }, new Note({
+			id: new URL("https://example.com/notes/2"),
+			replyTarget: parentId
+		}), {
+			strategies: ["reply-tree"],
+			maxRequests: 0
+		}), []);
+	});
+	test("reply tree avoids ancestor cycles", async () => {
+		const seedId = new URL("https://example.com/notes/1");
+		const parentId = new URL("https://example.com/notes/2");
+		const note = new Note({
+			id: seedId,
+			replyTarget: parentId
+		});
+		const parent = new Note({
+			id: parentId,
+			replyTarget: seedId
+		});
+		const items = await collect({ documentLoader: (iri) => {
+			if (iri.href === seedId.href) return Promise.resolve(note);
+			if (iri.href === parentId.href) return Promise.resolve(parent);
+			return Promise.resolve(null);
+		} }, note, { strategies: ["reply-tree"] });
+		strictEqual(items.length, 1);
+		deepStrictEqual(items[0].object.id, parent.id);
+	});
+	test("reply tree deduplicates ancestors from context collection", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const parentId = new URL("https://example.com/notes/1");
+		const parent = new Note({
+			id: parentId,
+			content: "parent"
+		});
+		const items = await collect({ documentLoader: (iri) => {
+			if (iri.href === contextId.href) return Promise.resolve(new Collection({
+				id: contextId,
+				items: [parent]
+			}));
+			if (iri.href === parentId.href) return Promise.resolve(parent);
+			return Promise.resolve(null);
+		} }, new Note({
+			id: new URL("https://example.com/notes/2"),
+			contexts: [contextId],
+			replyTarget: parentId
+		}), { strategies: ["context-auto", "reply-tree"] });
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object, parent);
+		strictEqual(items[0].strategy, "context-auto");
+	});
+	test("document cache avoids duplicate dereferences across strategies", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const parentId = new URL("https://example.com/notes/1");
+		const parent = new Note({
+			id: parentId,
+			content: "parent"
+		});
+		const note = new Note({
+			id: new URL("https://example.com/notes/2"),
+			contexts: [contextId],
+			replyTarget: parentId
+		});
+		const requests = [];
+		const items = await collect({ documentLoader: (iri) => {
+			requests.push(iri);
+			if (iri.href === contextId.href) return Promise.resolve(new Collection({
+				id: contextId,
+				items: [parentId]
+			}));
+			if (iri.href === parentId.href) return Promise.resolve(parent);
+			return Promise.resolve(null);
+		} }, note, { strategies: ["context-auto", "reply-tree"] });
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object.id?.href, parentId.href);
+		deepStrictEqual(requests.map((url) => url.href), [contextId.href, parentId.href]);
+	});
+	test("document cache does not keep failed dereferences", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const parentId = new URL("https://example.com/notes/1");
+		const parent = new Note({
+			id: parentId,
+			content: "parent"
+		});
+		const note = new Note({
+			id: new URL("https://example.com/notes/2"),
+			contexts: [contextId],
+			replyTarget: parentId
+		});
+		const requests = [];
+		let parentRequests = 0;
+		const items = await collect({ documentLoader: (iri) => {
+			requests.push(iri);
+			if (iri.href === contextId.href) return Promise.resolve(new Collection({
+				id: contextId,
+				items: [parentId]
+			}));
+			if (iri.href === parentId.href) {
+				parentRequests++;
+				if (parentRequests === 1) throw new Error("temporary failure");
+				return Promise.resolve(parent);
+			}
+			return Promise.resolve(null);
+		} }, note, { strategies: ["context-auto", "reply-tree"] });
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object.id?.href, parentId.href);
+		deepStrictEqual(requests.map((url) => url.href), [
+			contextId.href,
+			parentId.href,
+			parentId.href
+		]);
+	});
+	test("strategy order controls deduplicated item metadata", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const parentId = new URL("https://example.com/notes/1");
+		const parent = new Note({
+			id: parentId,
+			content: "parent"
+		});
+		const items = await collect({ documentLoader: (iri) => {
+			if (iri.href === parentId.href) return Promise.resolve(parent);
+			if (iri.href === contextId.href) return Promise.resolve(new Collection({
+				id: contextId,
+				items: [parent]
+			}));
+			return Promise.resolve(null);
+		} }, new Note({
+			id: new URL("https://example.com/notes/2"),
+			contexts: [contextId],
+			replyTarget: parentId
+		}), { strategies: ["reply-tree", "context-auto"] });
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object.id?.href, parentId.href);
+		strictEqual(items[0].strategy, "reply-tree");
+		strictEqual(items[0].origin, "in-reply-to");
+	});
+	test("context auto preserves strategy order across reply tree", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const parentId = new URL("https://example.com/notes/1");
+		const parent = new Note({
+			id: parentId,
+			content: "parent"
+		});
+		const items = await collect({ documentLoader: (iri) => {
+			if (iri.href === contextId.href) return Promise.resolve(new Collection({
+				id: contextId,
+				items: [parent]
+			}));
+			if (iri.href === parentId.href) return Promise.resolve(parent);
+			return Promise.resolve(null);
+		} }, new Note({
+			id: new URL("https://example.com/notes/2"),
+			contexts: [contextId],
+			replyTarget: parentId
+		}), { strategies: [
+			"context-objects",
+			"reply-tree",
+			"context-auto"
+		] });
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object.id?.href, parentId.href);
+		strictEqual(items[0].strategy, "context-objects");
+		strictEqual(items[0].origin, "collection");
+	});
+	test("reply tree yields embedded descendants", async () => {
+		const reply = new Note({
+			id: new URL("https://example.com/notes/2"),
+			content: "reply"
+		});
+		const items = await collect({ documentLoader: () => {
+			throw new Error("documentLoader should not be called");
+		} }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			replies: new Collection({
+				id: new URL("https://example.com/notes/1/replies"),
+				items: [reply]
+			})
+		}), { strategies: ["reply-tree"] });
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object, reply);
+		deepStrictEqual(items[0].id, reply.id);
+		strictEqual(items[0].strategy, "reply-tree");
+		strictEqual(items[0].origin, "replies");
+		strictEqual(items[0].depth, 1);
+	});
+	test("reply tree walks sibling descendants from discovered ancestor", async () => {
+		const seedId = new URL("https://example.com/notes/2");
+		const sibling = new Note({
+			id: new URL("https://example.com/notes/3"),
+			content: "sibling"
+		});
+		const parent = new Note({
+			id: new URL("https://example.com/notes/1"),
+			content: "parent",
+			replies: new Collection({
+				id: new URL("https://example.com/notes/1/replies"),
+				items: [seedId, sibling]
+			})
+		});
+		const items = await collect({ documentLoader: () => {
+			throw new Error("documentLoader should not be called");
+		} }, new Note({
+			id: seedId,
+			replyTarget: parent
+		}), { strategies: ["reply-tree"] });
+		strictEqual(items.length, 2);
+		strictEqual(items[0].object, parent);
+		strictEqual(items[0].origin, "in-reply-to");
+		strictEqual(items[0].depth, 1);
+		strictEqual(items[1].object, sibling);
+		strictEqual(items[1].origin, "replies");
+		strictEqual(items[1].depth, 2);
+	});
+	test("reply tree maxDepth applies from seed through ancestors", async () => {
+		const seedId = new URL("https://example.com/notes/2");
+		const sibling = new Note({
+			id: new URL("https://example.com/notes/3"),
+			content: "sibling"
+		});
+		const parent = new Note({
+			id: new URL("https://example.com/notes/1"),
+			content: "parent",
+			replies: new Collection({
+				id: new URL("https://example.com/notes/1/replies"),
+				items: [seedId, sibling]
+			})
+		});
+		const items = await collect({ documentLoader: () => {
+			throw new Error("documentLoader should not be called");
+		} }, new Note({
+			id: seedId,
+			replyTarget: parent
+		}), {
+			strategies: ["reply-tree"],
+			maxDepth: 1
+		});
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object, parent);
+		strictEqual(items[0].depth, 1);
+	});
+	test("reply tree dereferences replies collection URL", async () => {
+		const repliesId = new URL("https://example.com/notes/1/replies");
+		const reply = new Note({
+			id: new URL("https://example.com/notes/2"),
+			content: "reply"
+		});
+		const items = await collect({ documentLoader: (iri) => Promise.resolve(iri.href === repliesId.href ? new Collection({
+			id: repliesId,
+			items: [reply]
+		}) : null) }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			replies: repliesId
+		}), { strategies: ["reply-tree"] });
+		strictEqual(items.length, 1);
+		deepStrictEqual(items[0].object.id, reply.id);
+		strictEqual(items[0].origin, "replies");
+		strictEqual(items[0].depth, 1);
+	});
+	test("reply tree maxDepth limits descendants", async () => {
+		const grandchild = new Note({
+			id: new URL("https://example.com/notes/3"),
+			content: "grandchild"
+		});
+		const reply = new Note({
+			id: new URL("https://example.com/notes/2"),
+			content: "reply",
+			replies: new Collection({
+				id: new URL("https://example.com/notes/2/replies"),
+				items: [grandchild]
+			})
+		});
+		const items = await collect({ documentLoader: () => {
+			throw new Error("documentLoader should not be called");
+		} }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			replies: new Collection({
+				id: new URL("https://example.com/notes/1/replies"),
+				items: [reply]
+			})
+		}), {
+			strategies: ["reply-tree"],
+			maxDepth: 1
+		});
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object, reply);
+		strictEqual(items[0].depth, 1);
+	});
+	test("reply tree defaults maxDepth to 10 for descendants", async () => {
+		let note = new Note({ id: new URL("https://example.com/notes/12") });
+		for (let i = 11; i >= 0; i--) note = new Note({
+			id: new URL(`https://example.com/notes/${i}`),
+			replies: new Collection({
+				id: new URL(`https://example.com/notes/${i}/replies`),
+				items: [note]
+			})
+		});
+		const items = await collect({ documentLoader: () => {
+			throw new Error("documentLoader should not be called");
+		} }, note, { strategies: ["reply-tree"] });
+		strictEqual(items.length, 10);
+		strictEqual(items.at(-1)?.depth, 10);
+	});
+	test("maxRequests limits reply tree replies dereferencing", async () => {
+		const repliesId = new URL("https://example.com/notes/1/replies");
+		deepStrictEqual(await collect({ documentLoader: () => {
+			throw new Error("documentLoader should not be called");
+		} }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			replies: repliesId
+		}), {
+			strategies: ["reply-tree"],
+			maxRequests: 0
+		}), []);
+	});
+	test("reply tree does not reload visited replies collection URL", async () => {
+		const repliesId = new URL("https://example.com/notes/1/replies");
+		const reply = new Note({
+			id: new URL("https://example.com/notes/2"),
+			content: "reply",
+			replies: repliesId
+		});
+		const note = new Note({
+			id: new URL("https://example.com/notes/1"),
+			replies: repliesId
+		});
+		let requests = 0;
+		const items = await collect({ documentLoader: (iri) => {
+			requests++;
+			strictEqual(iri.href, repliesId.href);
+			return Promise.resolve(new Collection({
+				id: repliesId,
+				items: [reply]
+			}));
+		} }, note, { strategies: ["reply-tree"] });
+		strictEqual(requests, 1);
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object.id?.href, reply.id?.href);
+	});
+	test("reply tree retries a replies collection after load failure", async () => {
+		const repliesId = new URL("https://example.com/replies/shared");
+		const grandchild = new Note({
+			id: new URL("https://example.com/notes/4"),
+			content: "grandchild"
+		});
+		const first = new Note({
+			id: new URL("https://example.com/notes/2"),
+			replies: repliesId
+		});
+		const second = new Note({
+			id: new URL("https://example.com/notes/3"),
+			replies: repliesId
+		});
+		const note = new Note({
+			id: new URL("https://example.com/notes/1"),
+			replies: new Collection({
+				id: new URL("https://example.com/notes/1/replies"),
+				items: [first, second]
+			})
+		});
+		let requests = 0;
+		const items = await collect({ documentLoader: (iri) => {
+			strictEqual(iri.href, repliesId.href);
+			requests++;
+			if (requests === 1) throw new Error("temporary failure");
+			return Promise.resolve(new Collection({
+				id: repliesId,
+				items: [grandchild]
+			}));
+		} }, note, { strategies: ["reply-tree"] });
+		strictEqual(requests, 2);
+		deepStrictEqual(items.map((item) => item.object.id?.href), [
+			first.id?.href,
+			second.id?.href,
+			grandchild.id?.href
+		]);
+		strictEqual(items[2].depth, 2);
+	});
+	test("reply tree skips visited reply IRIs before dereferencing", async () => {
+		const seedId = new URL("https://example.com/notes/1");
+		const siblingId = new URL("https://example.com/notes/2");
+		const sibling = new Note({
+			id: siblingId,
+			content: "sibling"
+		});
+		const note = new Note({
+			id: seedId,
+			replies: new Collection({
+				id: new URL("https://example.com/notes/1/replies"),
+				items: [seedId, siblingId]
+			})
+		});
+		const requests = [];
+		const items = await collect({ documentLoader: (iri) => {
+			requests.push(iri.href);
+			if (iri.href === siblingId.href) return Promise.resolve(sibling);
+			if (iri.href === seedId.href) throw new Error("seed should have been skipped");
+			return Promise.resolve(null);
+		} }, note, {
+			strategies: ["reply-tree"],
+			maxRequests: 1
+		});
+		deepStrictEqual(requests, [siblingId.href]);
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object.id?.href, siblingId.href);
+	});
+	test("reply tree avoids descendant cycles", async () => {
+		const seedId = new URL("https://example.com/notes/1");
+		const replyId = new URL("https://example.com/notes/2");
+		const note = new Note({ id: seedId });
+		const reply = new Note({
+			id: replyId,
+			replies: new Collection({
+				id: new URL("https://example.com/notes/2/replies"),
+				items: [note]
+			})
+		});
+		const items = await collect({ documentLoader: () => {
+			throw new Error("documentLoader should not be called");
+		} }, note.clone({ replies: new Collection({
+			id: new URL("https://example.com/notes/1/replies"),
+			items: [reply]
+		}) }), { strategies: ["reply-tree"] });
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object, reply);
+	});
+	test("context auto overrides overlapping context strategies", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const item = new Note({ content: "anonymous" });
+		const items = await collect({ documentLoader: () => Promise.resolve(new Collection({
+			id: contextId,
+			items: [item]
+		})) }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		}), { strategies: [
+			"context-objects",
+			"context-auto",
+			"reply-tree"
+		] });
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object, item);
+		strictEqual(items[0].strategy, "context-auto");
+	});
+	test("duplicate strategies are ignored", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const item = new Note({ content: "anonymous" });
+		const items = await collect({ documentLoader: () => Promise.resolve(new Collection({
+			id: contextId,
+			items: [item]
+		})) }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		}), { strategies: ["context-objects", "context-objects"] });
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object, item);
+		strictEqual(items[0].strategy, "context-objects");
+	});
+	test("context activity collection yields object from embedded Create", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const item = new Note({
+			id: new URL("https://example.com/notes/2"),
+			content: "hello"
+		});
+		const activity = new Create({
+			id: new URL("https://example.com/activities/1"),
+			object: item
+		});
+		const items = await collect({ documentLoader: () => Promise.resolve(new Collection({
+			id: contextId,
+			items: [activity]
+		})) }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		}), { strategies: ["context-activities"] });
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object, item);
+		strictEqual(items[0].id?.href, item.id?.href);
+		strictEqual(items[0].strategy, "context-activities");
+		strictEqual(items[0].origin, "collection");
+	});
+	test("combined context strategies yield posts and activity objects", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const post = new Note({ id: new URL("https://example.com/notes/2") });
+		const activityObject = new Note({ id: new URL("https://example.com/notes/3") });
+		const items = await collect({ documentLoader: () => Promise.resolve(new Collection({
+			id: contextId,
+			items: [post, new Create({
+				id: new URL("https://example.com/activities/1"),
+				object: activityObject
+			})]
+		})) }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		}), { strategies: ["context-objects", "context-activities"] });
+		strictEqual(items.length, 2);
+		strictEqual(items[0].object, post);
+		strictEqual(items[0].strategy, "context-objects");
+		strictEqual(items[1].object, activityObject);
+		strictEqual(items[1].strategy, "context-activities");
+	});
+	test("combined context strategies share context collection loading", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const post = new Note({
+			id: new URL("https://example.com/notes/2"),
+			content: "hello"
+		});
+		const activityObject = new Note({
+			id: new URL("https://example.com/notes/3"),
+			content: "activity object"
+		});
+		const activity = new Create({
+			id: new URL("https://example.com/activities/1"),
+			object: activityObject
+		});
+		const note = new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		});
+		let requests = 0;
+		const items = await collect({ documentLoader: (iri) => {
+			requests++;
+			strictEqual(iri.href, contextId.href);
+			return Promise.resolve(new Collection({
+				id: contextId,
+				items: [post, activity]
+			}));
+		} }, note, { strategies: ["context-objects", "context-activities"] });
+		strictEqual(requests, 1);
+		strictEqual(items.length, 2);
+		strictEqual(items[0].object, post);
+		strictEqual(items[1].object, activityObject);
+	});
+	test("context activity collection dereferences activity object URL", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const itemId = new URL("https://example.com/notes/2");
+		const item = new Note({
+			id: itemId,
+			content: "hello"
+		});
+		const activity = new Create({
+			id: new URL("https://example.com/activities/1"),
+			object: itemId
+		});
+		const note = new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		});
+		const requests = [];
+		const items = await collect({ documentLoader: (iri) => {
+			requests.push(iri);
+			if (iri.href === contextId.href) return Promise.resolve(new Collection({
+				id: contextId,
+				items: [activity]
+			}));
+			if (iri.href === itemId.href) return Promise.resolve(item);
+			return Promise.resolve(null);
+		} }, note, { strategies: ["context-activities"] });
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object.id?.href, item.id?.href);
+		deepStrictEqual(requests.map((url) => url.href), [contextId.href, itemId.href]);
+	});
+	test("context activity collection dereferences activity URL", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const activityId = new URL("https://example.com/activities/1");
+		const item = new Note({
+			id: new URL("https://example.com/notes/2"),
+			content: "hello"
+		});
+		const activity = new Create({
+			id: activityId,
+			object: item
+		});
+		const note = new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		});
+		const requests = [];
+		const items = await collect({ documentLoader: (iri) => {
+			requests.push(iri);
+			if (iri.href === contextId.href) return Promise.resolve(new Collection({
+				id: contextId,
+				items: [activityId]
+			}));
+			if (iri.href === activityId.href) return Promise.resolve(activity);
+			return Promise.resolve(null);
+		} }, note, { strategies: ["context-activities"] });
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object.id?.href, item.id?.href);
+		deepStrictEqual(requests.map((url) => url.href), [contextId.href, activityId.href]);
+	});
+	test("context activity collection deduplicates by extracted object ID", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const itemId = new URL("https://example.com/notes/2");
+		const first = new Create({
+			id: new URL("https://example.com/activities/1"),
+			object: new Note({
+				id: itemId,
+				content: "first"
+			})
+		});
+		const second = new Create({
+			id: new URL("https://example.com/activities/2"),
+			object: new Note({
+				id: itemId,
+				content: "second"
+			})
+		});
+		const items = await collect({ documentLoader: () => Promise.resolve(new Collection({
+			id: contextId,
+			items: [first, second]
+		})) }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		}), { strategies: ["context-activities"] });
+		strictEqual(items.length, 1);
+		strictEqual(items[0].id?.href, itemId.href);
+	});
+	test("context activity collection skips missing object", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const activity = new Create({ id: new URL("https://example.com/activities/1") });
+		deepStrictEqual(await collect({ documentLoader: () => Promise.resolve(new Collection({
+			id: contextId,
+			items: [activity]
+		})) }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		}), { strategies: ["context-activities"] }), []);
+	});
+	test("context activity collection skips unsupported activity type", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const item = new Note({ id: new URL("https://example.com/notes/2") });
+		const activity = new Announce({
+			id: new URL("https://example.com/activities/1"),
+			object: item
+		});
+		deepStrictEqual(await collect({ documentLoader: () => Promise.resolve(new Collection({
+			id: contextId,
+			items: [activity]
+		})) }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		}), { strategies: ["context-activities"] }), []);
+	});
+	test("maxRequests limits activity object dereferencing", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const activityId = new URL("https://example.com/activities/1");
+		const itemId = new URL("https://example.com/notes/2");
+		const activity = new Create({
+			id: activityId,
+			object: itemId
+		});
+		const note = new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		});
+		const requests = [];
+		deepStrictEqual(await collect({ documentLoader: (iri) => {
+			requests.push(iri);
+			if (iri.href === contextId.href) return Promise.resolve(new Collection({
+				id: contextId,
+				items: [activityId]
+			}));
+			if (iri.href === activityId.href) return Promise.resolve(activity);
+			if (iri.href === itemId.href) return Promise.resolve(new Note({ id: itemId }));
+			return Promise.resolve(null);
+		} }, note, {
+			maxRequests: 2,
+			strategies: ["context-activities"]
+		}), []);
+		deepStrictEqual(requests.map((url) => url.href), [contextId.href, activityId.href]);
+	});
+	test("maxItems limits context activity items", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const first = new Note({ id: new URL("https://example.com/notes/2") });
+		const second = new Note({ id: new URL("https://example.com/notes/3") });
+		const items = await collect({ documentLoader: () => Promise.resolve(new Collection({
+			id: contextId,
+			items: [new Create({
+				id: new URL("https://example.com/activities/1"),
+				object: first
+			}), new Create({
+				id: new URL("https://example.com/activities/2"),
+				object: second
+			})]
+		})) }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		}), {
+			maxItems: 1,
+			strategies: ["context-activities"]
+		});
+		strictEqual(items.length, 1);
+		strictEqual(items[0].id?.href, first.id?.href);
+	});
+	test("context collection with URL items loads and yields objects", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const itemId = new URL("https://example.com/notes/2");
+		const item = new Note({
+			id: itemId,
+			content: "hello"
+		});
+		const note = new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		});
+		const requests = [];
+		const items = await collect({ documentLoader: (iri) => {
+			requests.push(iri);
+			if (iri.href === contextId.href) return Promise.resolve(new Collection({
+				id: contextId,
+				items: [itemId]
+			}));
+			if (iri.href === itemId.href) return Promise.resolve(item);
+			return Promise.resolve(null);
+		} }, note);
+		strictEqual(items.length, 1);
+		ok(items[0].id instanceof URL);
+		strictEqual(items[0].id.href, itemId.href);
+		deepStrictEqual(requests.map((url) => url.href), [contextId.href, itemId.href]);
+	});
+	test("seen context collection URL items are not loaded", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const seedId = new URL("https://example.com/notes/1");
+		const itemId = new URL("https://example.com/notes/2");
+		const item = new Note({
+			id: itemId,
+			content: "hello"
+		});
+		const note = new Note({
+			id: seedId,
+			contexts: [contextId]
+		});
+		const requests = [];
+		const items = await collect({ documentLoader: (iri) => {
+			requests.push(iri);
+			if (iri.href === contextId.href) return Promise.resolve(new Collection({
+				id: contextId,
+				items: [seedId, itemId]
+			}));
+			if (iri.href === itemId.href) return Promise.resolve(item);
+			throw new Error("seen collection item should not be loaded");
+		} }, note);
+		strictEqual(items.length, 1);
+		strictEqual(items[0].id?.href, itemId.href);
+		deepStrictEqual(requests.map((url) => url.href), [contextId.href, itemId.href]);
+	});
+	test("failed URL collection items are skipped", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const missingItemId = new URL("https://example.com/notes/missing");
+		const failedItemId = new URL("https://example.com/notes/failed");
+		const itemId = new URL("https://example.com/notes/2");
+		const item = new Note({
+			id: itemId,
+			content: "hello"
+		});
+		const items = await collect({ documentLoader: (iri) => {
+			if (iri.href === contextId.href) return Promise.resolve(new Collection({
+				id: contextId,
+				items: [
+					missingItemId,
+					failedItemId,
+					itemId
+				]
+			}));
+			if (iri.href === missingItemId.href) return Promise.resolve(null);
+			if (iri.href === failedItemId.href) return Promise.reject(/* @__PURE__ */ new Error("failed to load"));
+			if (iri.href === itemId.href) return Promise.resolve(item);
+			return Promise.resolve(null);
+		} }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		}));
+		strictEqual(items.length, 1);
+		strictEqual(items[0].id?.href, itemId.href);
+	});
+	test("seed is not yielded again when present in collection", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const note = new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		});
+		const other = new Note({ id: new URL("https://example.com/notes/2") });
+		const items = await collect({ documentLoader: () => Promise.resolve(new Collection({
+			id: contextId,
+			items: [note, other]
+		})) }, note);
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object, other);
+	});
+	test("duplicate object IDs are skipped", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const duplicateId = new URL("https://example.com/notes/2");
+		const first = new Note({
+			id: duplicateId,
+			content: "first"
+		});
+		const second = new Note({
+			id: duplicateId,
+			content: "second"
+		});
+		const items = await collect({ documentLoader: () => Promise.resolve(new Collection({
+			id: contextId,
+			items: [first, second]
+		})) }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		}));
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object, first);
+	});
+	test("maxItems limits yielded items", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const items = await collect({ documentLoader: () => Promise.resolve(new Collection({
+			id: contextId,
+			items: [new Note({ id: new URL("https://example.com/notes/2") }), new Note({ id: new URL("https://example.com/notes/3") })]
+		})) }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		}), { maxItems: 1 });
+		strictEqual(items.length, 1);
+		strictEqual(items[0].id?.href, "https://example.com/notes/2");
+	});
+	test("maxItems is shared across context and reply tree", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const reply = new Note({
+			id: new URL("https://example.com/notes/3"),
+			content: "reply"
+		});
+		const note = new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId],
+			replies: new Collection({
+				id: new URL("https://example.com/notes/1/replies"),
+				items: [reply]
+			})
+		});
+		const contextItem = new Note({
+			id: new URL("https://example.com/notes/2"),
+			content: "context item"
+		});
+		const items = await collect({ documentLoader: () => Promise.resolve(new Collection({
+			id: contextId,
+			items: [contextItem]
+		})) }, note, {
+			strategies: ["context-auto", "reply-tree"],
+			maxItems: 1
+		});
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object, contextItem);
+		strictEqual(items[0].strategy, "context-auto");
+	});
+	test("maxRequests limits dereferencing", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const itemId = new URL("https://example.com/notes/2");
+		deepStrictEqual(await collect({ documentLoader: (iri) => {
+			if (iri.href === contextId.href) return Promise.resolve(new Collection({
+				id: contextId,
+				items: [itemId]
+			}));
+			return Promise.resolve(new Note({ id: iri }));
+		} }, new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		}), { maxRequests: 1 }), []);
+	});
+	test("maxRequests is shared across context and reply tree", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const parentId = new URL("https://example.com/notes/0");
+		const note = new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId],
+			replyTarget: parentId
+		});
+		const contextItem = new Note({
+			id: new URL("https://example.com/notes/2"),
+			content: "context item"
+		});
+		const items = await collect({ documentLoader: (iri) => {
+			if (iri.href === contextId.href) return Promise.resolve(new Collection({
+				id: contextId,
+				items: [contextItem]
+			}));
+			throw new Error("reply-tree request should be budgeted out");
+		} }, note, {
+			strategies: ["context-auto", "reply-tree"],
+			maxRequests: 1
+		});
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object, contextItem);
+	});
+	test("AbortSignal stops traversal", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const note = new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		});
+		const controller = new AbortController();
+		controller.abort();
+		await rejects(collect({ documentLoader: () => Promise.resolve(new Collection({
+			id: contextId,
+			items: [new Note({ id: new URL("https://example.com/notes/2") })]
+		})) }, note, { signal: controller.signal }), { name: "AbortError" });
+	});
+	test("AbortSignal stops traversal across strategies", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const parentId = new URL("https://example.com/notes/0");
+		const controller = new AbortController();
+		const note = new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId],
+			replyTarget: parentId
+		});
+		const contextItem = new Note({
+			id: new URL("https://example.com/notes/2"),
+			content: "context item"
+		});
+		let requests = 0;
+		const context = { documentLoader: (iri) => {
+			requests++;
+			if (iri.href === contextId.href) return Promise.resolve(new Collection({
+				id: contextId,
+				items: [contextItem]
+			}));
+			throw new Error("reply-tree request should not be started");
+		} };
+		const items = [];
+		await rejects(async () => {
+			for await (const item of backfill(context, note, {
+				strategies: ["context-auto", "reply-tree"],
+				signal: controller.signal
+			})) {
+				items.push(item);
+				controller.abort();
+			}
+		}, { name: "AbortError" });
+		strictEqual(requests, 1);
+		strictEqual(items.length, 1);
+		strictEqual(items[0].object, contextItem);
+	});
+	test("documentLoader receives AbortSignal", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const note = new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		});
+		const controller = new AbortController();
+		let receivedSignal;
+		await collect({ documentLoader: (_iri, options) => {
+			receivedSignal = options?.signal;
+			return Promise.resolve(new Collection({
+				id: contextId,
+				items: []
+			}));
+		} }, note, { signal: controller.signal });
+		strictEqual(receivedSignal, controller.signal);
+	});
+	test("interval callback receives zero-based request index", async () => {
+		const contextId = new URL("https://example.com/contexts/1");
+		const itemId = new URL("https://example.com/notes/2");
+		const note = new Note({
+			id: new URL("https://example.com/notes/1"),
+			contexts: [contextId]
+		});
+		const iterations = [];
+		await collect({ documentLoader: (iri) => {
+			if (iri.href === contextId.href) return Promise.resolve(new Collection({
+				id: contextId,
+				items: [itemId]
+			}));
+			return Promise.resolve(new Note({ id: iri }));
+		} }, note, { interval: (iteration) => {
+			iterations.push(iteration);
+			return { milliseconds: 0 };
+		} });
+		deepStrictEqual(iterations, [0, 1]);
+	});
+});
+//#endregion
+export {};