r2-relay-channel 0.3.5

package/dist/message-adapter.d.ts

@@ -0,0 +1,27 @@
+import type { MessageReceipt } from "openclaw/plugin-sdk/channel-message";
+export declare const r2RelayMessageAdapter: {
+    readonly id: "r2-relay-channel";
+    readonly durableFinal: {
+        readonly capabilities: {
+            readonly text: true;
+            readonly media: true;
+            readonly payload: true;
+        };
+    };
+    readonly send: {
+        readonly text: ({ cfg, to, text, accountId }: import("openclaw/plugin-sdk/channel-message").ChannelMessageSendTextContext<import("openclaw/plugin-sdk/core").OpenClawConfig>) => Promise<{
+            receipt: MessageReceipt;
+            messageId: string;
+        }>;
+        readonly media: ({ cfg, to, text, mediaUrl, accountId, mediaAccess, mediaLocalRoots, mediaReadFile }: import("openclaw/plugin-sdk/channel-message").ChannelMessageSendMediaContext<import("openclaw/plugin-sdk/core").OpenClawConfig>) => Promise<{
+            receipt: MessageReceipt;
+            messageId: string;
+        }>;
+        readonly payload: ({ cfg, to, payload, accountId, mediaAccess, mediaLocalRoots, mediaReadFile }: import("openclaw/plugin-sdk/channel-message").ChannelMessageSendPayloadContext<import("openclaw/plugin-sdk/core").OpenClawConfig>) => Promise<{
+            receipt: MessageReceipt;
+            messageId: string;
+        }>;
+    };
+} & {
+    receive: {};
+};

package/dist/message-adapter.js

@@ -0,0 +1,53 @@
+import { defineChannelMessageAdapter } from "openclaw/plugin-sdk/channel-message";
+import { sendRelayPayloadMessage } from "./outbound.js";
+function asMessageResult(result) {
+    const sentAt = result.timestamp ?? Date.now();
+    const receipt = {
+        primaryPlatformMessageId: result.messageId,
+        platformMessageIds: [result.messageId],
+        parts: [{
+                platformMessageId: result.messageId,
+                kind: "text",
+                index: 0,
+                raw: result,
+            }],
+        sentAt,
+        raw: [result],
+    };
+    return { receipt, messageId: result.messageId };
+}
+export const r2RelayMessageAdapter = defineChannelMessageAdapter({
+    id: "r2-relay-channel",
+    durableFinal: {
+        capabilities: {
+            text: true,
+            media: true,
+            payload: true,
+        },
+    },
+    send: {
+        text: async ({ cfg, to, text, accountId }) => asMessageResult(await sendRelayPayloadMessage({
+            cfg: cfg,
+            to,
+            payload: { text },
+            accountId,
+            source: "message.text",
+        })),
+        media: async ({ cfg, to, text, mediaUrl, accountId, mediaAccess, mediaLocalRoots, mediaReadFile }) => asMessageResult(await sendRelayPayloadMessage({
+            cfg: cfg,
+            to,
+            payload: { text, mediaUrl },
+            accountId,
+            source: "message.media",
+            meta: { mediaAccess, mediaLocalRoots, mediaReadFile },
+        })),
+        payload: async ({ cfg, to, payload, accountId, mediaAccess, mediaLocalRoots, mediaReadFile }) => asMessageResult(await sendRelayPayloadMessage({
+            cfg: cfg,
+            to,
+            payload,
+            accountId,
+            source: "message.payload",
+            meta: { mediaAccess, mediaLocalRoots, mediaReadFile },
+        })),
+    },
+});

package/dist/openclaw.plugin.json

