@sdxc/activitypub 0.0.0-pre.1

package/dist/lib/compact.js

@@ -0,0 +1,514 @@
+import { createIssue, createSchema, fail } from "remix/data-schema";
+import { PUBLIC } from "./constants.js";
+/** The compact spellings senders use for the public collection, besides the full IRI. */
+const PUBLIC_ALIASES = new Set(["as:Public", "Public", PUBLIC]);
+/** The attachment types that carry a file; Mastodon sends `Document`, others the specific type. */
+const MEDIA_TYPES = new Set(["Document", "Image", "Video", "Audio"]);
+/**
+ * Whether a decoded value is a plain JSON object.
+ *
+ * @param value - Any decoded JSON value.
+ */
+export function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Runs a schema on a member, so its issues point at that member.
+ *
+ * @param schema - The member's schema.
+ * @param value - The member's value.
+ * @param context - The enclosing value's context.
+ * @param key - The member name or array index.
+ * @template Output - What the schema produces.
+ */
+export function runAt(schema, value, context, key) {
+    let result = schema["~run"](value, { path: [...context.path, key], options: context.options });
+    if (result.issues !== undefined)
+        return { issues: result.issues };
+    return { value: result.value };
+}
+/**
+ * The public collection's IRI for any spelling of it; every other IRI unchanged.
+ *
+ * @param iri - An addressing entry.
+ */
+export function normalizePublic(iri) {
+    return PUBLIC_ALIASES.has(iri) ? PUBLIC : iri;
+}
+/**
+ * The values of a member that may be a single value or an array, as an array.
+ *
+ * @param value - The member's value; `undefined` and `null` read as empty.
+ */
+function many(value) {
+    if (value === undefined || value === null)
+        return [];
+    return Array.isArray(value) ? value : [value];
+}
+/**
+ * The IRI an entry names: itself when a string, its `id` when an embedded object, or its
+ * `href` when a `Link`.
+ *
+ * @param value - An IRI, an embedded object, or a Link.
+ */
+function iriOf(value) {
+    if (typeof value === "string")
+        return value;
+    if (!isObject(value))
+        return null;
+    if (typeof value.id === "string")
+        return value.id;
+    if (typeof value.href === "string")
+        return value.href;
+    return null;
+}
+/**
+ * An absolute IRI, which a document's `id` must be: every ownership check compares its
+ * origin, and a relative one has none.
+ *
+ * @param label - The member, for the message.
+ */
+export function absoluteIri(label) {
+    return createSchema((value, context) => {
+        if (typeof value !== "string")
+            return fail(`"${label}" must be a string IRI.`, context.path);
+        if (!URL.canParse(value))
+            return fail(`"${label}" must be an absolute IRI.`, context.path);
+        return { value };
+    });
+}
+/**
+ * An absolute IRI that may be absent, `null` then.
+ *
+ * @param label - The member, for the message.
+ */
+export function optionalAbsoluteIri(label) {
+    let required = absoluteIri(label);
+    return createSchema((value, context) => {
+        if (value === undefined || value === null)
+            return { value: null };
+        return required["~run"](value, context);
+    });
+}
+/**
+ * A `type` sent as a string or an array, read as one name: the first a caller knows,
+ * else the first listed. An `as:` prefix is dropped, since it names the same term.
+ *
+ * @param known - Type names to prefer when several are listed.
+ */
+export function documentType(known) {
+    return createSchema((value, context) => {
+        let names = many(value)
+            .filter((entry) => typeof entry === "string")
+            .map((name) => (name.startsWith("as:") ? name.slice(3) : name));
+        let first = names.find((name) => known.has(name)) ?? names[0];
+        if (first === undefined)
+            return fail('"type" must name the document\'s type.', context.path);
+        return { value: first };
+    });
+}
+/**
+ * A list of IRIs sent as one entry or an array, each an IRI or an embedded object, read
+ * as the IRIs alone. With `addressing`, every spelling of the public collection reads
+ * as `PUBLIC`.
+ *
+ * @param options - Whether the list addresses an audience.
+ */
+export function iris(options = {}) {
+    return createSchema((value, context) => {
+        let issues = [];
+        let result = [];
+        let entries = many(value);
+        for (let [index, entry] of entries.entries()) {
+            let iri = iriOf(entry);
+            if (iri === null) {
+                let at = Array.isArray(value) ? [...context.path, index] : context.path;
+                issues.push(createIssue("An entry must be an IRI or an object with an id.", at));
+                continue;
+            }
+            result.push(options.addressing ? normalizePublic(iri) : iri);
+        }
+        if (issues.length > 0)
+            return { issues };
+        return { value: result };
+    });
+}
+export function iri(options = {}) {
+    return createSchema((value, context) => {
+        let entries = many(value);
+        if (entries.length === 0) {
+            if (!options.required)
+                return { value: null };
+            return fail(`"${options.label ?? "member"}" is required.`, context.path);
+        }
+        let first = iriOf(entries[0]);
+        if (first === null) {
+            return fail("The reference must be an IRI or an object with an id.", context.path);
+        }
+        return { value: first };
+    });
+}
+/** Text that may be absent: a string, or `null` when absent. */
+export function text() {
+    return createSchema((value, context) => {
+        if (value === undefined || value === null)
+            return { value: null };
+        if (typeof value !== "string")
+            return fail("The value must be a string.", context.path);
+        return { value };
+    });
+}
+/** A language map (`contentMap`, `nameMap`, `summaryMap`), empty when absent. */
+export function languageMap() {
+    return createSchema((value, context) => {
+        if (value === undefined || value === null)
+            return { value: {} };
+        if (!isObject(value))
+            return fail("A language map must be an object.", context.path);
+        let issues = [];
+        let result = {};
+        for (let [language, entry] of Object.entries(value)) {
+            if (typeof entry === "string")
+                result[language] = entry;
+            else
+                issues.push(createIssue("A language map value must be a string.", [...context.path, language]));
+        }
+        if (issues.length > 0)
+            return { issues };
+        return { value: result };
+    });
+}
+/**
+ * The plain value of a text member, falling back to the first entry of its language map
+ * when a sender sent only the map.
+ *
+ * @param plain - The plain value.
+ * @param map - The language map.
+ */
+export function withMapFallback(plain, map) {
+    if (plain !== null)
+        return plain;
+    return Object.values(map)[0] ?? null;
+}
+/**
+ * The links a `url` member offers, each with its media type when the sender gave one.
+ *
+ * @param value - A string, a `Link`, or an array of either.
+ */
+function linksOf(value) {
+    let links = [];
+    for (let entry of many(value)) {
+        if (typeof entry === "string")
+            links.push({ href: entry, mediaType: null });
+        else if (isObject(entry) && typeof entry.href === "string") {
+            let mediaType = typeof entry.mediaType === "string" ? entry.mediaType : null;
+            links.push({ href: entry.href, mediaType });
+        }
+    }
+    return links;
+}
+/**
+ * A `url` sent as a string, a `Link` or an array of them, read as the page a person
+ * opens: the first `text/html` link, else the first link. A member that names no link
+ * at all reads as `null`.
+ */
+export function htmlUrl() {
+    return createSchema((value, context) => {
+        if (value === undefined || value === null)
+            return { value: null };
+        if (typeof value !== "string" && typeof value !== "object") {
+            return fail('"url" must be a string, a Link or an array of them.', context.path);
+        }
+        let links = linksOf(value);
+        let html = links.find((link) => link.mediaType?.split(";")[0]?.trim() === "text/html");
+        return { value: (html ?? links[0])?.href ?? null };
+    });
+}
+/** An ISO 8601 date, `null` when absent. */
+export function date() {
+    return createSchema((value, context) => {
+        if (value === undefined || value === null)
+            return { value: null };
+        if (typeof value !== "string")
+            return fail("A date must be an ISO 8601 string.", context.path);
+        let parsed = new Date(value);
+        if (Number.isNaN(parsed.getTime()))
+            return fail("The date is not valid.", context.path);
+        return { value: parsed };
+    });
+}
+/** A boolean flag, `false` when absent. */
+export function flag() {
+    return createSchema((value, context) => {
+        if (value === undefined || value === null)
+            return { value: false };
+        if (typeof value !== "boolean")
+            return fail("The flag must be a boolean.", context.path);
+        return { value };
+    });
+}
+/** A count such as `totalItems`, `null` when absent. */
+export function count() {
+    return createSchema((value, context) => {
+        if (value === undefined || value === null)
+            return { value: null };
+        if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+            return fail("A count must be a non-negative integer.", context.path);
+        }
+        return { value };
+    });
+}
+/**
+ * A string member of an embedded object, or `null`.
+ *
+ * @param body - The embedded object.
+ * @param member - The member name.
+ */
+function stringOf(body, member) {
+    let value = body[member];
+    return typeof value === "string" ? value : null;
+}
+/**
+ * A positive integer member of an embedded object, or `null`.
+ *
+ * @param body - The embedded object.
+ * @param member - The member name.
+ */
+function dimensionOf(body, member) {
+    let value = body[member];
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+/**
+ * A date member of an embedded object, or `null` when absent or invalid.
+ *
+ * @param body - The embedded object.
+ * @param member - The member name.
+ */
+function dateOf(body, member) {
+    let value = body[member];
+    if (typeof value !== "string")
+        return null;
+    let parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+/**
+ * The type names an embedded value lists, `as:` prefixes dropped.
+ *
+ * @param body - The embedded object.
+ */
+function typesOf(body) {
+    return many(body.type)
+        .filter((entry) => typeof entry === "string")
+        .map((name) => (name.startsWith("as:") ? name.slice(3) : name));
+}
+/**
+ * An image sent as a string URL or an `Image` object (or an array of them), read as an
+ * `Image`. A value that names no URL reads as `null`.
+ *
+ * @param value - The member's value.
+ */
+export function readImage(value) {
+    for (let entry of many(value)) {
+        if (typeof entry === "string")
+            return { type: "Image", url: entry, mediaType: null };
+        if (!isObject(entry))
+            continue;
+        let link = linksOf(entry.url)[0];
+        if (link === undefined)
+            continue;
+        let mediaType = stringOf(entry, "mediaType") ?? link.mediaType;
+        return { type: "Image", url: link.href, mediaType };
+    }
+    return null;
+}
+/** An `icon` or `image`, `null` when absent or naming no URL. */
+export function image() {
+    return createSchema((value) => ({ value: readImage(value) }));
+}
+/**
+ * One `tag` entry, or `null` for a type this package does not model or an entry that
+ * lacks what its type requires.
+ *
+ * @param entry - The decoded entry.
+ */
+function readTag(entry) {
+    if (!isObject(entry))
+        return null;
+    let types = typesOf(entry);
+    if (types.includes("Hashtag")) {
+        let name = stringOf(entry, "name");
+        if (name === null)
+            return null;
+        return { type: "Hashtag", name, href: stringOf(entry, "href") };
+    }
+    if (types.includes("Mention")) {
+        let href = stringOf(entry, "href");
+        if (href === null)
+            return null;
+        return { type: "Mention", href, name: stringOf(entry, "name") };
+    }
+    if (types.includes("Emoji")) {
+        let name = stringOf(entry, "name");
+        let icon = readImage(entry.icon);
+        if (name === null || icon === null)
+            return null;
+        return {
+            type: "Emoji",
+            id: stringOf(entry, "id"),
+            name,
+            icon,
+            updated: dateOf(entry, "updated"),
+        };
+    }
+    return null;
+}
+/**
+ * `tag` entries this package models: hashtags, mentions and custom emoji. Entries of
+ * other types, and entries missing what their type requires, are dropped, since a tag
+ * decorates an object and never decides whether it can be read.
+ */
+export function tags() {
+    return createSchema((value) => ({
+        value: many(value)
+            .map(readTag)
+            .filter((tag) => tag !== null),
+    }));
+}
+/**
+ * A `focalPoint` as two finite coordinates, or `null`.
+ *
+ * @param value - The decoded member.
+ */
+function focalPointOf(value) {
+    if (!Array.isArray(value) || value.length !== 2)
+        return null;
+    let [x, y] = value;
+    if (typeof x !== "number" || typeof y !== "number")
+        return null;
+    if (!Number.isFinite(x) || !Number.isFinite(y))
+        return null;
+    return [x, y];
+}
+/**
+ * One `attachment` entry, or `null` for a type this package does not model or an entry
+ * that lacks what its type requires.
+ *
+ * @param entry - The decoded entry.
+ */
+function readAttachment(entry) {
+    if (!isObject(entry))
+        return null;
+    let types = typesOf(entry);
+    if (types.includes("PropertyValue")) {
+        let name = stringOf(entry, "name");
+        let value = stringOf(entry, "value");
+        if (name === null || value === null)
+            return null;
+        return { type: "PropertyValue", name, value };
+    }
+    let type = types.find((name) => MEDIA_TYPES.has(name));
+    if (type === undefined)
+        return null;
+    let links = linksOf(entry.url);
+    let link = links[0];
+    if (link === undefined)
+        return null;
+    return {
+        type,
+        url: link.href,
+        mediaType: stringOf(entry, "mediaType") ?? link.mediaType,
+        name: stringOf(entry, "name"),
+        blurhash: stringOf(entry, "blurhash"),
+        width: dimensionOf(entry, "width"),
+        height: dimensionOf(entry, "height"),
+        focalPoint: focalPointOf(entry.focalPoint),
+    };
+}
+/**
+ * `attachment` entries this package models: media files and profile fields. Other
+ * entries are dropped, for the same reason as tags.
+ */
+export function attachments() {
+    return createSchema((value) => ({
+        value: many(value)
+            .map(readAttachment)
+            .filter((attachment) => attachment !== null),
+    }));
+}
+/**
+ * FEP-8b32 proofs, sent as one object or a set. An entry that is not a complete
+ * `DataIntegrityProof` is dropped, so verification treats the document as unproven.
+ */
+export function proofs() {
+    return createSchema((value) => {
+        let result = [];
+        for (let entry of many(value)) {
+            if (!isObject(entry) || !typesOf(entry).includes("DataIntegrityProof"))
+                continue;
+            let cryptosuite = stringOf(entry, "cryptosuite");
+            let verificationMethod = iriOf(entry.verificationMethod);
+            let proofPurpose = stringOf(entry, "proofPurpose");
+            let proofValue = stringOf(entry, "proofValue");
+            if (!cryptosuite || !verificationMethod || !proofPurpose || !proofValue)
+                continue;
+            result.push({
+                type: "DataIntegrityProof",
+                cryptosuite,
+                verificationMethod,
+                proofPurpose,
+                proofValue,
+                created: dateOf(entry, "created"),
+            });
+        }
+        return { value: result };
+    });
+}
+/** FEP-521a `Multikey` entries of `assertionMethod`; other verification methods are dropped. */
+export function multikeys() {
+    return createSchema((value) => {
+        let result = [];
+        for (let entry of many(value)) {
+            if (!isObject(entry) || !typesOf(entry).includes("Multikey"))
+                continue;
+            let id = stringOf(entry, "id");
+            let controller = stringOf(entry, "controller");
+            let publicKeyMultibase = stringOf(entry, "publicKeyMultibase");
+            if (!id || !controller || !publicKeyMultibase)
+                continue;
+            result.push({ id, type: "Multikey", controller, publicKeyMultibase });
+        }
+        return { value: result };
+    });
+}
+/**
+ * An actor's `publicKey`, sent as one object or an array whose first complete entry is
+ * read. A key present but missing `id`, `owner` or `publicKeyPem` fails, since no
+ * signature from the actor could verify against it.
+ */
+export function publicKey() {
+    return createSchema((value, context) => {
+        let entries = many(value);
+        if (entries.length === 0)
+            return { value: null };
+        for (let entry of entries) {
+            if (!isObject(entry))
+                continue;
+            let id = stringOf(entry, "id");
+            let owner = iriOf(entry.owner);
+            let publicKeyPem = stringOf(entry, "publicKeyPem");
+            if (id && owner && publicKeyPem)
+                return { value: { id, owner, publicKeyPem } };
+        }
+        return fail('"publicKey" must have an id, an owner and a publicKeyPem.', context.path);
+    });
+}
+/** An actor's `endpoints`, whose `sharedInbox` is `null` when absent. */
+export function endpoints() {
+    return createSchema((value, context) => {
+        if (value === undefined || value === null)
+            return { value: { sharedInbox: null } };
+        if (!isObject(value))
+            return fail('"endpoints" must be an object.', context.path);
+        return { value: { sharedInbox: iriOf(value.sharedInbox) } };
+    });
+}

package/dist/lib/constants.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The fixed IRIs and media types ActivityPub documents are read and written with: the
+ * public collection, the JSON-LD contexts `stringify` writes, and the AS2 media types
+ * content negotiation and delivery name.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+/**
+ * The special collection that makes an object public. Addressed in `to` it is a public
+ * post; in `cc` alone, an unlisted one. Every compact spelling reads as this IRI.
+ */
+export declare const PUBLIC = "https://www.w3.org/ns/activitystreams#Public";
+/** The normative ActivityStreams 2.0 context, which every document is read against. */
+export declare const AS2_CONTEXT = "https://www.w3.org/ns/activitystreams";
+/** Defines `publicKey`, `owner` and `publicKeyPem`, which Mastodon reads from an actor. */
+export declare const SECURITY_CONTEXT = "https://w3id.org/security/v1";
+/** Defines `DataIntegrityProof` (FEP-8b32), written only when a document carries a proof. */
+export declare const DATA_INTEGRITY_CONTEXT = "https://w3id.org/security/data-integrity/v1";
+/** Defines `Multikey` (FEP-521a), written only when an actor lists `assertionMethod` keys. */
+export declare const MULTIKEY_CONTEXT = "https://w3id.org/security/multikey/v1";
+/** The media type ActivityPub servers serve and accept, as ActivityPub §3.2 recommends. */
+export declare const ACTIVITY_JSON = "application/activity+json";
+/** The JSON-LD media type ActivityPub §3.2 requires a server to treat as `ACTIVITY_JSON`. */
+export declare const LD_JSON = "application/ld+json";
+/** The JSON-LD form with the AS2 profile, as a client sends it in `Accept`. */
+export declare const LD_JSON_ACTIVITY = "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"";
+/** The `Content-Type` every document this package serves is answered with. */
+export declare const ACTIVITY_CONTENT_TYPE = "application/activity+json; charset=utf-8";
+/** The `Accept` a client sends to ask a server for the AS2 representation of a URL. */
+export declare const ACTIVITY_ACCEPT = "application/activity+json, application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"";
+/** The ActivityStreams 2.0 activity types, plus `EmojiReact`, which Pleroma and Akkoma send. */
+export declare const ACTIVITY_TYPES: readonly ["Accept", "Add", "Announce", "Arrive", "Block", "Create", "Delete", "Dislike", "EmojiReact", "Flag", "Follow", "Ignore", "Invite", "Join", "Leave", "Like", "Listen", "Move", "Offer", "Question", "Read", "Reject", "Remove", "TentativeAccept", "TentativeReject", "Travel", "Undo", "Update", "View"];
+/** The ActivityStreams 2.0 actor types. */
+export declare const ACTOR_TYPES: readonly ["Application", "Group", "Organization", "Person", "Service"];

package/dist/lib/constants.js

@@ -0,0 +1,65 @@
+/**
+ * The fixed IRIs and media types ActivityPub documents are read and written with: the
+ * public collection, the JSON-LD contexts `stringify` writes, and the AS2 media types
+ * content negotiation and delivery name.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+/**
+ * The special collection that makes an object public. Addressed in `to` it is a public
+ * post; in `cc` alone, an unlisted one. Every compact spelling reads as this IRI.
+ */
+export const PUBLIC = "https://www.w3.org/ns/activitystreams#Public";
+/** The normative ActivityStreams 2.0 context, which every document is read against. */
+export const AS2_CONTEXT = "https://www.w3.org/ns/activitystreams";
+/** Defines `publicKey`, `owner` and `publicKeyPem`, which Mastodon reads from an actor. */
+export const SECURITY_CONTEXT = "https://w3id.org/security/v1";
+/** Defines `DataIntegrityProof` (FEP-8b32), written only when a document carries a proof. */
+export const DATA_INTEGRITY_CONTEXT = "https://w3id.org/security/data-integrity/v1";
+/** Defines `Multikey` (FEP-521a), written only when an actor lists `assertionMethod` keys. */
+export const MULTIKEY_CONTEXT = "https://w3id.org/security/multikey/v1";
+/** The media type ActivityPub servers serve and accept, as ActivityPub §3.2 recommends. */
+export const ACTIVITY_JSON = "application/activity+json";
+/** The JSON-LD media type ActivityPub §3.2 requires a server to treat as `ACTIVITY_JSON`. */
+export const LD_JSON = "application/ld+json";
+/** The JSON-LD form with the AS2 profile, as a client sends it in `Accept`. */
+export const LD_JSON_ACTIVITY = `${LD_JSON}; profile="${AS2_CONTEXT}"`;
+/** The `Content-Type` every document this package serves is answered with. */
+export const ACTIVITY_CONTENT_TYPE = `${ACTIVITY_JSON}; charset=utf-8`;
+/** The `Accept` a client sends to ask a server for the AS2 representation of a URL. */
+export const ACTIVITY_ACCEPT = `${ACTIVITY_JSON}, ${LD_JSON_ACTIVITY}`;
+/** The ActivityStreams 2.0 activity types, plus `EmojiReact`, which Pleroma and Akkoma send. */
+export const ACTIVITY_TYPES = [
+    "Accept",
+    "Add",
+    "Announce",
+    "Arrive",
+    "Block",
+    "Create",
+    "Delete",
+    "Dislike",
+    "EmojiReact",
+    "Flag",
+    "Follow",
+    "Ignore",
+    "Invite",
+    "Join",
+    "Leave",
+    "Like",
+    "Listen",
+    "Move",
+    "Offer",
+    "Question",
+    "Read",
+    "Reject",
+    "Remove",
+    "TentativeAccept",
+    "TentativeReject",
+    "Travel",
+    "Undo",
+    "Update",
+    "View",
+];
+/** The ActivityStreams 2.0 actor types. */
+export const ACTOR_TYPES = ["Application", "Group", "Organization", "Person", "Service"];

package/dist/lib/delivery-fan-out.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Works out where one activity goes: the local actor's followers, paged from the store,
+ * and every other addressed actor, resolved to its inbox. Targets are deduplicated by URL,
+ * blocked and unavailable servers skipped, and deliveries enqueued in batches.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import type { Cache } from "@sdxc/cache";
+import type { Result } from "@sdxc/result";
+import type { Resolver } from "../remote.js";
+import type { FollowerStore } from "../store.js";
+import { ActivityPubError } from "../errors.js";
+import type { DeliveryInput } from "./delivery-post.js";
+import type { BlockedCheck } from "./inbox-receive.js";
+import type { ActivityPub } from "./types.js";
+/** Leaves room for the inbox, the actor and the job envelope inside a 128 KB queue message. */
+export declare const MAX_ACTIVITY_BYTES: number;
+/** One fan-out: the local actor sending and the activity as JSON text. */
+export interface FanOutInput {
+    /** The local actor whose followers receive the activity and whose keys sign it. */
+    actor: string;
+    /** The activity as JSON text; `bto` and `bcc` are read for addressing and stripped. */
+    activity: string;
+}
+/** Why a fan-out failed: `store` and `enqueue` are retryable, the rest repeat on a retry. */
+export type FanOutErrorCode = "invalid-input" | "invalid-document" | "too-large" | "store" | "enqueue";
+/** What `fanOut` needs. */
+export interface FanOutOptions {
+    /** The sending actor's document: its `followers` IRI is what addressing names to reach them. */
+    actor: Pick<ActivityPub.Actor, "id" | "followers">;
+    followers: FollowerStore;
+    /** Resolves every other addressed actor to its inbox. */
+    resolver: Pick<Resolver, "actor">;
+    /** Called once per host; a blocked host receives nothing and its actors are never fetched. */
+    blocked: BlockedCheck;
+    /** Where `deliver` keeps each origin's failure window. */
+    cache: Cache;
+    /**
+     * Writes one batch of delivery jobs, of any total size; a failure or rejection fails the
+     * fan-out as retryable.
+     */
+    enqueue: (deliveries: DeliveryInput[]) => Promise<Result<void, Error> | void>;
+    /** Followers' inboxes read per store page, and the most deliveries per batch. @default 100 */
+    pageSize?: number;
+    /** The clock origin failure windows are measured against. @default () => new Date() */
+    now?: () => Date;
+}
+/** What a fan-out planned. */
+export interface FanOutResult {
+    /** Deliveries enqueued, one per distinct inbox URL. */
+    inboxes: number;
+    /** Targets left out: blocked hosts, unavailable origins, and actors that would not resolve. */
+    skipped: number;
+}
+/**
+ * Enqueues one delivery per distinct inbox the activity is addressed to. The sender's
+ * followers collection in `to`, `cc`, `bto` or `bcc` (of the activity or its embedded
+ * object) pages through `FollowerStore.inboxes`; every other IRI except `PUBLIC` resolves
+ * to its actor's `sharedInbox ?? inbox`, and one that fails to resolve is skipped and
+ * counted, so one unreachable mention never holds back delivery to every follower.
+ *
+ * A batch closes at `pageSize` deliveries. A retried fan-out may enqueue some deliveries
+ * twice, which receivers absorb by activity id.
+ *
+ * @param input - The sending actor and the activity.
+ * @param options - The stores, the moderation callback and the job writer.
+ * @returns The counts, or `too-large` for an activity over 120 KB, `invalid-document`
+ *   for one that does not parse, or a retryable `store` or `enqueue` failure.
+ * @example let planned = await fanOut(ctx.input, { actor: ACTOR, followers, resolver, blocked, cache, enqueue });
+ */
+export declare function fanOut(input: FanOutInput, options: FanOutOptions): Promise<Result<FanOutResult, ActivityPubError<FanOutErrorCode>>>;