@dsbot-channel/p2p 0.0.0-stage → 0.7.1

package/dist/p2p-mapping.js

@@ -0,0 +1,80 @@
+import { buildEvent } from '@dsbot-channel/core/event-build.js';
+/** How much of the message being answered travels back with the reply. */
+export const EXCERPT_CHARS = 200;
+/** How much of a peer's own text reaches a line of ours. */
+export const PEER_TEXT_MAX = 200;
+/** How much of a wire name one log line keeps, escapes included. */
+export const LOG_NAME_MAX = 64;
+function logChar(char) {
+    const code = char.codePointAt(0) ?? 0;
+    if (code < 0x20 || (code >= 0x7f && code <= 0x9f) || code === 0x2028 || code === 0x2029) {
+        return `\\u${code.toString(16).padStart(4, '0')}`;
+    }
+    return char;
+}
+/** A wire name as one log-safe literal: control characters escaped, length bounded. */
+export function logName(value) {
+    let out = '';
+    for (const char of value) {
+        const piece = logChar(char);
+        if (out.length + piece.length > LOG_NAME_MAX - 1)
+            return `${out}…`;
+        out += piece;
+    }
+    return out;
+}
+function flatten(text) {
+    let out = '';
+    for (const char of text) {
+        const code = char.codePointAt(0) ?? 0;
+        out += code < 0x20 || code === 0x7f ? ' ' : char;
+    }
+    return out;
+}
+/** A peer's own words for a line of ours: one line, bounded, nothing that breaks the line. */
+export function oneLine(text, limit = PEER_TEXT_MAX) {
+    const flat = flatten(typeof text === 'string' ? text : String(text ?? '')).replace(/\s+/g, ' ').trim();
+    return Array.from(flat).slice(0, limit).join('').trim();
+}
+/** Keeps a peer from shaping the header: no control characters, one line, no quotes. */
+export function cleanExcerpt(text, limit = EXCERPT_CHARS) {
+    const flat = flatten(text)
+        .replace(/["'`]+/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return Array.from(flat).slice(0, limit).join('').trim();
+}
+/** Maps a peer message onto the event model with the peer identity as the source. */
+export function toP2PEvent(inbound) {
+    const text = inbound.body;
+    return buildEvent({
+        source: { kind: 'p2p', instance: inbound.instance, peer: inbound.instance, scope: 'p2p' },
+        author: { senderId: inbound.sender, kind: 'bot', personId: null },
+        body: {
+            text,
+            media: (inbound.media ?? []).map(([type, url, name]) => ({
+                type: type,
+                url,
+                handle: null,
+                ...(name === undefined ? {} : { name }),
+            })),
+            replyTo: inbound.inReplyTo ?? null,
+        },
+        transport: {
+            messageId: inbound.messageId,
+            timestamp: inbound.sentAt,
+            mentioned: { self: false, others: false, all: false },
+            isReply: inbound.inReplyTo !== undefined,
+            signature: null,
+        },
+        declared: { nickname: '', avatar: '' },
+        adapter: {
+            sentAt: inbound.sentAt,
+            ...(inbound.inReplyTo === undefined ? {} : { inReplyTo: inbound.inReplyTo }),
+            ...(inbound.inReplyToExcerpt === undefined ? {} : { inReplyToExcerpt: cleanExcerpt(inbound.inReplyToExcerpt) }),
+            ...(inbound.status === undefined ? {} : { status: inbound.status }),
+            ...(inbound.reason === undefined ? {} : { reason: inbound.reason }),
+            ...(inbound.final === undefined ? {} : { final: inbound.final }),
+        },
+    });
+}

package/dist/p2p-protocol.d.ts

@@ -0,0 +1,94 @@
+import type { CredentialsLike, PeerRef } from './p2p-secrets.js';
+import type { DedupeTable } from './p2p-dedupe.js';
+import type { ChannelStats } from '@dsbot-channel/core/channel-stats.js';
+import type { P2PMediaItem } from './p2p-wire.js';
+export declare const P2P_ROUTE = "/p2p/v1/message";
+export declare const MAX_BODY_BYTES: number;
+export declare const DEFAULT_SENT_AT_WINDOW_MS = 300000;
+/** The reference is a token, not free text: it lands in a header line. */
+export declare const IN_REPLY_TO_MAX = 128;
+/** An event id is a token the adapter builds; a reply's own id stays this short. */
+export declare const EVENT_ID_MAX = 256;
+/** A chain root is an event id, so it gets the same room. */
+export declare const CHAIN_ID_MAX = 256;
+export declare const MEDIA_MAX_ITEMS = 16;
+export declare const MEDIA_URL_MAX = 2048;
+export declare const MEDIA_TOTAL_MAX: number;
+export interface P2PConfig {
+    botName: string;
+    peers: readonly PeerRef[];
+    credentials: CredentialsLike;
+    inflightTtlMs: number;
+    maxBodyBytes: number;
+    waitMs?: number;
+    sentAtWindowMs?: number;
+    now?: () => number;
+    warn?: (message: string) => void;
+}
+export interface P2PPayload {
+    eventId?: unknown;
+    to?: unknown;
+    sender?: unknown;
+    instance?: unknown;
+    body?: unknown;
+    media?: unknown;
+    sentAt?: unknown;
+    [key: string]: unknown;
+}
+export interface AuthHeader {
+    signature?: string | null;
+    claimedInstance: string;
+}
+export declare const DECLINED = "declined";
+export interface ParsedMessage {
+    eventId: string;
+    chainId: string;
+    to: string;
+    sender: string;
+    instance: string;
+    body: string;
+    media: readonly P2PMediaItem[];
+    sentAt: number;
+    status?: typeof DECLINED;
+    reason?: string;
+    final?: boolean;
+    inReplyTo?: string;
+    inReplyToExcerpt?: string;
+}
+export type Parsed = {
+    ok: true;
+    value: ParsedMessage;
+} | {
+    ok: false;
+    status: 400 | 401 | 413;
+    reason: string;
+    protocolMismatch?: boolean;
+};
+export declare function parseRequest(payload: P2PPayload, maxBodyBytes?: number): Parsed;
+export interface HandleInput {
+    config: P2PConfig;
+    table: DedupeTable;
+    auth: AuthHeader;
+    payload: P2PPayload;
+    process?: (eventId: string) => Promise<boolean>;
+    stats?: ChannelStats | undefined;
+}
+export type HandleResult = {
+    ok: true;
+    status: 200;
+    body: {
+        duplicate: boolean;
+        messageId: string;
+        eventId: string;
+    };
+} | {
+    ok: false;
+    status: 400 | 401 | 403 | 413 | 503;
+    body: {
+        error: string;
+        code?: string;
+        sentAt?: number;
+        now?: number;
+    };
+};
+export declare function handleMessage(input: HandleInput): Promise<HandleResult>;

package/dist/p2p-protocol.js

@@ -0,0 +1,229 @@
+import { verifyRequest } from './p2p-auth.js';
+import { SecretRefError, resolvePeers } from './p2p-secrets.js';
+import { EXCERPT_CHARS, logName } from './p2p-mapping.js';
+import { MEDIA_TYPES, mediaNameProblem } from '@dsbot-channel/core/event-types.js';
+export const P2P_ROUTE = '/p2p/v1/message';
+export const MAX_BODY_BYTES = 64 * 1024;
+export const DEFAULT_SENT_AT_WINDOW_MS = 300_000;
+/** The reference is a token, not free text: it lands in a header line. */
+export const IN_REPLY_TO_MAX = 128;
+/** An event id is a token the adapter builds; a reply's own id stays this short. */
+export const EVENT_ID_MAX = 256;
+/** A chain root is an event id, so it gets the same room. */
+export const CHAIN_ID_MAX = 256;
+export const MEDIA_MAX_ITEMS = 16;
+export const MEDIA_URL_MAX = 2048;
+export const MEDIA_TOTAL_MAX = 8 * 1024;
+function isToken(text) {
+    for (const char of text) {
+        const code = char.codePointAt(0) ?? 0;
+        if (code < 0x21 || code > 0x7e)
+            return false;
+    }
+    return true;
+}
+export const DECLINED = 'declined';
+export function parseRequest(payload, maxBodyBytes = MAX_BODY_BYTES) {
+    const { eventId, to, sender, instance, body, sentAt } = payload;
+    const parsed = parseMedia(payload.media);
+    if (!parsed.ok)
+        return { ok: false, status: 400, reason: parsed.reason };
+    // An empty body is accepted only when the request carries media; a message with neither is refused.
+    const carriesMedia = parsed.value.length > 0;
+    for (const [name, value] of Object.entries({ eventId, to, sender, instance, body })) {
+        if (name === 'body' && carriesMedia && typeof value === 'string')
+            continue;
+        if (typeof value !== 'string' || value.length === 0)
+            return { ok: false, status: 400, reason: `${name} must be a non-empty string` };
+    }
+    if (typeof sentAt !== 'number' || !Number.isFinite(sentAt))
+        return { ok: false, status: 400, reason: 'sentAt must be a number' };
+    if (eventId.length > EVENT_ID_MAX || !isToken(eventId)) {
+        return { ok: false, status: 400, reason: `eventId must be a token of at most ${EVENT_ID_MAX} characters` };
+    }
+    if (!isToken(sender)) {
+        return { ok: false, status: 400, reason: 'sender must be a token: printable characters, no whitespace' };
+    }
+    const text = typeof body === 'string' ? body : '';
+    if (Buffer.byteLength(text, 'utf8') > maxBodyBytes)
+        return { ok: false, status: 413, reason: 'body exceeds the size limit' };
+    const status = payload.status;
+    if (status !== undefined && status !== DECLINED) {
+        return { ok: false, status: 400, reason: `status must be "${DECLINED}" when it is present` };
+    }
+    const reason = payload.reason;
+    if (reason !== undefined && typeof reason !== 'string')
+        return { ok: false, status: 400, reason: 'reason must be a string' };
+    const final = payload.final;
+    if (final !== undefined && typeof final !== 'boolean')
+        return { ok: false, status: 400, reason: 'final must be a boolean' };
+    const chainId = payload.chainId;
+    if (chainId === undefined) {
+        return {
+            ok: false,
+            status: 401,
+            reason: 'chainId is required: this peer speaks the chain-root protocol',
+            protocolMismatch: true,
+        };
+    }
+    if (typeof chainId !== 'string' || !isToken(chainId) || chainId.length > CHAIN_ID_MAX) {
+        return { ok: false, status: 400, reason: `chainId must be a token of at most ${CHAIN_ID_MAX} characters` };
+    }
+    const inReplyTo = payload.inReplyTo;
+    if (inReplyTo !== undefined) {
+        if (typeof inReplyTo !== 'string' || inReplyTo.length === 0 || inReplyTo.length > IN_REPLY_TO_MAX || !isToken(inReplyTo)) {
+            return { ok: false, status: 400, reason: `inReplyTo must be a token of at most ${IN_REPLY_TO_MAX} characters` };
+        }
+    }
+    const rawExcerpt = payload.inReplyToExcerpt;
+    if (rawExcerpt !== undefined && typeof rawExcerpt !== 'string') {
+        return { ok: false, status: 400, reason: 'inReplyToExcerpt must be a string' };
+    }
+    const inReplyToExcerpt = rawExcerpt === undefined ? undefined : Array.from(rawExcerpt).slice(0, EXCERPT_CHARS).join('');
+    return {
+        ok: true,
+        value: {
+            eventId: eventId,
+            chainId,
+            to: to,
+            sender: sender,
+            instance: instance,
+            body: text,
+            media: parsed.value,
+            sentAt,
+            ...(status === undefined ? {} : { status }),
+            ...(reason === undefined ? {} : { reason }),
+            ...(final === undefined ? {} : { final }),
+            ...(inReplyTo === undefined ? {} : { inReplyTo }),
+            ...(inReplyToExcerpt === undefined ? {} : { inReplyToExcerpt }),
+        },
+    };
+}
+/** Media is a list of [type, url, name?] items; anything else is refused whole, never trimmed. */
+function parseMedia(raw) {
+    if (raw === undefined)
+        return { ok: true, value: [] };
+    if (!Array.isArray(raw))
+        return { ok: false, reason: 'media must be an array of [type, url] or [type, url, name] items' };
+    if (raw.length > MEDIA_MAX_ITEMS)
+        return { ok: false, reason: `media carries at most ${MEDIA_MAX_ITEMS} items` };
+    const value = [];
+    for (const item of raw) {
+        if (!Array.isArray(item) || (item.length !== 2 && item.length !== 3)) {
+            return { ok: false, reason: 'each media item must be a [type, url] or [type, url, name] item' };
+        }
+        const [type, url, name] = item;
+        if (typeof type !== 'string' || !MEDIA_TYPES.includes(type)) {
+            return { ok: false, reason: `media type must be one of ${MEDIA_TYPES.join(', ')}` };
+        }
+        if (typeof url !== 'string' || url.length === 0 || url.length > MEDIA_URL_MAX || !/^https?:\/\/[^\s]+$/i.test(url)) {
+            return { ok: false, reason: `media url must be an http(s) address of at most ${MEDIA_URL_MAX} characters` };
+        }
+        if (item.length === 2) {
+            value.push([type, url]);
+            continue;
+        }
+        const nameProblem = mediaNameProblem(name);
+        if (nameProblem !== undefined)
+            return { ok: false, reason: nameProblem };
+        value.push([type, url, name]);
+    }
+    if (JSON.stringify(value).length > MEDIA_TOTAL_MAX)
+        return { ok: false, reason: `media must fit in ${MEDIA_TOTAL_MAX} bytes` };
+    return { ok: true, value };
+}
+function messageIdFor(eventId) {
+    return `p2p-${eventId}`;
+}
+export async function handleMessage(input) {
+    const { config, table, auth, payload } = input;
+    const parsed = parseRequest(payload, config.maxBodyBytes);
+    if (!parsed.ok) {
+        if (parsed.protocolMismatch)
+            input.stats?.protocolMismatch();
+        return {
+            ok: false,
+            status: parsed.status,
+            body: { error: parsed.reason, ...(parsed.protocolMismatch ? { code: 'protocol_mismatch' } : {}) },
+        };
+    }
+    const request = parsed.value;
+    const roster = config.peers.map((peer) => peer.instance);
+    if (!roster.includes(request.instance)) {
+        const name = logName(request.instance);
+        const firstForInstance = input.stats === undefined || input.stats.unknownInstance(name);
+        if (firstForInstance) {
+            config.warn?.(`dsbot-channel: refused a message from unknown instance "${name}" for ${config.botName}; ` +
+                `configured peers are ${roster.map(logName).join(', ')}`);
+        }
+    }
+    let resolved;
+    try {
+        resolved = await resolvePeers(config.peers, config.credentials);
+    }
+    catch (error) {
+        if (error instanceof SecretRefError)
+            return { ok: false, status: 401, body: { error: 'peer secret is not configured' } };
+        throw error;
+    }
+    const verified = verifyRequest({
+        peers: resolved,
+        signature: auth.signature ?? null,
+        claimedInstance: auth.claimedInstance,
+        envelope: request,
+    });
+    if (!verified.ok)
+        return { ok: false, status: verified.status ?? 401, body: { error: verified.reason ?? 'unauthorized' } };
+    input.stats?.authenticated();
+    const window = config.sentAtWindowMs ?? DEFAULT_SENT_AT_WINDOW_MS;
+    const at = config.now?.() ?? Date.now();
+    const skewMs = request.sentAt - at;
+    input.stats?.skew(skewMs);
+    if (Math.abs(skewMs) > window) {
+        const sender = verified.instance ?? request.instance;
+        const firstForInstance = input.stats === undefined || input.stats.stale(sender);
+        if (firstForInstance) {
+            config.warn?.(`dsbot-channel: refused a message from ${sender} for ${config.botName}: ` +
+                `sentAt is ${skewMs}ms from the local clock, outside the ${window}ms window`);
+        }
+        return {
+            ok: false,
+            status: 403,
+            body: {
+                error: `sentAt is outside the accepted window of ${window}ms`,
+                code: 'stale_sent_at',
+                sentAt: request.sentAt,
+                now: at,
+            },
+        };
+    }
+    if (request.instance !== verified.instance)
+        return { ok: false, status: 403, body: { error: 'instance does not match the bound secret' } };
+    if (request.to !== config.botName)
+        return { ok: false, status: 403, body: { error: 'message is addressed to another bot' } };
+    const key = `${request.instance}|${request.to}|${request.eventId}`;
+    const stats = input.stats;
+    stats?.beginDelivery();
+    try {
+        const claim = await table.claim(key, config.waitMs ?? 10_000);
+        if (claim.done) {
+            if (!claim.entry)
+                return { ok: false, status: 503, body: { error: 'the first delivery is still being processed' } };
+            return { ok: true, status: 200, body: { duplicate: true, messageId: claim.entry.messageId, eventId: request.eventId } };
+        }
+        const messageId = messageIdFor(request.eventId);
+        try {
+            if (input.process)
+                await input.process(request.eventId);
+            table.commit(key, messageId);
+        }
+        catch (error) {
+            table.abort(key);
+            throw error;
+        }
+        return { ok: true, status: 200, body: { duplicate: false, messageId, eventId: request.eventId } };
+    }
+    finally {
+        stats?.endDelivery();
+    }
+}

package/dist/p2p-secrets.d.ts

@@ -0,0 +1,28 @@
+import type { PeerSecret } from './p2p-auth.js';
+export interface PeerRef {
+    instance: string;
+    secret: string;
+    /** The name the peer answers to; an active push needs it, a reply borrows the sender's. */
+    botName?: string;
+    host?: string;
+}
+export interface ResolvedSecret {
+    value: string;
+    source?: string;
+}
+export interface CredentialsLike {
+    resolve(reference: string): Promise<ResolvedSecret | undefined>;
+}
+export type SecretRefReason = 'unresolved' | 'blank';
+export declare class SecretRefError extends Error {
+    readonly instance: string;
+    readonly reference: string;
+    readonly reason: SecretRefReason;
+    constructor(instance: string, reference: string, reason?: SecretRefReason);
+}
+/** Resolves each peer reference through the host credentials service, at call time. */
+export declare function resolvePeers(refs: readonly PeerRef[], credentials: CredentialsLike): Promise<PeerSecret[]>;
+/** Startup check so a missing reference fails the mount instead of the first request. */
+export declare function assertPeersResolvable(refs: readonly PeerRef[], credentials: CredentialsLike): Promise<void>;
+/** In-memory source for tests only; a real profile resolves through the host service. */
+export declare function staticCredentials(values: Record<string, string>): CredentialsLike;

package/dist/p2p-secrets.js

@@ -0,0 +1,50 @@
+export class SecretRefError extends Error {
+    instance;
+    reference;
+    reason;
+    constructor(instance, reference, reason = 'unresolved') {
+        super(reason === 'blank'
+            ? `peer "${instance}" refers to credential "${reference}", which resolved to a blank value`
+            : `peer "${instance}" refers to credential "${reference}", which did not resolve`);
+        this.name = 'SecretRefError';
+        this.instance = instance;
+        this.reference = reference;
+        this.reason = reason;
+    }
+}
+/** Resolves each peer reference through the host credentials service, at call time. */
+export async function resolvePeers(refs, credentials) {
+    const resolved = [];
+    for (const ref of refs) {
+        let found;
+        try {
+            found = await credentials.resolve(ref.secret);
+        }
+        catch {
+            throw new SecretRefError(ref.instance, ref.secret, 'unresolved');
+        }
+        if (!found)
+            throw new SecretRefError(ref.instance, ref.secret, 'unresolved');
+        if (!found.value?.trim())
+            throw new SecretRefError(ref.instance, ref.secret, 'blank');
+        resolved.push({ instance: ref.instance, secret: found.value });
+    }
+    return resolved;
+}
+/** Startup check so a missing reference fails the mount instead of the first request. */
+export async function assertPeersResolvable(refs, credentials) {
+    if (!refs.length)
+        throw new Error('p2p: at least one peer is required to start');
+    await resolvePeers(refs, credentials);
+}
+/** In-memory source for tests only; a real profile resolves through the host service. */
+export function staticCredentials(values) {
+    return {
+        resolve: async (reference) => {
+            const value = values[reference];
+            if (!value)
+                return undefined;
+            return { value, source: 'static' };
+        },
+    };
+}

package/dist/p2p-send.d.ts

@@ -0,0 +1,37 @@
+import type { P2PMediaItem } from './p2p-wire.js';
+import type { CredentialsLike, PeerRef } from './p2p-secrets.js';
+import type { SendResult } from '@dsbot-channel/core/contract.js';
+export type { SendFailure, SendFailureCode, SendResult, SendSuccess } from '@dsbot-channel/core/contract.js';
+export declare const DEFAULT_SEND_TIMEOUT_MS = 10000;
+export interface PeerTarget extends PeerRef {
+    url?: string;
+    /** Sent as the Host header, for a peer reached by address behind a name router.
+     *  http only: https checks the certificate against the url host, not this header. */
+    host?: string;
+}
+export interface P2PSendInput {
+    peer: PeerTarget;
+    credentials: CredentialsLike;
+    to: string;
+    /** The root event of the conversation; a new conversation uses its own event id. */
+    chainId?: string;
+    body: string;
+    eventId: string;
+    sender: string;
+    instance: string;
+    sentAt?: number;
+    timeoutMs?: number;
+    waitMs?: number;
+    fetchImpl?: typeof fetch;
+    /** Marks the message as a refusal; the peer runs no answer for it. */
+    status?: 'declined';
+    reason?: string;
+    final?: boolean;
+    /** The event this message answers, so the peer knows what it refers to. */
+    inReplyTo?: string;
+    inReplyToExcerpt?: string;
+    /** Media to carry, as `[type, url]`; every url must be an http(s) address. */
+    media?: readonly P2PMediaItem[];
+}
+/** Posts one signed message to a peer; the eventId doubles as the retry key. */
+export declare function sendToPeer(input: P2PSendInput): Promise<SendResult>;

package/dist/p2p-send.js

@@ -0,0 +1,137 @@
+import { request as httpRequest } from 'node:http';
+import { request as httpsRequest } from 'node:https';
+import { canonicalEnvelope, signEnvelope } from './p2p-auth.js';
+import { SecretRefError, resolvePeers } from './p2p-secrets.js';
+import { P2P_ROUTE } from './p2p-protocol.js';
+import { oneLine } from './p2p-mapping.js';
+export const DEFAULT_SEND_TIMEOUT_MS = 10_000;
+function failure(code, retryable, reason) {
+    return { ok: false, code, retryable, reason };
+}
+/** Posts the signed bytes with an explicit Host header, which fetch refuses to set. */
+function postWithHost(url, host, payload, signature, timeoutMs) {
+    return new Promise((resolve) => {
+        const target = new URL(url);
+        const send = target.protocol === 'https:' ? httpsRequest : httpRequest;
+        const request = send({
+            protocol: target.protocol,
+            hostname: target.hostname,
+            port: target.port,
+            path: `${target.pathname.replace(/\/$/, '')}${P2P_ROUTE}`,
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                'content-length': Buffer.byteLength(payload),
+                'x-p2p-signature': signature,
+                host,
+            },
+            signal: AbortSignal.timeout(timeoutMs),
+        }, (response) => {
+            const chunks = [];
+            response.on('data', (chunk) => chunks.push(chunk));
+            response.on('end', () => {
+                const raw = Buffer.concat(chunks).toString('utf8');
+                let body;
+                try {
+                    body = raw.length === 0 ? {} : JSON.parse(raw);
+                }
+                catch {
+                    resolve(failure('rejected', false, `the peer answered ${response.statusCode ?? 0} without json`));
+                    return;
+                }
+                resolve({ status: response.statusCode ?? 0, body });
+            });
+        });
+        request.on('error', (error) => {
+            if (error.name === 'AbortError' || error.name === 'TimeoutError' || error.code === 'ABORT_ERR') {
+                resolve(failure('timeout', false, 'the peer did not answer in time'));
+                return;
+            }
+            resolve(failure('unreachable', true, 'the peer could not be reached'));
+        });
+        request.end(payload);
+    });
+}
+/** Posts one signed message to a peer; the eventId doubles as the retry key. */
+export async function sendToPeer(input) {
+    const url = input.peer.url;
+    if (!url)
+        return failure('no_url', false, `peer "${input.peer.instance}" has no url configured`);
+    let secret;
+    try {
+        const resolved = await resolvePeers([input.peer], input.credentials);
+        secret = resolved[0].secret;
+    }
+    catch (error) {
+        if (error instanceof SecretRefError)
+            return failure('credential', false, error.message);
+        throw error;
+    }
+    const sentAt = input.sentAt ?? Date.now();
+    // A name is a file's label: any other type loses it here, so one peer that never read a
+    // three-element item keeps seeing the two elements it always did.
+    const media = (input.media ?? []).map(([type, url, name]) => type === 'file' && name !== undefined ? [type, url, name] : [type, url]);
+    const envelope = {
+        eventId: input.eventId,
+        chainId: input.chainId ?? input.eventId,
+        to: input.to,
+        sender: input.sender,
+        instance: input.instance,
+        body: input.body,
+        sentAt,
+        ...(input.status === undefined ? {} : { status: input.status }),
+        ...(input.reason === undefined ? {} : { reason: input.reason }),
+        ...(input.final === undefined ? {} : { final: input.final }),
+        ...(input.inReplyTo === undefined ? {} : { inReplyTo: input.inReplyTo }),
+        ...(input.inReplyToExcerpt === undefined ? {} : { inReplyToExcerpt: input.inReplyToExcerpt }),
+        ...(media.length === 0 ? {} : { media }),
+    };
+    const signature = signEnvelope(secret, envelope);
+    const payload = canonicalEnvelope(envelope);
+    const timeoutMs = input.timeoutMs ?? DEFAULT_SEND_TIMEOUT_MS;
+    let answered;
+    if (input.peer.host === undefined) {
+        const send = input.fetchImpl ?? fetch;
+        try {
+            const response = await send(`${url.replace(/\/$/, '')}${P2P_ROUTE}`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json', 'x-p2p-signature': signature },
+                body: payload,
+                signal: AbortSignal.timeout(timeoutMs),
+            });
+            let parsed;
+            try {
+                parsed = await response.json();
+            }
+            catch {
+                return failure('rejected', false, `the peer answered ${response.status} without json`);
+            }
+            answered = { status: response.status, body: parsed };
+        }
+        catch (error) {
+            const name = error.name;
+            if (name === 'TimeoutError' || name === 'AbortError')
+                return failure('timeout', false, 'the peer did not answer in time');
+            return failure('unreachable', true, 'the peer could not be reached');
+        }
+    }
+    else {
+        answered = await postWithHost(url, input.peer.host, payload, signature, timeoutMs);
+    }
+    if (!('status' in answered))
+        return answered;
+    const body = answered.body;
+    if (answered.status === 200) {
+        return { ok: true, messageId: body.messageId ?? `p2p-${input.eventId}`, duplicate: body.duplicate === true };
+    }
+    if (answered.status === 401 && body.code === 'protocol_mismatch') {
+        return failure('protocol_mismatch', false, oneLine(body.error ?? 'the peer speaks another protocol'));
+    }
+    if (answered.status === 401)
+        return failure('unauthorized', false, oneLine(body.error ?? 'unauthorized'));
+    if (answered.status === 403)
+        return failure('forbidden', false, oneLine(body.error ?? 'forbidden'));
+    if (answered.status === 503)
+        return failure('busy', true, oneLine(body.error ?? 'the peer is still working on this event'));
+    return failure('rejected', answered.status >= 500, oneLine(body.error ?? `the peer answered ${answered.status}`));
+}

package/dist/p2p-status.d.ts

@@ -0,0 +1 @@
+export declare const STATUS_ROUTE = "/p2p/v1/status";

package/dist/p2p-status.js

@@ -0,0 +1 @@
+export const STATUS_ROUTE = '/p2p/v1/status';

package/dist/p2p-wire.d.ts

@@ -0,0 +1,18 @@
+/** `[type, url]`, with a file's name appended when the sender gave one. */
+export type P2PMediaItem = readonly [type: string, url: string, name?: string];
+export interface InboundRequest {
+    eventId: string;
+    chainId: string;
+    to: string;
+    sender: string;
+    instance: string;
+    body: string;
+    media?: readonly P2PMediaItem[];
+    sentAt: number;
+    /** The peer refused this request, so its turn runs but answers nothing. */
+    status?: 'declined';
+    reason?: string;
+    final?: boolean;
+    inReplyTo?: string;
+    inReplyToExcerpt?: string;
+}