@@ -0,0 +1,41 @@
+{
+  "id": "r2-relay-channel",
+  "kind": "channel",
+  "name": "R2 Relay Channel",
+  "description": "Cloudflare R2 relay channel plugin for OpenClaw by AgentDeck App.",
+  "channels": ["r2-relay-channel"],
+  "channelConfigs": {
+    "r2-relay-channel": {
+      "label": "R2 Relay",
+      "description": "Cloudflare R2 relay channel for direct text messaging.",
+      "schema": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "enabled": { "type": "boolean" },
+          "configFile": { "type": "string" }
+        }
+      },
+      "uiHints": {
+        "configFile": {
+          "label": "Config file",
+          "placeholder": "/path/to/r2relay.config.json"
+        }
+      }
+    }
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "r2-relay-channel": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "enabled": { "type": "boolean" },
+          "configFile": { "type": "string" }
+        }
+      }
+    }
+  }
+}

package/dist/outbound.d.ts

@@ -0,0 +1,28 @@
+import type { OutboundMediaAccess } from "openclaw/plugin-sdk/media-runtime";
+import type { RelayRoute } from "./protocol.js";
+import { type RelayPollLog } from "./lifecycle.js";
+export declare function sendRelayPayloadMessage(params: {
+    cfg: Record<string, unknown>;
+    to: string;
+    payload: {
+        text?: string | null;
+        mediaUrl?: string | null;
+        mediaUrls?: string[] | null;
+        channelData?: Record<string, unknown> | null;
+    };
+    accountId?: string | null;
+    log?: RelayPollLog;
+    source?: string;
+    meta?: {
+        route?: RelayRoute | null;
+        workspaceDir?: string | null;
+        mediaAccess?: OutboundMediaAccess;
+        mediaLocalRoots?: readonly string[];
+        mediaReadFile?: (filePath: string) => Promise<Buffer>;
+    };
+}): Promise<{
+    channel: string;
+    to: string;
+    messageId: string;
+    timestamp: number;
+}>;

package/dist/outbound.js

