@opencoredev/social-sdk 0.1.0 → 0.1.2

package/dist/platforms/bluesky.js

@@ -1,1049 +0,0 @@
-import { readBinary } from "../transport/binary.js";
-import { remainingBudget } from "../transport/budget.js";
-import { connectedAccountRef, defineAdapter, platformPostRef, } from "../core/index.js";
-import { SocialError } from "../core/errors.js";
-import { abortable, createHttp, HttpError } from "../transport/http.js";
-import { httpsUrl } from "../transport/upload.js";
-import { array, object, string } from "../transport/validation.js";
-import { publicFields } from "../cloud/common.js";
-const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
-const MAX_IMAGES = 4;
-function endpoint(service, method) {
-    let base;
-    try {
-        base = new URL(service);
-    }
-    catch {
-        throw new SocialError({
-            code: "invalid_config",
-            operation: "bluesky.configure",
-            message: "Bluesky service must be an absolute URL.",
-        });
-    }
-    if (base.protocol !== "https:" || base.username || base.password) {
-        throw new SocialError({
-            code: "invalid_config",
-            operation: "bluesky.configure",
-            message: "Bluesky service must use HTTPS without embedded credentials.",
-        });
-    }
-    return new URL(`/xrpc/${method}`, base);
-}
-function accountMatches(ref, auth, backend) {
-    return ref.backend === backend && ref.platform === "bluesky" && ref.accountId === auth.did;
-}
-function authHeaders(auth) {
-    return auth.accessJwt === undefined ? {} : { Authorization: `Bearer ${auth.accessJwt}` };
-}
-function operationError(operation, error, mutation = true) {
-    if (error instanceof SocialError)
-        return error;
-    if (error instanceof HttpError) {
-        const ambiguous = mutation &&
-            error.dispatched &&
-            (error.kind !== "http" || (error.status !== undefined && error.status >= 500));
-        return new SocialError({
-            code: ambiguous
-                ? "ambiguous_outcome"
-                : error.kind === "timeout"
-                    ? "timeout"
-                    : error.kind === "cancelled"
-                        ? "cancelled"
-                        : "upstream_failure",
-            operation,
-            message: error.message,
-            retryDisposition: ambiguous ? { kind: "reconcile-first" } : { kind: "never" },
-            ...(error.status === undefined ? {} : { upstreamStatus: error.status }),
-        });
-    }
-    return new SocialError({
-        code: "upstream_failure",
-        operation,
-        message: "Bluesky request failed.",
-        retryDisposition: { kind: "reconcile-first" },
-        cause: error,
-    });
-}
-function postRef(value) {
-    const record = object(value);
-    return { uri: string(record["uri"]), cid: string(record["cid"]) };
-}
-function linkFacets(text) {
-    const facets = [];
-    const urlPattern = /https?:\/\/[^\s<>]+/g;
-    for (const match of text.matchAll(urlPattern)) {
-        const value = match[0];
-        const start = match.index;
-        if (start === undefined || value === undefined)
-            continue;
-        const end = start + value.length;
-        const byteStart = new TextEncoder().encode(text.slice(0, start)).byteLength;
-        const byteEnd = new TextEncoder().encode(text.slice(0, end)).byteLength;
-        facets.push({
-            index: { byteStart, byteEnd },
-            features: [{ $type: "app.bsky.richtext.facet#link", uri: value }],
-        });
-    }
-    return facets;
-}
-function richTextOptions(text, options) {
-    const invalid = (message) => {
-        throw new SocialError({ code: "invalid_input", operation: "bluesky.prepare", message });
-    };
-    if (options !== undefined &&
-        (options === null || typeof options !== "object" || Array.isArray(options)))
-        invalid("Bluesky options must be an object.");
-    const config = (options ?? {});
-    if (Object.keys(config).some((key) => key !== "languages" && key !== "mentions"))
-        invalid("A supplied Bluesky option is not supported.");
-    let langs;
-    if (config["languages"] !== undefined) {
-        const languages = config["languages"];
-        if (!Array.isArray(languages) ||
-            languages.length > 3 ||
-            languages.some((value) => typeof value !== "string"))
-            invalid("Bluesky accepts at most three language tags.");
-        try {
-            langs = Intl.getCanonicalLocales(languages);
-        }
-        catch {
-            invalid("Bluesky languages must be valid BCP 47 tags.");
-        }
-    }
-    const facets = [...linkFacets(text)];
-    const bytes = new TextEncoder().encode(text);
-    const mentions = config["mentions"] ?? [];
-    if (!Array.isArray(mentions) || mentions.length > 100)
-        invalid("Bluesky mentions must be an array of at most 100 DID references.");
-    const spans = [];
-    for (const value of mentions) {
-        if (!value || typeof value !== "object" || Array.isArray(value))
-            invalid("Each mention requires UTF-8 offsets and a DID.");
-        const start = value["byteStart"], end = value["byteEnd"], did = value["did"];
-        if (typeof start !== "number" ||
-            typeof end !== "number" ||
-            !Number.isSafeInteger(start) ||
-            !Number.isSafeInteger(end) ||
-            start < 0 ||
-            end <= start ||
-            end > bytes.length ||
-            (bytes[start] & 0xc0) === 0x80 ||
-            (end < bytes.length && (bytes[end] & 0xc0) === 0x80) ||
-            typeof did !== "string" ||
-            !/^did:[a-z]+:[A-Za-z0-9._:%-]+$/.test(did))
-            invalid("Mention offsets must span complete UTF-8 characters and identify a DID.");
-        const byteStart = start, byteEnd = end;
-        if (!new TextDecoder().decode(bytes.slice(byteStart, byteEnd)).startsWith("@"))
-            invalid("A mention span must start with @.");
-        if (spans.some((span) => byteStart < span.end && byteEnd > span.start) ||
-            facets.some((facet) => {
-                const index = facet["index"];
-                return byteStart < Number(index["byteEnd"]) && byteEnd > Number(index["byteStart"]);
-            }))
-            invalid("Mention spans must not overlap links or other mentions.");
-        spans.push({ start: byteStart, end: byteEnd });
-        facets.push({
-            index: { byteStart, byteEnd },
-            features: [{ $type: "app.bsky.richtext.facet#mention", did: did }],
-        });
-    }
-    facets.sort((left, right) => Number(left["index"]["byteStart"]) -
-        Number(right["index"]["byteStart"]));
-    return { ...(langs === undefined ? {} : { langs }), ...(facets.length ? { facets } : {}) };
-}
-function graphemeCount(text) {
-    const Segmenter = Intl.Segmenter;
-    return Segmenter === undefined
-        ? Array.from(text).length
-        : [...new Segmenter(undefined, { granularity: "grapheme" }).segment(text)].length;
-}
-async function readMedia(source, fetcher, context, allowMediaHost) {
-    const duration = remainingBudget(context);
-    const controller = new AbortController();
-    const abort = () => controller.abort(context.signal?.reason);
-    if (context.signal?.aborted)
-        abort();
-    context.signal?.addEventListener("abort", abort, { once: true });
-    const timer = setTimeout(() => controller.abort(new Error("Media deadline exceeded")), duration);
-    try {
-        controller.signal.throwIfAborted();
-        if (source.kind === "blob") {
-            if (source.blob.size > MAX_IMAGE_BYTES)
-                throw new SocialError({
-                    code: "media_error",
-                    operation: "bluesky.uploadBlob",
-                    message: "Image exceeds the 10 MiB limit.",
-                });
-            return {
-                bytes: await readBinary(source.blob.stream(), MAX_IMAGE_BYTES, controller.signal),
-                mimeType: source.blob.type || "application/octet-stream",
-            };
-        }
-        if (source.kind === "stream")
-            return {
-                bytes: await readBinary(source.open(), MAX_IMAGE_BYTES, controller.signal),
-                mimeType: "application/octet-stream",
-            };
-        if (source.kind === "https-url") {
-            const url = httpsUrl(source.url);
-            if (!allowMediaHost(url.hostname))
-                throw new SocialError({
-                    code: "media_error",
-                    operation: "bluesky.uploadBlob",
-                    message: "Remote image host is outside the configured egress policy.",
-                });
-            const pending = fetcher(url, { redirect: "error", signal: controller.signal });
-            void pending.then((response) => {
-                if (controller.signal.aborted)
-                    void response.body?.cancel().catch(() => undefined);
-            }, () => undefined);
-            const response = await abortable(pending, controller.signal);
-            if (!response.ok ||
-                !response.body ||
-                Number(response.headers.get("content-length")) > MAX_IMAGE_BYTES) {
-                void response.body?.cancel().catch(() => undefined);
-                throw new SocialError({
-                    code: "media_error",
-                    operation: "bluesky.uploadBlob",
-                    message: "Remote image was unavailable or exceeded its byte limit.",
-                });
-            }
-            return {
-                bytes: await readBinary(response.body, MAX_IMAGE_BYTES, controller.signal),
-                mimeType: response.headers.get("content-type")?.split(";")[0] || "application/octet-stream",
-            };
-        }
-        throw new SocialError({
-            code: "media_error",
-            operation: "bluesky.uploadBlob",
-            message: "This image source cannot be uploaded.",
-        });
-    }
-    catch (error) {
-        if (controller.signal.aborted)
-            throw new SocialError({
-                code: context.signal?.aborted ? "cancelled" : "timeout",
-                operation: "bluesky.uploadBlob",
-                message: "Image preparation was interrupted before publication.",
-                retryDisposition: { kind: "never" },
-            });
-        throw error;
-    }
-    finally {
-        clearTimeout(timer);
-        context.signal?.removeEventListener("abort", abort);
-    }
-}
-export function bluesky(options) {
-    const backend = options.backend ?? "default";
-    const fetcher = options.fetch ?? globalThis.fetch;
-    const allowMediaHost = options.allowMediaHost ?? (() => false);
-    const http = createHttp({
-        fetch: options.session
-            ? (input, init) => {
-                const url = new URL(input instanceof Request ? input.url : String(input));
-                // OAuthSession resolves a relative XRPC path against its verified token
-                // audience. Never override that audience with caller-provided service URLs.
-                return options.session.fetchHandler(url.pathname + url.search, init);
-            }
-            : fetcher,
-        ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
-    });
-    const auth = options.auth;
-    if (options.session) {
-        if (options.session.did !== auth.did)
-            throw new SocialError({
-                code: "invalid_config",
-                operation: "bluesky.configure",
-                message: "OAuth session DID must match the configured account DID.",
-            });
-        if (auth.accessJwt !== undefined)
-            throw new SocialError({
-                code: "invalid_config",
-                operation: "bluesky.configure",
-                message: "Use OAuth session transport or bearer credentials, not both.",
-            });
-    }
-    else if (auth.accessJwt === undefined) {
-        throw new SocialError({
-            code: "invalid_config",
-            operation: "bluesky.configure",
-            message: "Bluesky authorization requires accessJwt or an OAuth session.",
-        });
-    }
-    const service = auth.service;
-    const account = connectedAccountRef({ backend, platform: "bluesky", accountId: auth.did });
-    const capabilities = {
-        schemaVersion: 1,
-        backend,
-        apiRevision: "AT Protocol XRPC 2026-09",
-        runtime: ["node>=22.12", "bun"],
-        capabilities: [
-            {
-                operation: "accounts.read",
-                platform: "bluesky",
-                availability: "available",
-                requiredScopes: ["repo"],
-            },
-            {
-                operation: "posts.publish",
-                platform: "bluesky",
-                availability: "available",
-                formats: ["text", "image"],
-                requiredScopes: ["repo"],
-            },
-            {
-                operation: "posts.read",
-                platform: "bluesky",
-                availability: "available",
-                formats: ["text", "image"],
-            },
-            {
-                operation: "posts.list",
-                platform: "bluesky",
-                availability: "available",
-                formats: ["text", "image"],
-            },
-            {
-                operation: "comments.read",
-                platform: "bluesky",
-                availability: "available",
-                formats: ["text"],
-            },
-            {
-                operation: "analytics.read",
-                platform: "bluesky",
-                availability: "available",
-                formats: ["text", "image"],
-            },
-            { operation: "analytics.account.read", platform: "bluesky", availability: "available" },
-            {
-                operation: "comments.write",
-                platform: "bluesky",
-                availability: "available",
-                formats: ["text"],
-                requiredScopes: ["repo"],
-            },
-            {
-                operation: "posts.publish.video",
-                platform: "bluesky",
-                availability: "available",
-                formats: ["video"],
-                requiredScopes: ["repo"],
-            },
-            ...[
-                "posts.repost",
-                "posts.quote",
-                "posts.delete",
-                "graph.follow",
-                "graph.block",
-                "graph.mute",
-                "notifications.read",
-                "notifications.seen",
-                "profile.read",
-                "profile.update",
-                "feeds.read",
-                "chat.read",
-                "chat.write",
-            ].map((operation) => ({
-                operation,
-                platform: "bluesky",
-                availability: operation.startsWith("chat.")
-                    ? "available"
-                    : "available",
-            })),
-        ],
-    };
-    async function xrpc(method, context, init = {}) {
-        try {
-            return await http({
-                url: endpoint(service, method),
-                timeoutMs: remainingBudget(context),
-                method: init.body === undefined ? "GET" : "POST",
-                ...(options.session
-                    ? init.headers === undefined
-                        ? {}
-                        : { headers: init.headers }
-                    : { headers: { ...authHeaders(auth), ...init.headers } }),
-                ...(init.body === undefined ? {} : { body: init.body }),
-                ...(context.signal === undefined ? {} : { signal: context.signal }),
-                maxAttempts: init.maxAttempts ??
-                    (init.body === undefined ? Math.min(context.retryBudget.maxAttempts, 3) : 1),
-            });
-        }
-        catch (error) {
-            throw operationError(`bluesky.${method}`, error, init.body !== undefined);
-        }
-    }
-    async function verifiedSession(context) {
-        const session = object(await xrpc(options.session
-            ? `app.bsky.actor.getProfile?actor=${encodeURIComponent(auth.did)}`
-            : "com.atproto.server.getSession", context));
-        const did = string(session["did"]);
-        if (did !== auth.did) {
-            throw new SocialError({
-                code: "unauthorized",
-                operation: "bluesky.accounts.get",
-                message: "The configured credential belongs to a different DID.",
-            });
-        }
-        const handle = typeof session["handle"] === "string" ? session["handle"] : undefined;
-        return { did, ...(handle === undefined ? {} : { handle }) };
-    }
-    const nativeContext = (context, operation) => context ?? {
-        correlationId: operation,
-        retryBudget: { maxAttempts: 2, maxElapsedMs: 30_000 },
-        backendInstance: backend,
-    };
-    const assertNativeAccount = (selected, context, operation) => {
-        if (!accountMatches(selected, auth, backend) || context.backendInstance !== backend)
-            throw new SocialError({
-                code: "unauthorized",
-                operation,
-                message: "Account reference does not belong to this Bluesky adapter.",
-            });
-    };
-    const native = {
-        async getPost(input) {
-            const context = input.context ?? {
-                correlationId: "bluesky-native",
-                retryBudget: { maxAttempts: 2, maxElapsedMs: 30_000 },
-                backendInstance: backend,
-            };
-            const query = new URLSearchParams({ uris: input.uri });
-            const response = object(await xrpc(`app.bsky.feed.getPosts?${query.toString()}`, context));
-            const posts = array(response["posts"]);
-            const post = posts.find((value) => object(value)["uri"] === input.uri);
-            if (post === undefined)
-                throw new SocialError({
-                    code: "upstream_failure",
-                    operation: "bluesky.getPost",
-                    message: "Bluesky post was not found.",
-                });
-            return object(post);
-        },
-        async getPostThread(input) {
-            const context = input.context ?? {
-                correlationId: "bluesky-native",
-                retryBudget: { maxAttempts: 2, maxElapsedMs: 30_000 },
-                backendInstance: backend,
-            };
-            const query = new URLSearchParams({ uri: input.uri });
-            return object(await xrpc(`app.bsky.feed.getPostThread?${query.toString()}`, context));
-        },
-        async likePost(input) {
-            if (!accountMatches(input.account, auth, backend) ||
-                (input.context && input.context.backendInstance !== backend))
-                throw new SocialError({
-                    code: "unauthorized",
-                    operation: "bluesky.reactions.like",
-                    message: "Account reference does not belong to this Bluesky adapter.",
-                });
-            if (!/^at:\/\/did:[a-z]+:[A-Za-z0-9._:%-]+\/app\.bsky\.feed\.post\/[A-Za-z0-9._~:-]{1,512}$/.test(input.post.uri) ||
-                !/^[A-Za-z0-9]{1,2048}$/.test(input.post.cid))
-                throw new SocialError({
-                    code: "invalid_input",
-                    operation: "bluesky.reactions.like",
-                    message: "Provide the native post URI and CID returned by a Bluesky read.",
-                });
-            const context = input.context ?? {
-                correlationId: "bluesky-like",
-                retryBudget: { maxAttempts: 1, maxElapsedMs: 30_000 },
-                backendInstance: backend,
-            };
-            const response = object(await xrpc("com.atproto.repo.createRecord", context, {
-                body: JSON.stringify({
-                    repo: auth.did,
-                    collection: "app.bsky.feed.like",
-                    record: {
-                        $type: "app.bsky.feed.like",
-                        subject: { uri: input.post.uri, cid: input.post.cid },
-                        createdAt: new Date().toISOString(),
-                    },
-                }),
-            }));
-            const prefix = `at://${auth.did}/app.bsky.feed.like/`;
-            const uri = response["uri"], cid = response["cid"];
-            if (typeof uri !== "string" ||
-                !uri.startsWith(prefix) ||
-                !/^[A-Za-z0-9._~:-]{1,512}$/.test(uri.slice(prefix.length)) ||
-                typeof cid !== "string" ||
-                !cid)
-                throw new SocialError({
-                    code: "ambiguous_outcome",
-                    operation: "bluesky.reactions.like",
-                    message: "Bluesky did not return an owned like record. Reconcile before retrying.",
-                    retryDisposition: { kind: "reconcile-first" },
-                });
-            return { uri, cid };
-        },
-        async unlikePost(input) {
-            if (!accountMatches(input.account, auth, backend) ||
-                (input.context && input.context.backendInstance !== backend))
-                throw new SocialError({
-                    code: "unauthorized",
-                    operation: "bluesky.reactions.unlike",
-                    message: "Account reference does not belong to this Bluesky adapter.",
-                });
-            const context = input.context ?? {
-                correlationId: "bluesky-unlike",
-                retryBudget: { maxAttempts: 1, maxElapsedMs: 30_000 },
-                backendInstance: backend,
-            };
-            const prefix = `at://${auth.did}/app.bsky.feed.like/`;
-            const recordKey = input.likeUri.startsWith(prefix) ? input.likeUri.slice(prefix.length) : "";
-            if (!/^[A-Za-z0-9._~:-]{1,512}$/.test(recordKey) || recordKey === "." || recordKey === "..")
-                throw new SocialError({
-                    code: "unauthorized",
-                    operation: "bluesky.reactions.unlike",
-                    message: "Like record must belong to this Bluesky account.",
-                });
-            await xrpc("com.atproto.repo.deleteRecord", context, {
-                body: JSON.stringify({ repo: auth.did, collection: "app.bsky.feed.like", rkey: recordKey }),
-            });
-        },
-        async repostPost(input) {
-            const context = nativeContext(input.context, "bluesky.repost");
-            assertNativeAccount(input.account, context, "bluesky.repost");
-            const result = object(await xrpc("com.atproto.repo.createRecord", context, {
-                body: JSON.stringify({
-                    repo: auth.did,
-                    collection: "app.bsky.feed.repost",
-                    record: {
-                        $type: "app.bsky.feed.repost",
-                        subject: input.post,
-                        createdAt: new Date().toISOString(),
-                    },
-                }),
-            }));
-            return postRef(result);
-        },
-        async quotePost(input) {
-            const context = nativeContext(input.context, "bluesky.quote");
-            assertNativeAccount(input.account, context, "bluesky.quote");
-            if (!input.text.trim() || input.text.length > 300)
-                throw new SocialError({
-                    code: "invalid_input",
-                    operation: "bluesky.quote",
-                    message: "Quote text must be 1-300 characters.",
-                });
-            const result = object(await xrpc("com.atproto.repo.createRecord", context, {
-                body: JSON.stringify({
-                    repo: auth.did,
-                    collection: "app.bsky.feed.post",
-                    record: {
-                        $type: "app.bsky.feed.post",
-                        text: input.text,
-                        createdAt: new Date().toISOString(),
-                        embed: { $type: "app.bsky.embed.record", record: input.post },
-                    },
-                }),
-            }));
-            return postRef(result);
-        },
-        async deletePost(input) {
-            const context = nativeContext(input.context, "bluesky.delete");
-            assertNativeAccount(input.account, context, "bluesky.delete");
-            const prefix = `at://${auth.did}/app.bsky.feed.post/`;
-            const rkey = input.post.uri.startsWith(prefix) ? input.post.uri.slice(prefix.length) : "";
-            if (!rkey)
-                throw new SocialError({
-                    code: "unauthorized",
-                    operation: "bluesky.delete",
-                    message: "Post URI does not belong to this account.",
-                });
-            await xrpc("com.atproto.repo.deleteRecord", context, {
-                body: JSON.stringify({ repo: auth.did, collection: "app.bsky.feed.post", rkey }),
-            });
-        },
-        async uploadVideo(input) {
-            const context = nativeContext(input.context, "bluesky.video.upload");
-            assertNativeAccount(input.account, context, "bluesky.video.upload");
-            if (!input.video.type.startsWith("video/") || input.video.size <= 0)
-                throw new SocialError({
-                    code: "invalid_input",
-                    operation: "bluesky.video.upload",
-                    message: "Provide a non-empty video Blob.",
-                });
-            return object(await xrpc("app.bsky.video.uploadVideo", context, {
-                body: input.video,
-                headers: { "Content-Type": input.mimeType ?? input.video.type },
-            }));
-        },
-        async follow(input) {
-            const context = nativeContext(input.context, "bluesky.follow");
-            assertNativeAccount(input.account, context, "bluesky.follow");
-            return object(await xrpc("com.atproto.repo.createRecord", context, {
-                body: JSON.stringify({
-                    repo: auth.did,
-                    collection: "app.bsky.graph.follow",
-                    record: {
-                        $type: "app.bsky.graph.follow",
-                        subject: input.did,
-                        createdAt: new Date().toISOString(),
-                    },
-                }),
-            }));
-        },
-        async block(input) {
-            const context = nativeContext(input.context, "bluesky.block");
-            assertNativeAccount(input.account, context, "bluesky.block");
-            return object(await xrpc("com.atproto.repo.createRecord", context, {
-                body: JSON.stringify({
-                    repo: auth.did,
-                    collection: "app.bsky.graph.block",
-                    record: {
-                        $type: "app.bsky.graph.block",
-                        subject: input.did,
-                        createdAt: new Date().toISOString(),
-                    },
-                }),
-            }));
-        },
-        async mute(input) {
-            const context = nativeContext(input.context, "bluesky.mute");
-            assertNativeAccount(input.account, context, "bluesky.mute");
-            return object(await xrpc("app.bsky.graph.muteActor", context, {
-                body: JSON.stringify({ actor: input.did }),
-            }));
-        },
-        async listNotifications(input) {
-            const context = nativeContext(input.context, "bluesky.notifications.list");
-            assertNativeAccount(input.account, context, "bluesky.notifications.list");
-            const query = new URLSearchParams({
-                limit: String(input.limit ?? 50),
-                ...(input.cursor ? { cursor: input.cursor } : {}),
-            });
-            return object(await xrpc(`app.bsky.notification.listNotifications?${query}`, context));
-        },
-        async markNotificationsSeen(input) {
-            const context = nativeContext(input.context, "bluesky.notifications.seen");
-            assertNativeAccount(input.account, context, "bluesky.notifications.seen");
-            await xrpc("app.bsky.notification.updateSeen", context, {
-                body: JSON.stringify({ seenAt: input.seenAt ?? new Date().toISOString() }),
-            });
-        },
-        async getProfile(input) {
-            const context = nativeContext(input.context, "bluesky.profile.get");
-            assertNativeAccount(input.account, context, "bluesky.profile.get");
-            return object(await xrpc(`app.bsky.actor.getProfile?actor=${encodeURIComponent(input.actor ?? auth.did)}`, context));
-        },
-        async updateProfile(input) {
-            const context = nativeContext(input.context, "bluesky.profile.update");
-            assertNativeAccount(input.account, context, "bluesky.profile.update");
-            await xrpc("com.atproto.repo.putRecord", context, {
-                body: JSON.stringify({
-                    repo: auth.did,
-                    collection: "app.bsky.actor.profile",
-                    rkey: "self",
-                    record: input.profile,
-                }),
-            });
-        },
-        async listFeeds(input) {
-            const context = nativeContext(input.context, "bluesky.feeds.list");
-            assertNativeAccount(input.account, context, "bluesky.feeds.list");
-            const query = new URLSearchParams({
-                limit: String(input.limit ?? 50),
-                ...(input.cursor ? { cursor: input.cursor } : {}),
-            });
-            return object(await xrpc(`app.bsky.feed.getSuggestedFeeds?${query}`, context));
-        },
-        async listConversations(input) {
-            const context = nativeContext(input.context, "bluesky.chat.list");
-            assertNativeAccount(input.account, context, "bluesky.chat.list");
-            const query = new URLSearchParams({
-                limit: String(input.limit ?? 50),
-                ...(input.cursor ? { cursor: input.cursor } : {}),
-            });
-            return object(await xrpc(`chat.bsky.convo.listConvos?${query}`, context));
-        },
-        async listMessages(input) {
-            const context = nativeContext(input.context, "bluesky.chat.messages");
-            assertNativeAccount(input.account, context, "bluesky.chat.messages");
-            const query = new URLSearchParams({
-                limit: String(input.limit ?? 50),
-                ...(input.cursor ? { cursor: input.cursor } : {}),
-            });
-            return object(await xrpc(`chat.bsky.convo.getMessages?convoId=${encodeURIComponent(input.conversationId)}&${query}`, context));
-        },
-        async sendMessage(input) {
-            const context = nativeContext(input.context, "bluesky.chat.send");
-            assertNativeAccount(input.account, context, "bluesky.chat.send");
-            if (!input.text.trim())
-                throw new SocialError({
-                    code: "invalid_input",
-                    operation: "bluesky.chat.send",
-                    message: "Message text is required.",
-                });
-            return object(await xrpc("chat.bsky.convo.sendMessage", context, {
-                body: JSON.stringify({ convoId: input.conversationId, message: { text: input.text } }),
-            }));
-        },
-    };
-    const adapter = defineAdapter({
-        id: backend,
-        capabilities,
-        native,
-        accounts: {
-            async list(_input, context) {
-                const session = await verifiedSession(context);
-                return {
-                    items: [
-                        {
-                            ref: account,
-                            displayName: session.handle ?? session.did,
-                            ...(session.handle === undefined ? {} : { handle: session.handle }),
-                            status: "connected",
-                        },
-                    ],
-                };
-            },
-            async get(ref, context) {
-                if (!accountMatches(ref, auth, backend))
-                    throw new SocialError({
-                        code: "unauthorized",
-                        operation: "bluesky.accounts.get",
-                        message: "The account reference does not belong to this Bluesky adapter.",
-                        account: ref,
-                    });
-                const session = await verifiedSession(context);
-                return {
-                    ref: account,
-                    displayName: session.handle ?? session.did,
-                    ...(session.handle === undefined ? {} : { handle: session.handle }),
-                    status: "connected",
-                };
-            },
-        },
-        posts: {
-            async list(account, input, context) {
-                if (!accountMatches(account, auth, backend))
-                    throw new SocialError({
-                        code: "unauthorized",
-                        operation: "bluesky.posts.list",
-                        message: "The account reference does not belong to this adapter.",
-                    });
-                const limit = input.limit ?? 50;
-                if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)
-                    throw new SocialError({
-                        code: "invalid_input",
-                        operation: "posts.read",
-                        message: "Bluesky author-feed page size must be between 1 and 100.",
-                    });
-                const query = new URLSearchParams({
-                    actor: auth.did,
-                    limit: String(limit),
-                    ...(input.cursor === undefined ? {} : { cursor: input.cursor }),
-                });
-                const response = object(await xrpc(`app.bsky.feed.getAuthorFeed?${query.toString()}`, context));
-                const feed = array(response["feed"]).map((value) => {
-                    const entry = object(value);
-                    const post = object(entry["post"]);
-                    const safePost = {
-                        ...publicFields(post, [
-                            "uri",
-                            "cid",
-                            "likeCount",
-                            "repostCount",
-                            "replyCount",
-                            "quoteCount",
-                            "indexedAt",
-                            "labels",
-                        ]),
-                        ...(post["author"] === undefined
-                            ? {}
-                            : {
-                                author: publicFields(object(post["author"]), [
-                                    "did",
-                                    "handle",
-                                    "displayName",
-                                    "avatar",
-                                ]),
-                            }),
-                        ...(post["record"] === undefined
-                            ? {}
-                            : {
-                                record: publicFields(object(post["record"]), [
-                                    "text",
-                                    "facets",
-                                    "createdAt",
-                                    "reply",
-                                    "embed",
-                                ]),
-                            }),
-                    };
-                    return {
-                        post: safePost,
-                        ...(entry["reason"] === undefined
-                            ? {}
-                            : { reason: publicFields(object(entry["reason"]), ["$type", "by", "indexedAt"]) }),
-                    };
-                });
-                const cursor = typeof response["cursor"] === "string" ? response["cursor"] : undefined;
-                return {
-                    items: feed,
-                    ...(cursor === undefined ? {} : { nextCursor: cursor }),
-                };
-            },
-            prepareTarget(target) {
-                const issues = [];
-                const text = target.content.text ?? "";
-                try {
-                    richTextOptions(text, target.options);
-                }
-                catch (error) {
-                    issues.push({
-                        code: "bluesky.richtext",
-                        message: error instanceof Error ? error.message : "Invalid Bluesky rich text options.",
-                        severity: "error",
-                    });
-                }
-                if (new TextEncoder().encode(text).byteLength > 3000 || graphemeCount(text) > 300)
-                    issues.push({
-                        code: "text.too_long",
-                        message: "Bluesky posts must be at most 300 graphemes and 3,000 UTF-8 bytes.",
-                        severity: "error",
-                    });
-                if (target.account.platform !== "bluesky")
-                    issues.push({
-                        code: "platform.unsupported",
-                        message: "Bluesky adapter received a different platform.",
-                        severity: "error",
-                    });
-                if (target.schedule !== undefined)
-                    issues.push({
-                        code: "schedule.unsupported",
-                        message: "Bluesky scheduling requires an application-owned job runner.",
-                        severity: "error",
-                    });
-                if (target.content.media?.some((media) => media.kind !== "image"))
-                    issues.push({
-                        code: "media.unsupported",
-                        message: "Bluesky direct publishing supports images, not video.",
-                        severity: "error",
-                    });
-                if ((target.content.media?.length ?? 0) > MAX_IMAGES)
-                    issues.push({
-                        code: "media.too_many",
-                        message: `Bluesky supports at most ${MAX_IMAGES} images per post.`,
-                        severity: "error",
-                    });
-                return issues;
-            },
-            async publishTarget(target, context) {
-                if (!accountMatches(target.account, auth, backend))
-                    throw new SocialError({
-                        code: "unauthorized",
-                        operation: "bluesky.publish",
-                        message: "The account reference does not belong to this adapter.",
-                        account: target.account,
-                    });
-                try {
-                    const content = target.content;
-                    const text = content.text ?? "";
-                    const record = {
-                        $type: "app.bsky.feed.post",
-                        text,
-                        createdAt: new Date().toISOString(),
-                    };
-                    Object.assign(record, richTextOptions(text, target.options));
-                    if (target.replyTo !== undefined) {
-                        if (target.replyTo.kind !== "platform-post")
-                            throw new SocialError({
-                                code: "unsupported_capability",
-                                operation: "bluesky.reply",
-                                message: "Bluesky replies require a platform post reference.",
-                            });
-                        const parent = await native.getPost({
-                            uri: target.replyTo.native?.["uri"]?.toString() ?? target.replyTo.postId,
-                            context,
-                        });
-                        const parentRecord = object(parent["record"]);
-                        const parentRef = target.replyTo.native === undefined
-                            ? { uri: string(parent["uri"]), cid: string(parent["cid"]) }
-                            : {
-                                uri: string(target.replyTo.native["uri"]),
-                                cid: string(target.replyTo.native["cid"]),
-                            };
-                        const rootValue = parentRecord["reply"];
-                        const root = rootValue === undefined ? parentRef : object(object(rootValue)["root"]);
-                        Object.assign(record, { reply: { root, parent: parentRef } });
-                    }
-                    if (content.media !== undefined && content.media.length > 0) {
-                        const blobs = [];
-                        for (const media of content.media) {
-                            const source = await readMedia(media.source, fetcher, context, allowMediaHost);
-                            const blob = object(await xrpc("com.atproto.repo.uploadBlob", context, {
-                                body: new Blob([source.bytes.slice().buffer], {
-                                    type: source.mimeType,
-                                }),
-                                headers: { "Content-Type": source.mimeType },
-                            }));
-                            blobs.push(object(blob["blob"]));
-                        }
-                        Object.assign(record, {
-                            embed: {
-                                $type: "app.bsky.embed.images",
-                                images: blobs.map((blob, index) => ({
-                                    image: blob,
-                                    alt: content.media?.[index]?.altText ?? "",
-                                })),
-                            },
-                        });
-                    }
-                    const response = object(await xrpc("com.atproto.repo.createRecord", context, {
-                        body: JSON.stringify({ repo: auth.did, collection: "app.bsky.feed.post", record }),
-                        headers: { "Content-Type": "application/json" },
-                    }));
-                    const created = postRef(response);
-                    const delivery = {
-                        kind: "delivery",
-                        version: 1,
-                        backend,
-                        deliveryId: created.uri,
-                        platform: "bluesky",
-                        accountId: auth.did,
-                    };
-                    return {
-                        state: "published",
-                        targetIndex: target.targetIndex,
-                        account: target.account,
-                        delivery,
-                        post: {
-                            ...platformPostRef({
-                                backend,
-                                platform: "bluesky",
-                                accountId: auth.did,
-                                postId: created.uri,
-                            }),
-                            native: { uri: created.uri, cid: created.cid },
-                        },
-                        observedAt: new Date().toISOString(),
-                    };
-                }
-                catch (error) {
-                    throw operationError("bluesky.publish", error);
-                }
-            },
-            async get(ref, context) {
-                if (ref.backend !== backend || ref.platform !== "bluesky" || ref.accountId !== auth.did)
-                    throw new SocialError({
-                        code: "unauthorized",
-                        operation: "bluesky.posts.get",
-                        message: "The account reference does not belong to this adapter.",
-                    });
-                return native.getPost({ uri: ref.postId, context });
-            },
-        },
-        comments: {
-            async list(post, input, context) {
-                if (input.cursor !== undefined)
-                    throw new SocialError({
-                        code: "unsupported_capability",
-                        operation: "comments.read",
-                        message: "This adapter does not expose upstream comment pagination.",
-                    });
-                const thread = await native.getPostThread({ uri: post.postId, context });
-                const replies = array(object(thread["thread"])["replies"] ?? []);
-                return { items: replies.map((reply) => object(reply)) };
-            },
-            async reply(comment, content, context) {
-                const outcome = await adapter.posts?.publishTarget({
-                    targetIndex: 0,
-                    targetKey: comment.backend + ":" + comment.platform + ":" + comment.accountId,
-                    account: connectedAccountRef({
-                        backend: comment.backend,
-                        platform: "bluesky",
-                        accountId: comment.accountId,
-                    }),
-                    content: { text: content.text },
-                    replyTo: platformPostRef({
-                        backend: comment.backend,
-                        platform: "bluesky",
-                        accountId: comment.accountId,
-                        postId: comment.commentId,
-                    }),
-                }, context);
-                if (outcome?.state !== "published")
-                    throw new SocialError({
-                        code: "upstream_failure",
-                        operation: "bluesky.comments.reply",
-                        message: "Bluesky did not confirm the comment reply.",
-                    });
-                return {
-                    kind: "comment",
-                    version: 1,
-                    backend: comment.backend,
-                    platform: "bluesky",
-                    accountId: comment.accountId,
-                    postId: comment.postId,
-                    commentId: outcome.post.postId,
-                };
-            },
-        },
-        analytics: {
-            async getPostMetrics(post, context) {
-                const value = await native.getPost({ uri: post.postId, context });
-                const record = object(value);
-                const fetchedAt = new Date().toISOString();
-                const metrics = [];
-                for (const [name, field] of [
-                    ["likes", "likeCount"],
-                    ["reposts", "repostCount"],
-                    ["replies", "replyCount"],
-                    ["quotes", "quoteCount"],
-                ]) {
-                    const count = record[field];
-                    if (typeof count === "number" && Number.isFinite(count))
-                        metrics.push({
-                            name,
-                            value: count,
-                            unit: "count",
-                            period: "lifetime",
-                            fetchedAt,
-                            freshness: "unknown",
-                            source: "app.bsky.feed.getPosts",
-                        });
-                }
-                return metrics;
-            },
-            async getAccountMetrics(accountRef, context) {
-                // https://docs.bsky.app/docs/api/app-bsky-actor-get-profile
-                if (!accountMatches(accountRef, auth, backend))
-                    throw new SocialError({
-                        code: "unauthorized",
-                        operation: "bluesky.analytics.account",
-                        message: "Account reference does not belong to this Bluesky adapter.",
-                    });
-                const profile = object(await xrpc(`app.bsky.actor.getProfile?actor=${encodeURIComponent(auth.did)}`, context));
-                if (profile["did"] !== auth.did)
-                    throw new SocialError({
-                        code: "unauthorized",
-                        operation: "bluesky.analytics.account",
-                        message: "Bluesky profile identity does not match the requested DID.",
-                    });
-                const fetchedAt = new Date().toISOString();
-                return [
-                    ["followers", profile["followersCount"]],
-                    ["following", profile["followsCount"]],
-                    ["posts", profile["postsCount"]],
-                ].flatMap(([name, value]) => typeof value === "number" && Number.isFinite(value)
-                    ? [
-                        {
-                            name,
-                            value,
-                            unit: "count",
-                            period: "lifetime",
-                            fetchedAt,
-                            freshness: "unknown",
-                            source: "app.bsky.actor.getProfile",
-                        },
-                    ]
-                    : []);
-            },
-        },
-    });
-    return adapter;
-}
-//# sourceMappingURL=bluesky.js.map