@@ -0,0 +1,141 @@
+import { getOrCreateService, emitRelayDebug, touchRuntime } from "./lifecycle.js";
+import { parseRelayTarget } from "./target.js";
+import { buildRelayAttachments, describeLocalMediaReference, resolveRelayPayloadMediaUrls, } from "./media.js";
+import { resolveR2RelayAccount } from "./config.js";
+import { schedulePublishedIdentityRefresh } from "./session-publication.js";
+export async function sendRelayPayloadMessage(params) {
+    const account = resolveR2RelayAccount({ cfg: params.cfg, accountId: params.accountId });
+    const service = getOrCreateService(account);
+    const target = parseRelayTarget(params.to);
+    const text = params.payload.text ?? "";
+    const mediaUrls = resolveRelayPayloadMediaUrls(params.payload);
+    const route = params.meta?.route ?? {
+        agent_id: agentIdFromConversationId(target.conversationId ?? "main") ?? "main",
+        conversation_id: target.conversationId ?? null,
+        instance_id: null,
+    };
+    emitRelayDebug(params.log, `[${account.accountId}] outbound relay send starting`, {
+        source: params.source ?? "unknown",
+        to: params.to,
+        peer: target.peer,
+        route,
+        mediaCount: mediaUrls.length,
+        hasText: Boolean(text.trim()),
+    });
+    const attachmentBuild = await buildRelayAttachments({
+        account,
+        service,
+        targetPeer: target.peer,
+        mediaUrls,
+        workspaceDir: params.meta?.workspaceDir ?? null,
+        mediaAccess: params.meta?.mediaAccess,
+        mediaLocalRoots: params.meta?.mediaLocalRoots,
+        mediaReadFile: params.meta?.mediaReadFile,
+        log: params.log,
+        source: params.source,
+    });
+    const attachments = attachmentBuild.attachments;
+    emitRelayDebug(params.log, `[${account.accountId}] sending outbound relay message`, {
+        source: params.source ?? "unknown",
+        attachmentCount: attachments.length,
+        hasText: Boolean(text.trim()),
+        targetPeer: target.peer,
+        route,
+    });
+    if (mediaUrls.length > 0 && attachments.length === 0) {
+        const detail = attachmentBuild.failures.length > 0
+            ? attachmentBuild.failures.join(" | ")
+            : "no attachment objects were created";
+        throw new Error(`Failed to prepare outbound relay attachments: ${detail}`);
+    }
+    const fallbackText = text.trim() || (mediaUrls.length > 0 && attachments.length === 0
+        ? mediaUrls.map((url) => `[Attachment unavailable: ${describeLocalMediaReference(url)}]`).join("\n")
+        : text);
+    const result = await service.sendMessage(target.peer, {
+        route,
+        content: relayContentFromPayload(fallbackText, attachments, params.payload.channelData),
+    });
+    emitRelayDebug(params.log, `[${account.accountId}] outbound relay message sent`, {
+        source: params.source ?? "unknown",
+        messageId: result.messageId,
+        attachmentCount: attachments.length,
+    });
+    touchRuntime(account.accountId, {
+        lastOutboundAt: Date.now(),
+        lastError: null,
+    });
+    schedulePublishedIdentityRefresh(service, account);
+    return {
+        channel: "r2-relay-channel",
+        to: params.to.trim(),
+        messageId: result.messageId,
+        timestamp: Date.now(),
+    };
+}
+function relayContentFromPayload(text, attachments, channelData) {
+    const execApproval = readExecApprovalChannelData(channelData);
+    if (execApproval?.state === "pending") {
+        return {
+            type: "approval_request",
+            approval_id: execApproval.approvalId,
+            approval_kind: execApproval.approvalKind === "plugin" ? "tool" : execApproval.approvalKind,
+            title: firstNonEmptyLine(text) ?? "Approval required",
+            body: text.trim() || null,
+            allowed_decisions: execApproval.allowedDecisions.length > 0
+                ? execApproval.allowedDecisions
+                : ["allow-once", "allow-always", "deny"],
+            metadata: {
+                openclaw: execApproval.raw,
+            },
+        };
+    }
+    return {
+        type: "text",
+        text,
+        attachments: attachments.length > 0 ? attachments : undefined,
+    };
+}
+function readExecApprovalChannelData(channelData) {
+    const raw = channelData?.execApproval;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return null;
+    }
+    const record = raw;
+    const approvalId = typeof record.approvalId === "string" ? record.approvalId.trim() : "";
+    if (!approvalId) {
+        return null;
+    }
+    const approvalKind = normalizeApprovalKind(record.approvalKind);
+    const allowedDecisions = Array.isArray(record.allowedDecisions)
+        ? record.allowedDecisions.filter((value) => typeof value === "string" && value.trim().length > 0)
+        : [];
+    return {
+        approvalId,
+        approvalKind,
+        allowedDecisions,
+        state: typeof record.state === "string" ? record.state : null,
+        raw: record,
+    };
+}
+function normalizeApprovalKind(value) {
+    if (value === "exec" || value === "tool" || value === "custom" || value === "plugin") {
+        return value;
+    }
+    return "exec";
+}
+function firstNonEmptyLine(value) {
+    for (const line of value.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed) {
+            return trimmed;
+        }
+    }
+    return null;
+}
+function agentIdFromConversationId(conversationId) {
+    const parts = conversationId.split(":");
+    if (parts.length >= 2 && parts[0] === "agent" && parts[1]?.trim()) {
+        return parts[1].trim();
+    }
+    return null;
+}

package/dist/protocol.d.ts

@@ -0,0 +1,2 @@
+export { MAX_MS, R2Relay, extractTimestampFromRelayKey, padRevTs, sanitizeFragment, type AttachmentKind, type AttachmentRef, type AgentDescriptor, type ConversationDescriptor, type HeadDoc, type IdentityDoc, type InboxBatch, type InboxMessage, type RelayContent, type RelayMessage, type RelayRoute, type RelayCheckpointState, type RelayRetentionConfig, type ServerLimits, type SendMessageOptions, type SendMessageResult, type SweepRuleSummary, } from "./relay-core/index.js";
+export type { RelayKeyspaceOptions as R2RelayOptions } from "./relay-core/index.js";

package/dist/protocol.js

@@ -0,0 +1 @@
+export { MAX_MS, R2Relay, extractTimestampFromRelayKey, padRevTs, sanitizeFragment, } from "./relay-core/index.js";

package/dist/r2-relay.d.ts

@@ -0,0 +1 @@
+export { default } from "./index.js";

package/dist/r2-relay.js

@@ -0,0 +1 @@
+export { default } from "./index.js";

package/dist/r2client.d.ts

@@ -0,0 +1,33 @@
+import { S3Client } from "@aws-sdk/client-s3";
+export interface R2Config {
+    endpoint: string;
+    bucket: string;
+    region?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    forcePathStyle?: boolean;
+}
+export declare class R2Client {
+    s3: S3Client;
+    bucket: string;
+    constructor(cfg: R2Config);
+    getPresignedUrl(key: string, expiresIn: number): Promise<string>;
+    putObject(key: string, body: Buffer | string, contentType?: string, tagging?: string, ifMatch?: string, ifNoneMatch?: string): Promise<import("@aws-sdk/client-s3").PutObjectCommandOutput>;
+    getObject(key: string): Promise<import("@aws-sdk/client-s3").GetObjectCommandOutput | null>;
+    headObject(key: string): Promise<import("@aws-sdk/client-s3").HeadObjectCommandOutput | null>;
+    getJsonWithEtag<T>(key: string): Promise<{
+        body: T;
+        etag: string | null;
+    } | null>;
+    deleteObject(key: string): Promise<import("@aws-sdk/client-s3").DeleteObjectCommandOutput>;
+    listPrefix(prefix: string, maxKeys?: number): Promise<import("@aws-sdk/client-s3")._Object[]>;
+    listPrefixPage(prefix: string, continuationToken?: string, maxKeys?: number): Promise<{
+        contents: import("@aws-sdk/client-s3")._Object[];
+        nextContinuationToken: string | null;
+        isTruncated: boolean;
+    }>;
+    deleteObjects(keys: string[]): Promise<import("@aws-sdk/client-s3").DeleteObjectsCommandOutput | {
+        deleted: never[];
+        errors: never[];
+    }>;
+}

package/dist/r2client.js

@@ -0,0 +1,137 @@
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { DeleteObjectCommand, DeleteObjectsCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, PutObjectCommand, S3Client, } from "@aws-sdk/client-s3";
+export class R2Client {
+    s3;
+    bucket;
+    constructor(cfg) {
+        this.bucket = cfg.bucket;
+        this.s3 = new S3Client({
+            region: cfg.region || "auto",
+            endpoint: cfg.endpoint,
+            credentials: cfg.accessKeyId
+                ? {
+                    accessKeyId: cfg.accessKeyId,
+                    secretAccessKey: cfg.secretAccessKey ?? "",
+                }
+                : undefined,
+            forcePathStyle: cfg.forcePathStyle ?? true,
+        });
+    }
+    async getPresignedUrl(key, expiresIn) {
+        const command = new GetObjectCommand({ Bucket: this.bucket, Key: key });
+        return getSignedUrl(this.s3, command, { expiresIn });
+    }
+    async putObject(key, body, contentType, tagging, ifMatch, ifNoneMatch) {
+        const params = { Bucket: this.bucket, Key: key, Body: body };
+        if (contentType)
+            params.ContentType = contentType;
+        if (tagging)
+            params.Tagging = tagging;
+        if (ifMatch)
+            params.IfMatch = ifMatch;
+        if (ifNoneMatch)
+            params.IfNoneMatch = ifNoneMatch;
+        const cmd = new PutObjectCommand(params);
+        try {
+            return await this.s3.send(cmd);
+        }
+        catch (err) {
+            const normalized = err;
+            const code = normalized?.Code || normalized?.name || normalized?.$metadata?.httpStatusCode;
+            if (tagging && (code === "NotImplemented" || normalized?.$metadata?.httpStatusCode === 501)) {
+                delete params.Tagging;
+                return await this.s3.send(new PutObjectCommand(params));
+            }
+            if (normalized &&
+                (normalized.$metadata?.httpStatusCode === 412 || normalized.Code === "PreconditionFailed")) {
+                const preconditionError = new Error("PreconditionFailed");
+                preconditionError.code = "PreconditionFailed";
+                throw preconditionError;
+            }
+            throw err;
+        }
+    }
+    async getObject(key) {
+        const cmd = new GetObjectCommand({ Bucket: this.bucket, Key: key });
+        try {
+            return await this.s3.send(cmd);
+        }
+        catch (err) {
+            const normalized = err;
+            const code = normalized?.Code || normalized?.name || normalized?.code;
+            if (code === "NoSuchKey" ||
+                code === "NotFound" ||
+                normalized?.$metadata?.httpStatusCode === 404) {
+                return null;
+            }
+            throw err;
+        }
+    }
+    async headObject(key) {
+        const cmd = new HeadObjectCommand({ Bucket: this.bucket, Key: key });
+        try {
+            return await this.s3.send(cmd);
+        }
+        catch (err) {
+            const normalized = err;
+            if (normalized?.Code === "NotFound" ||
+                normalized?.name === "NotFound" ||
+                normalized?.$metadata?.httpStatusCode === 404) {
+                return null;
+            }
+            return null;
+        }
+    }
+    async getJsonWithEtag(key) {
+        const res = await this.getObject(key);
+        if (!res?.Body) {
+            return null;
+        }
+        const chunks = [];
+        for await (const chunk of res.Body) {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+        const text = Buffer.concat(chunks).toString("utf8");
+        return {
+            body: JSON.parse(text),
+            etag: normalizeEtag(res.ETag),
+        };
+    }
+    async deleteObject(key) {
+        return await this.s3.send(new DeleteObjectCommand({ Bucket: this.bucket, Key: key }));
+    }
+    async listPrefix(prefix, maxKeys = 100) {
+        const res = await this.s3.send(new ListObjectsV2Command({ Bucket: this.bucket, Prefix: prefix, MaxKeys: maxKeys }));
+        return res.Contents || [];
+    }
+    async listPrefixPage(prefix, continuationToken, maxKeys = 1000) {
+        const res = await this.s3.send(new ListObjectsV2Command({
+            Bucket: this.bucket,
+            Prefix: prefix,
+            MaxKeys: maxKeys,
+            ContinuationToken: continuationToken,
+        }));
+        return {
+            contents: res.Contents || [],
+            nextContinuationToken: res.NextContinuationToken ?? null,
+            isTruncated: Boolean(res.IsTruncated),
+        };
+    }
+    async deleteObjects(keys) {
+        if (keys.length === 0) {
+            return { deleted: [], errors: [] };
+        }
+        return await this.s3.send(new DeleteObjectsCommand({
+            Bucket: this.bucket,
+            Delete: {
+                Objects: keys.map((Key) => ({ Key })),
+                Quiet: true,
+            },
+        }));
+    }
+}
+function normalizeEtag(etag) {
+    if (!etag)
+        return null;
+    return etag.replace(/^"|"$/g, "") || null;
+}

package/dist/relay-core/checkpoint.d.ts

@@ -0,0 +1,31 @@
+import type { RelayCheckpointState } from "./types.js";
+export declare const DEFAULT_CHECKPOINT_STATE: RelayCheckpointState;
+export declare function defaultCheckpointState(): RelayCheckpointState;
+export declare function normalizeCheckpointState(data?: Partial<RelayCheckpointState> | null): RelayCheckpointState;
+export interface CheckpointStore {
+    load(): Promise<RelayCheckpointState> | RelayCheckpointState;
+    save(state: RelayCheckpointState): Promise<void> | void;
+}
+export declare class InMemoryCheckpointStore implements CheckpointStore {
+    private state;
+    constructor(state?: Partial<RelayCheckpointState>);
+    load(): RelayCheckpointState;
+    save(state: RelayCheckpointState): void;
+}
+export declare class FileCheckpointStore implements CheckpointStore {
+    readonly filePath: string;
+    constructor(filePath: string);
+    load(): Promise<RelayCheckpointState>;
+    save(state: RelayCheckpointState): Promise<void>;
+}
+export declare function loadCheckpointStateFromFile(filePath: string): Promise<RelayCheckpointState>;
+export declare function saveCheckpointStateToFile(filePath: string, state: RelayCheckpointState): Promise<void>;
+export declare function rememberMessage(state: RelayCheckpointState, params: {
+    msgId?: string | null;
+    objectKey?: string | null;
+    at?: number | null;
+}): RelayCheckpointState;
+export declare function hasSeenMessage(state: RelayCheckpointState, params: {
+    msgId?: string | null;
+    objectKey?: string | null;
+}): boolean;

package/dist/relay-core/checkpoint.js

@@ -0,0 +1,95 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+const RECENT_MESSAGE_IDS_LIMIT = 200;
+export const DEFAULT_CHECKPOINT_STATE = {
+    lastHeadKey: null,
+    recentMessageIds: [],
+    recentObjectKeys: [],
+    lastPollAt: null,
+    lastInboundAt: null,
+};
+export function defaultCheckpointState() {
+    return {
+        lastHeadKey: DEFAULT_CHECKPOINT_STATE.lastHeadKey,
+        recentMessageIds: [...DEFAULT_CHECKPOINT_STATE.recentMessageIds],
+        recentObjectKeys: [...DEFAULT_CHECKPOINT_STATE.recentObjectKeys],
+        lastPollAt: DEFAULT_CHECKPOINT_STATE.lastPollAt,
+        lastInboundAt: DEFAULT_CHECKPOINT_STATE.lastInboundAt,
+    };
+}
+export function normalizeCheckpointState(data) {
+    const raw = data ?? {};
+    return {
+        lastHeadKey: typeof raw.lastHeadKey === "string" ? raw.lastHeadKey : null,
+        recentMessageIds: Array.isArray(raw.recentMessageIds)
+            ? raw.recentMessageIds.filter((value) => typeof value === "string").slice(0, RECENT_MESSAGE_IDS_LIMIT)
+            : [],
+        recentObjectKeys: Array.isArray(raw.recentObjectKeys)
+            ? raw.recentObjectKeys.filter((value) => typeof value === "string").slice(0, RECENT_MESSAGE_IDS_LIMIT)
+            : [],
+        lastPollAt: typeof raw.lastPollAt === "number" ? raw.lastPollAt : null,
+        lastInboundAt: typeof raw.lastInboundAt === "number" ? raw.lastInboundAt : null,
+    };
+}
+export class InMemoryCheckpointStore {
+    state;
+    constructor(state) {
+        this.state = normalizeCheckpointState(state);
+    }
+    load() {
+        return normalizeCheckpointState(this.state);
+    }
+    save(state) {
+        this.state = normalizeCheckpointState(state);
+    }
+}
+export class FileCheckpointStore {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    async load() {
+        return loadCheckpointStateFromFile(this.filePath);
+    }
+    async save(state) {
+        await saveCheckpointStateToFile(this.filePath, state);
+    }
+}
+export async function loadCheckpointStateFromFile(filePath) {
+    try {
+        const raw = await fs.readFile(filePath, "utf8");
+        return normalizeCheckpointState(JSON.parse(raw));
+    }
+    catch {
+        return defaultCheckpointState();
+    }
+}
+export async function saveCheckpointStateToFile(filePath, state) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const normalized = normalizeCheckpointState(state);
+    const serialized = JSON.stringify(normalized, null, 2);
+    const tempPath = `${filePath}.${createHash("sha1").update(serialized).digest("hex")}.tmp`;
+    await fs.writeFile(tempPath, serialized, "utf8");
+    await fs.rename(tempPath, filePath);
+}
+export function rememberMessage(state, params) {
+    const normalized = normalizeCheckpointState(state);
+    const recentMessageIds = params.msgId
+        ? [params.msgId, ...normalized.recentMessageIds.filter((value) => value !== params.msgId)].slice(0, RECENT_MESSAGE_IDS_LIMIT)
+        : normalized.recentMessageIds;
+    const recentObjectKeys = params.objectKey
+        ? [params.objectKey, ...normalized.recentObjectKeys.filter((value) => value !== params.objectKey)].slice(0, RECENT_MESSAGE_IDS_LIMIT)
+        : normalized.recentObjectKeys;
+    return {
+        ...normalized,
+        recentMessageIds,
+        recentObjectKeys,
+        lastInboundAt: params.at ?? normalized.lastInboundAt ?? Date.now(),
+    };
+}
+export function hasSeenMessage(state, params) {
+    const normalized = normalizeCheckpointState(state);
+    return Boolean((params.msgId && normalized.recentMessageIds.includes(params.msgId)) ||
+        (params.objectKey && normalized.recentObjectKeys.includes(params.objectKey)));
+}

package/dist/relay-core/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class RelayTransportError extends Error {
+    constructor(message: string);
+}
+export declare class PreconditionFailedError extends RelayTransportError {
+    constructor(message?: string);
+}
+export declare class CASRetryExceededError extends RelayTransportError {
+    constructor(message?: string);
+}

package/dist/relay-core/errors.js

@@ -0,0 +1,18 @@
+export class RelayTransportError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RelayTransportError";
+    }
+}
+export class PreconditionFailedError extends RelayTransportError {
+    constructor(message = "PreconditionFailed") {
+        super(message);
+        this.name = "PreconditionFailedError";
+    }
+}
+export class CASRetryExceededError extends RelayTransportError {
+    constructor(message = "Failed to append message after CAS retries") {
+        super(message);
+        this.name = "CASRetryExceededError";
+    }
+}

package/dist/relay-core/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./errors.js";
+export * from "./object-store.js";
+export * from "./keyspace.js";
+export * from "./checkpoint.js";
+export * from "./transport.js";

package/dist/relay-core/index.js

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./errors.js";
+export * from "./object-store.js";
+export * from "./keyspace.js";
+export * from "./checkpoint.js";
+export * from "./transport.js";

package/dist/relay-core/keyspace.d.ts

@@ -0,0 +1,24 @@
+export declare const MAX_MS = 9999999999999;
+export declare function sanitizeFragment(value: string | null | undefined): string;
+export declare function padRevTs(ts: number): string;
+export declare function extractTimestampFromRelayKey(key: string): number | null;
+export interface RelayKeyspaceOptions {
+    bucket?: string;
+    idFactory?: () => string;
+    nowMsFactory?: () => number;
+}
+export declare class RelayKeyspace {
+    readonly bucket: string;
+    readonly idFactory: () => string;
+    readonly nowMsFactory: () => number;
+    constructor(options?: RelayKeyspaceOptions);
+    padRevTs(ts: number): string;
+    shortUuid(): string;
+    makeMsgKey(recipient: string, nowMs?: number, suffix?: string): string;
+    makeAttKey(recipient: string, messageId: string, index: number, name?: string, nowMs?: number): string;
+    makeHeadKey(recipient: string): string;
+    makeIdentityKey(peer: string): string;
+    makeIdentifyKey(peer: string): string;
+}
+export declare class R2Relay extends RelayKeyspace {
+}