@opencoredev/social-sdk 0.2.1 → 0.4.0

package/dist/platforms/x.js

@@ -1,19 +1,28 @@
-/* oxlint-disable anti-slop/no-conditional-empty-object-spread, anti-slop/no-runtime-typeof, anti-slop/require-readable-spacing, anti-slop/require-safety-comment-for-type-assertion -- validated external boundary or fixture contract. */
 import { remainingBudget } from "../transport/budget.js";
+import { definedFields } from "../core/fields.js";
 import { isValidXText } from "./x-text.js";
 import { defineAdapter } from "../core/adapter.js";
 import { connectedAccountRef, profileRef } from "../core/types.js";
 import { SocialError } from "../core/errors.js";
-import { managedHttp, publicFields } from "../cloud/common.js";
+import { managedHttp, optionsObject, publicFields } from "../cloud/common.js";
+import { verifyXWebhook } from "../server/webhooks.js";
+import { directWebhooks, webhookCapability } from "./webhook-adapter.js";
 import { createHttp, HttpError } from "../transport/http.js";
-import { array, object as parseObject, optionalNumber, optionalString, string, } from "../transport/validation.js";
-// oxlint-disable-next-line anti-slop/no-unknown-parameters, anti-slop/require-safety-comment-for-type-assertion -- transport parser validates the provider boundary.
-const object = (value) => parseObject(value);
-// 53-bit conversation ID hashes, 11 base36 characters each. listConversations returns at
-// most 1,200 distinct conversations, which keeps its cursor well under the client's 16,384
-// character cursor limit.
+import { isJsonValue } from "../transport/json.js";
+import { parseRulesUpdate, parseStreamRule, readFilteredStream, validateRuleIds, validateRuleInput, } from "./x-stream.js";
+import { array, isString, object, optionalBoolean, optionalNumber, optionalString, string, } from "../transport/validation.js";
 const conversationHashWidth = 11;
 const maxConversationHashes = 1200;
+const replyFields = [
+    "id",
+    "text",
+    "author_id",
+    "created_at",
+    "conversation_id",
+    "in_reply_to_user_id",
+    "referenced_tweets",
+    "public_metrics",
+];
 function conversationHash(id) {
     let h1 = 0xdeadbeef;
     let h2 = 0x41c6ce57;
@@ -28,11 +37,11 @@ function conversationHash(id) {
     return value.toString(36).padStart(conversationHashWidth, "0");
 }
 export { xLike, xUnlike } from "./x-engagement.js";
+export { xStreamDefaultStallTimeoutMs, } from "./x-stream.js";
 export function x(options) {
     const request = managedHttp("https://api.x.com", {
         apiKey: options.auth.accessToken ?? "app-auth-placeholder",
-        // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-        ...(options.fetch ? { fetch: options.fetch } : {}),
+        ...definedFields({ fetch: options.fetch }),
     });
     const appRequest = () => {
         if (!options.appBearerToken?.trim())
@@ -43,8 +52,7 @@ export function x(options) {
             });
         return managedHttp("https://api.x.com", {
             apiKey: options.appBearerToken,
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated external boundary or fixture contract.
-            ...(options.fetch ? { fetch: options.fetch } : {}),
+            ...definedFields({ fetch: options.fetch }),
         });
     };
     const requireUserToken = (operation) => {
@@ -61,7 +69,7 @@ export function x(options) {
         : options.auth.accessToken?.trim()
             ? request
             : appRequest();
-    const http = createHttp(options.fetch ? { fetch: options.fetch } : {});
+    const http = createHttp(definedFields({ fetch: options.fetch }));
     const now = () => (options.clock?.() ?? new Date()).toISOString();
     const authorize = (ref, context) => {
         if (ref.backend !== context.backendInstance ||
@@ -90,15 +98,7 @@ export function x(options) {
                 accountId: options.auth.userId,
             },
             displayName: string(user["name"]),
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-            // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- provider payload is validated at this adapter boundary.
-            // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated external boundary or fixture contract.
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated external boundary or fixture contract.
-            // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated external boundary or fixture contract.
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated external boundary or fixture contract.
-            // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated external boundary or fixture contract.
-            ...(typeof user["username"] === "string" ? { handle: user["username"] } : {}),
+            ...definedFields({ handle: optionalString(user["username"]) }),
             status: "connected",
         };
     }
@@ -113,7 +113,6 @@ export function x(options) {
                 operation: "posts.read",
                 message: "X post identity or author does not match the declared reference.",
             });
-        // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- validated boundary or fixture contract.
         return result;
     }
     async function listPosts(account, input, context) {
@@ -127,10 +126,10 @@ export function x(options) {
             });
         const result = object(await request(`/2/users/${encodeURIComponent(account.accountId)}/tweets`, context, undefined, {
             "tweet.fields": "id,text,author_id,created_at,conversation_id",
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-            ...(input.cursor === undefined ? {} : { pagination_token: input.cursor }),
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-            ...(input.limit === undefined ? {} : { max_results: String(input.limit) }),
+            ...definedFields({
+                pagination_token: input.cursor,
+                max_results: input.limit?.toString(),
+            }),
         }));
         const items = (result["data"] === undefined ? [] : array(result["data"])).map((entry) => {
             const row = object(entry);
@@ -147,8 +146,7 @@ export function x(options) {
         const nextCursor = optionalString(meta["next_token"]);
         return {
             items,
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-            ...(nextCursor === undefined ? {} : { nextCursor }),
+            ...definedFields({ nextCursor }),
         };
     }
     async function searchPosts(account, input, context, nativeInput) {
@@ -207,28 +205,16 @@ export function x(options) {
             ]
                 .filter((field, index, fields) => fields.indexOf(field) === index)
                 .join(","),
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-            ...(input.cursor === undefined ? {} : { next_token: input.cursor }),
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-            ...(input.limit === undefined ? {} : { max_results: String(input.limit) }),
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-            ...(input.startTime === undefined ? {} : { start_time: input.startTime }),
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-            ...(input.endTime === undefined ? {} : { end_time: input.endTime }),
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-            ...(nativeInput?.sortOrder === undefined ? {} : { sort_order: nativeInput.sortOrder }),
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-            ...(nativeInput?.expansions === undefined
-                ? {}
-                : { expansions: nativeInput.expansions.join(",") }),
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-            ...(nativeInput?.userFields === undefined
-                ? {}
-                : { "user.fields": nativeInput.userFields.join(",") }),
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-            ...(nativeInput?.mediaFields === undefined
-                ? {}
-                : { "media.fields": nativeInput.mediaFields.join(",") }),
+            ...definedFields({
+                next_token: input.cursor,
+                max_results: input.limit?.toString(),
+                start_time: input.startTime,
+                end_time: input.endTime,
+                sort_order: nativeInput?.sortOrder,
+                expansions: nativeInput?.expansions?.join(","),
+                "user.fields": nativeInput?.userFields?.join(","),
+                "media.fields": nativeInput?.mediaFields?.join(","),
+            }),
         }));
         const requestedFields = nativeInput?.tweetFields ?? [
             "id",
@@ -244,22 +230,96 @@ export function x(options) {
         ];
         const items = (result["data"] === undefined ? [] : array(result["data"])).map((entry) => {
             const row = object(entry);
-            return Object.fromEntries(["id", "text", ...requestedFields].flatMap((field, index, fields) => fields.indexOf(field) === index && field in row ? [[field, row[field]]] : []));
+            const picked = {};
+            // A Set keeps first-seen order, so "id" and "text" lead and repeated fields appear once.
+            for (const field of new Set(["id", "text", ...requestedFields])) {
+                const value = row[field];
+                if (value !== undefined)
+                    picked[field] = value;
+            }
+            return picked;
         });
         const meta = result["meta"] === undefined ? {} : object(result["meta"]);
         const nextCursor = optionalString(meta["next_token"]);
         const includes = result["includes"];
         return {
             items,
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-            ...(nextCursor === undefined ? {} : { nextCursor }),
-            ...(includes === undefined
-                ? {}
-                : {
-                    // SAFETY: X's `includes` member is a JSON object validated by the transport boundary.
-                    metadata: { includes: object(includes) },
-                }),
+            ...definedFields({
+                nextCursor,
+                metadata: includes === undefined ? undefined : { includes: object(includes) },
+            }),
+        };
+    }
+    // Replies come from recent search with the standalone `conversation_id:` operator, which is
+    // the method X documents for reading a conversation. Sources, accessed 2026-09-24:
+    // https://docs.x.com/x-api/fundamentals/conversation-id
+    // https://docs.x.com/x-api/posts/search/integrate/operators
+    // https://docs.x.com/x-api/posts/search-recent-posts (max_results 10-100, next_token)
+    // https://docs.x.com/x-api/posts/search/introduction (recent search covers the last 7 days)
+    // https://docs.x.com/x-api/fundamentals/rate-limits (450/15min per app, 300/15min per user)
+    async function listReplies(post, input, context) {
+        authorize(post, context);
+        if (!/^[0-9]{1,19}$/.test(post.postId))
+            throw new SocialError({
+                code: "invalid_input",
+                operation: "comments.read",
+                message: "X post IDs must be numeric.",
+            });
+        if (input.limit !== undefined &&
+            (!Number.isSafeInteger(input.limit) || input.limit < 10 || input.limit > 100))
+            throw new SocialError({
+                code: "invalid_input",
+                operation: "comments.read",
+                message: "X reply limits must be integers from 10 through 100.",
+            });
+        const query = {
+            query: `conversation_id:${post.postId}`,
+            "tweet.fields": replyFields.join(","),
         };
+        if (input.cursor !== undefined) {
+            query["next_token"] = input.cursor;
+        }
+        if (input.limit !== undefined) {
+            query["max_results"] = String(input.limit);
+        }
+        const result = object(await (options.auth.accessToken?.trim() ? request : appRequest())("/2/tweets/search/recent", context, undefined, query));
+        const items = (result["data"] === undefined ? [] : array(result["data"])).flatMap((entry) => {
+            const row = object(entry);
+            const id = string(row["id"]);
+            if (row["conversation_id"] !== post.postId)
+                throw new SocialError({
+                    code: "unauthorized",
+                    operation: "comments.read",
+                    message: "X returned a post from a different conversation.",
+                });
+            // The conversation root shares its own conversation_id; it is not a reply.
+            if (id === post.postId)
+                return [];
+            const references = row["referenced_tweets"] === undefined
+                ? undefined
+                : array(row["referenced_tweets"]).map((reference) => {
+                    const item = object(reference);
+                    return { type: string(item["type"]), id: string(item["id"]) };
+                });
+            const counts = row["public_metrics"] === undefined ? undefined : object(row["public_metrics"]);
+            const metrics = counts === undefined
+                ? undefined
+                : Object.fromEntries(Object.keys(counts).flatMap((name) => {
+                    const value = optionalNumber(counts[name]);
+                    return value === undefined ? [] : [[name, value]];
+                }));
+            const itemFields = definedFields({
+                ...publicFields(row, replyFields),
+                referenced_tweets: references,
+                public_metrics: metrics,
+            });
+            return [itemFields];
+        });
+        const meta = result["meta"] === undefined ? {} : object(result["meta"]);
+        const nextCursor = optionalString(meta["next_token"]);
+        if (nextCursor === undefined)
+            return { items };
+        return { items, nextCursor };
     }
     async function pageRequest(path, account, input, context, query = {}, fields = "id,name,username,description,created_at,public_metrics", resource = "users") {
         authorize(account, context);
@@ -285,13 +345,12 @@ export function x(options) {
                     : fields
                         ? { "user.fields": fields }
                         : {}),
-            ...(input.cursor === undefined ? {} : { pagination_token: input.cursor }),
-            ...(input.limit === undefined ? {} : { max_results: String(input.limit) }),
+            ...definedFields({ pagination_token: input.cursor, max_results: input.limit?.toString() }),
         }));
-        const items = (result["data"] === undefined ? [] : array(result["data"])).map((entry) => object(entry));
+        const items = (result["data"] === undefined ? [] : array(result["data"])).map(object);
         const meta = result["meta"] === undefined ? {} : object(result["meta"]);
         const nextCursor = optionalString(meta["next_token"]);
-        return { items, ...(nextCursor === undefined ? {} : { nextCursor }) };
+        return { items, ...definedFields({ nextCursor }) };
     }
     async function getAccountMetrics(account, context) {
         authorize(account, context);
@@ -341,8 +400,7 @@ export function x(options) {
                 "tweet.fields": "conversation_id",
             }))["data"]);
             if (root["id"] !== ref.postId ||
-                // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-                (typeof parent["conversation_id"] === "string" &&
+                (isString(parent["conversation_id"]) &&
                     parent["conversation_id"] !== root["conversation_id"]))
                 throw new SocialError({
                     code: "unauthorized",
@@ -372,8 +430,7 @@ export function x(options) {
                 headers: { Authorization: `Bearer ${options.auth.accessToken}` },
                 body,
                 timeoutMs: remainingBudget(context),
-                // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-                ...(context.signal ? { signal: context.signal } : {}),
+                ...definedFields({ signal: context.signal }),
             });
         }
         catch (error) {
@@ -396,6 +453,265 @@ export function x(options) {
             });
         return string(data["id"]);
     }
+    const xChunkBytes = 1024 * 1024;
+    const xMaxVideoBytes = 512 * 1024 * 1024;
+    const xMaxGifBytes = 15 * 1024 * 1024;
+    const xMaxStatusPolls = 30;
+    function chunkedCategory(media) {
+        if (media.source.kind !== "blob")
+            return undefined;
+        if (media.kind === "video" && media.mimeType === "video/mp4")
+            return "tweet_video";
+        if (media.kind === "image" && media.mimeType === "image/gif")
+            return "tweet_gif";
+        return undefined;
+    }
+    function chunkedLimits(media, category) {
+        const size = media.source.kind === "blob" ? media.source.blob.size : 0;
+        const maxBytes = category === "tweet_video" ? xMaxVideoBytes : xMaxGifBytes;
+        if (size <= 0 || size > maxBytes)
+            throw new SocialError({
+                code: "invalid_input",
+                operation: "media.upload",
+                message: category === "tweet_video"
+                    ? "X video uploads require a non-empty MP4 Blob up to 512 MiB."
+                    : "X GIF uploads require a non-empty GIF Blob up to 15 MiB.",
+            });
+    }
+    function mediaHttpError(error) {
+        if (error.kind === "cancelled")
+            return new SocialError({
+                code: "cancelled",
+                operation: "media.upload",
+                message: "X media upload was cancelled before completion.",
+                upstreamStatus: error.status,
+            });
+        if (error.kind === "timeout")
+            return new SocialError({
+                code: "timeout",
+                operation: "media.upload",
+                message: "X media upload exceeded its elapsed budget. Reconcile before retrying.",
+                upstreamStatus: error.status,
+                retryDisposition: { kind: "never" },
+            });
+        if (error.status === 401)
+            return new SocialError({
+                code: "reconnect_required",
+                operation: "media.upload",
+                message: "X rejected the media upload credentials. Reconnect before retrying.",
+                upstreamStatus: error.status,
+                retryDisposition: { kind: "after-reconnect" },
+            });
+        if (error.status === 429)
+            return new SocialError({
+                code: "rate_limited",
+                operation: "media.upload",
+                message: "X rate-limited the media upload.",
+                upstreamStatus: error.status,
+                retryDisposition: error.retryAfterMs === undefined
+                    ? { kind: "never" }
+                    : { kind: "after-delay", delayMs: error.retryAfterMs },
+            });
+        if (error.status === 413)
+            return new SocialError({
+                code: "media_error",
+                operation: "media.upload",
+                message: "Media chunk rejected by X (payload too large).",
+                upstreamStatus: error.status,
+                retryDisposition: { kind: "never" },
+            });
+        return new SocialError({
+            code: "media_error",
+            operation: "media.upload",
+            message: error.message,
+            upstreamStatus: error.status,
+            retryDisposition: { kind: "never" },
+        });
+    }
+    async function chunkedPost(path, body, context) {
+        requireUserToken("media.upload");
+        let result;
+        try {
+            result = await http({
+                url: new URL(`https://api.x.com${path}`),
+                method: "POST",
+                headers: body === undefined
+                    ? { Authorization: `Bearer ${options.auth.accessToken}` }
+                    : {
+                        Authorization: `Bearer ${options.auth.accessToken}`,
+                        "Content-Type": "application/json",
+                    },
+                timeoutMs: remainingBudget(context),
+                ...definedFields({
+                    body: body === undefined ? undefined : JSON.stringify(body),
+                    signal: context.signal,
+                }),
+            });
+        }
+        catch (error) {
+            if (!(error instanceof HttpError))
+                throw error;
+            throw mediaHttpError(error);
+        }
+        return object(object(result)["data"]);
+    }
+    async function appendChunk(mediaId, segmentIndex, chunk, context) {
+        requireUserToken("media.upload");
+        const body = new FormData();
+        body.set("segment_index", String(segmentIndex));
+        body.set("media", chunk, `chunk-${segmentIndex}`);
+        try {
+            await http({
+                url: new URL(`https://api.x.com/2/media/upload/${encodeURIComponent(mediaId)}/append`),
+                method: "POST",
+                headers: { Authorization: `Bearer ${options.auth.accessToken}` },
+                body,
+                timeoutMs: remainingBudget(context),
+                ...definedFields({ signal: context.signal }),
+            });
+        }
+        catch (error) {
+            if (!(error instanceof HttpError))
+                throw error;
+            throw mediaHttpError(error);
+        }
+    }
+    async function readMediaStatus(mediaId, context) {
+        requireUserToken("media.upload");
+        let result;
+        try {
+            result = await http({
+                url: new URL(`https://api.x.com/2/media/upload?command=STATUS&media_id=${encodeURIComponent(mediaId)}`),
+                method: "GET",
+                headers: { Authorization: `Bearer ${options.auth.accessToken}` },
+                timeoutMs: remainingBudget(context),
+                ...definedFields({ signal: context.signal }),
+            });
+        }
+        catch (error) {
+            if (!(error instanceof HttpError))
+                throw error;
+            throw mediaHttpError(error);
+        }
+        const data = object(object(result)["data"]);
+        const processing = data["processing_info"];
+        if (processing === undefined)
+            return { state: "succeeded", checkAfterSecs: 0 };
+        return processingState(object(processing));
+    }
+    function processingState(info) {
+        const checkAfter = optionalNumber(info["check_after_secs"]);
+        return {
+            state: optionalString(info["state"]) ?? "pending",
+            // X always sends check_after_secs while processing; a missing value must not spin the poll.
+            checkAfterSecs: checkAfter !== undefined && Number.isFinite(checkAfter) && checkAfter >= 0 ? checkAfter : 1,
+        };
+    }
+    function uploadCancelled() {
+        return new SocialError({
+            code: "cancelled",
+            operation: "media.upload",
+            message: "X media upload was cancelled before completion.",
+        });
+    }
+    function throwIfUploadCancelled(context) {
+        if (context.signal?.aborted)
+            throw uploadCancelled();
+    }
+    /** Waits for X's processing hint without outliving the shared operation budget. */
+    function processingWait(milliseconds, context) {
+        throwIfUploadCancelled(context);
+        if (milliseconds <= 0)
+            return Promise.resolve();
+        if (milliseconds >= remainingBudget(context))
+            throw new SocialError({
+                code: "timeout",
+                operation: "media.upload",
+                message: "X media processing needs longer than the remaining elapsed budget. No post was created.",
+                retryDisposition: { kind: "never" },
+            });
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                clearTimeout(timer);
+                reject(uploadCancelled());
+            };
+            const timer = setTimeout(() => {
+                context.signal?.removeEventListener("abort", onAbort);
+                resolve();
+            }, milliseconds);
+            context.signal?.addEventListener("abort", onAbort, { once: true });
+        });
+    }
+    async function uploadVideoOrGif(media, context) {
+        try {
+            return await chunkedUpload(media, context);
+        }
+        catch (error) {
+            // Malformed upload responses fail before any post request, so they are definite failures.
+            if (error instanceof HttpError)
+                throw mediaHttpError(error);
+            throw error;
+        }
+    }
+    async function chunkedUpload(media, context) {
+        requireUserToken("media.upload");
+        const category = chunkedCategory(media);
+        if (category === undefined || media.source.kind !== "blob")
+            throw new SocialError({
+                code: "invalid_input",
+                operation: "media.upload",
+                message: "X chunked upload requires a video/mp4 or image/gif Blob.",
+            });
+        chunkedLimits(media, category);
+        const blob = media.source.blob;
+        const totalBytes = blob.size;
+        const initialized = await chunkedPost("/2/media/upload/initialize", {
+            media_category: category,
+            media_type: category === "tweet_video" ? "video/mp4" : "image/gif",
+            total_bytes: totalBytes,
+        }, context);
+        const mediaId = string(initialized["id"]);
+        const segmentCount = Math.ceil(totalBytes / xChunkBytes);
+        for (let segmentIndex = 0; segmentIndex < segmentCount; segmentIndex++) {
+            throwIfUploadCancelled(context);
+            const start = segmentIndex * xChunkBytes;
+            const end = Math.min(start + xChunkBytes, totalBytes);
+            const chunk = blob.slice(start, end, media.mimeType ?? "");
+            await appendChunk(mediaId, segmentIndex, chunk, context);
+        }
+        const finalized = await chunkedPost(`/2/media/upload/${encodeURIComponent(mediaId)}/finalize`, undefined, context);
+        const finalizedId = optionalString(finalized["id"]) ?? mediaId;
+        const processing = finalized["processing_info"];
+        if (processing === undefined)
+            return finalizedId;
+        let { state, checkAfterSecs } = processingState(object(processing));
+        for (let poll = 0;; poll++) {
+            if (state === "succeeded")
+                return finalizedId;
+            if (state === "failed")
+                throw new SocialError({
+                    code: "media_error",
+                    operation: "media.upload",
+                    message: "X failed to process the uploaded media. No post was created.",
+                    retryDisposition: { kind: "never" },
+                });
+            if (poll >= xMaxStatusPolls)
+                break;
+            await processingWait(checkAfterSecs * 1000, context);
+            ({ state, checkAfterSecs } = await readMediaStatus(finalizedId, context));
+        }
+        throw new SocialError({
+            code: "timeout",
+            operation: "media.upload",
+            message: "X media processing did not complete in time. Reconcile before retrying.",
+            retryDisposition: { kind: "never" },
+        });
+    }
+    async function uploadXMedia(media, context) {
+        if (chunkedCategory(media) !== undefined)
+            return uploadVideoOrGif(media, context);
+        return uploadImage(media, context);
+    }
     async function createPost(account, text, context, extra = {}, targetIndex = 0) {
         authorize(account, context);
         const result = object(await request("/2/tweets", context, { text, ...extra }));
@@ -431,13 +747,14 @@ export function x(options) {
             apiRevision: "X API v2 / OpenAPI 2.168",
             runtime: ["node22", "node24", "bun"],
             capabilities: [
+                webhookCapability("x", "Verifies X-Twitter-Webhooks-Signature-OAuth2 or the legacy X-Twitter-Webhooks-Signature and decodes Account Activity deliveries. Answer the CRC GET with answerXWebhookChallenge."),
                 {
                     platform: "x",
                     operation: "posts.publish",
                     availability: "available",
-                    formats: ["text", "image"],
+                    formats: ["text", "image", "video"],
                     requiredScopes: ["tweet.read", "tweet.write", "users.read", "media.write"],
-                    notes: "User-context OAuth2 token; current X API access/billing required. Up to four static JPEG/PNG image Blobs, each at most 5 MiB. Video/GIF processing is outside this slice.",
+                    notes: "User-context OAuth2 token; current X API access/billing required. Up to four static JPEG/PNG image Blobs, each at most 5 MiB, or one MP4 video up to 512 MiB / one GIF up to 15 MiB via 1 MiB chunked upload with bounded processing poll. Post attach can still reject over-duration video with 403.",
                 },
                 ...[
                     "accounts.read",
@@ -483,6 +800,14 @@ export function x(options) {
                     availability: "available",
                     requiredScopes: ["tweet.read", "tweet.write", "users.read"],
                 },
+                {
+                    platform: "x",
+                    operation: "posts.update",
+                    availability: "available",
+                    formats: ["text"],
+                    requiredScopes: ["tweet.read", "tweet.write", "users.read"],
+                    notes: "Text-only edit through native.updatePost. X requires X Premium, the account's own post, and a recent post within X's edit window and edit count. Polls, replies to others, reposts, and scheduled posts are not editable. Each edit creates a new post ID.",
+                },
                 {
                     platform: "x",
                     operation: "graph.read",
@@ -560,6 +885,13 @@ export function x(options) {
                     availability: "available",
                     requiredScopes: ["dm.write"],
                 },
+                {
+                    platform: "x",
+                    operation: "comments.read",
+                    availability: "available",
+                    requiredScopes: ["tweet.read", "users.read"],
+                    notes: "Replies come from recent search with conversation_id, so only replies from the last 7 days are returned. Pass the conversation's root post. Page limits are 10-100. Recent search allows 450 requests per 15 minutes per app and 300 per user, and X bills post reads under the app's plan.",
+                },
                 {
                     platform: "x",
                     operation: "search.posts",
@@ -570,13 +902,17 @@ export function x(options) {
                 {
                     platform: "x",
                     operation: "media.video",
-                    availability: "not-implemented-by-adapter",
+                    availability: "available",
                     formats: ["video"],
+                    requiredScopes: ["tweet.read", "tweet.write", "users.read", "media.write"],
+                    notes: "MP4 Blob chunked INIT/APPEND/FINALIZE with 1 MiB segments and bounded STATUS poll honoring check_after_secs.",
                 },
                 {
                     platform: "x",
                     operation: "media.gif",
-                    availability: "not-implemented-by-adapter",
+                    availability: "available",
+                    requiredScopes: ["tweet.read", "tweet.write", "users.read", "media.write"],
+                    notes: "GIF Blob chunked upload; large GIFs process asynchronously before attach.",
                 },
                 {
                     platform: "x",
@@ -585,6 +921,12 @@ export function x(options) {
                     requiredScopes: ["dm.read", "users.read", "tweet.read"],
                     notes: "Requires a user-context token and an X API tier that includes Direct Messages.",
                 },
+                {
+                    platform: "x",
+                    operation: "notifications.read",
+                    availability: "unsupported-by-platform",
+                    notes: "X API v2 has no notifications list endpoint. Use mentions.read, or the Account Activity or X Activity API webhooks and streams.",
+                },
                 {
                     platform: "x",
                     operation: "messages.write",
@@ -592,11 +934,30 @@ export function x(options) {
                     requiredScopes: ["dm.write", "dm.read", "users.read", "tweet.read"],
                     notes: "Requires a user-context token and an X API tier that includes Direct Messages.",
                 },
+                {
+                    platform: "x",
+                    operation: "comments.moderate",
+                    availability: "available",
+                    requiredScopes: ["tweet.moderate.write", "tweet.read", "users.read"],
+                    notes: "Native hideReply hides or unhides replies in conversations the authenticated user started. Requires a user-context token.",
+                },
                 {
                     platform: "x",
                     operation: "streams.read",
+                    availability: "available",
+                    notes: "Filtered stream via native stream, listStreamRules, addStreamRules, and deleteStreamRules with the app-only appBearerToken. Needs X API pay-per-use (1 connection, 1,000 rules of up to 1,024 characters) or Enterprise (multiple connections, 25,000+ rules of up to 2,048 characters). backfillMinutes and startTime/endTime recovery need Enterprise. One caller-controlled connection per iteration; no automatic reconnect.",
+                },
+                {
+                    platform: "x",
+                    operation: "posts.schedule",
                     availability: "not-implemented-by-adapter",
-                    notes: "Filtered stream rules and streaming transport are not implemented by this adapter.",
+                    notes: "X API v2 has no scheduled-post field; POST /2/tweets publishes immediately. X Ads API scheduled Tweets (ads-api.x.com/12/accounts/:account_id/scheduled_tweets) need Ads API approval, an ads account, and OAuth 1.0a-signed requests, which this OAuth 2.0 adapter does not implement (https://docs.x.com/x-ads-api/fundamentals/making-authenticated-requests, checked 2026-09-24). Scheduled Tweets default to nullcast=true (promoted-only, not on the public timeline); organic nullcast=false Tweets can only be created by the ads account's full promotable user (https://docs.x.com/x-ads-api/creatives, checked 2026-09-24). Use an application-owned job runner to publish at a chosen time.",
+                },
+                {
+                    platform: "x",
+                    operation: "profile.update",
+                    availability: "unsupported-by-platform",
+                    notes: "X API v2 (OpenAPI 2.168, https://docs.x.com/openapi.json, checked 2026-09-24) has no endpoint that writes the user's profile. The v1.1 POST account/update_profile reference is no longer published on docs.x.com (its developer.x.com URL redirects to https://docs.x.com/overview), and v1.1 user writes require OAuth 1.0a.",
                 },
             ],
         },
@@ -625,16 +986,17 @@ export function x(options) {
                         accountId: account.accountId,
                         profileId: id,
                     }),
-                    ...(typeof user["name"] === "string" ? { displayName: user["name"] } : {}),
-                    ...(typeof user["username"] === "string" ? { handle: user["username"] } : {}),
-                    ...(typeof user["description"] === "string" ? { bio: user["description"] } : {}),
+                    ...definedFields({
+                        displayName: optionalString(user["name"]),
+                        handle: optionalString(user["username"]),
+                        bio: optionalString(user["description"]),
+                    }),
                     native: user,
                 };
             },
             async listRelationships(account, input, context) {
                 const pagination = {
-                    ...(input.cursor === undefined ? {} : { cursor: input.cursor }),
-                    ...(input.limit === undefined ? {} : { limit: input.limit }),
+                    ...definedFields({ cursor: input.cursor, limit: input.limit }),
                 };
                 const result = input.kind === "following"
                     ? await nativeAdapter.following({
@@ -679,7 +1041,7 @@ export function x(options) {
                                     : input.kind,
                         };
                     }),
-                    ...(result.nextCursor === undefined ? {} : { nextCursor: result.nextCursor }),
+                    ...definedFields({ nextCursor: result.nextCursor }),
                 };
             },
             async follow(target, context) {
@@ -748,23 +1110,41 @@ export function x(options) {
                 if (text && !isValidXText(text))
                     fail("x.text", "Text exceeds X's weighted 280-character limit or contains invalid characters.");
                 if (target.schedule || target.content.link)
-                    fail("x.operation", "Scheduling needs an application runner; place URLs explicitly in text.");
+                    fail("x.operation", "X API v2 cannot schedule posts; use an application job runner. Place URLs explicitly in text.");
                 if (target.replyTo &&
                     (target.replyTo.platform !== "x" ||
                         target.replyTo.backend !== target.account.backend ||
                         target.replyTo.accountId !== target.account.accountId ||
                         target.replyTo.kind !== "platform-post"))
                     fail("x.reply", "Use a platform-post reply reference authorized for this account and backend.");
-                const settings = target.options === undefined ? {} : object(target.options);
+                const settings = optionsObject(target);
                 if (Object.keys(settings).some((key) => key !== "replySettings") ||
                     (settings["replySettings"] !== undefined &&
                         !["everyone", "following", "mentionedUsers"].includes(String(settings["replySettings"]))))
                     fail("x.options", "Provide only a supported replySettings value.");
                 const media = target.content.media ?? [];
-                if (media.length > 4)
+                const hasChunked = media.some((item) => chunkedCategory(item) !== undefined);
+                if (hasChunked && media.length !== 1)
+                    fail("x.media_count", "Attach a single video or GIF per post.");
+                else if (!hasChunked && media.length > 4)
                     fail("x.media_count", "Attach up to four images.");
                 for (const item of media) {
-                    if (item.kind !== "image" ||
+                    const category = chunkedCategory(item);
+                    if (category === "tweet_video") {
+                        if (item.source.kind !== "blob" || item.source.blob.size === 0)
+                            fail("x.video_size", "Video must be a non-empty MP4 Blob.");
+                        else if (item.source.blob.size > xMaxVideoBytes)
+                            fail("x.video_size", "Video exceeds the 512 MiB limit.");
+                    }
+                    else if (category === "tweet_gif") {
+                        if (item.source.kind !== "blob" || item.source.blob.size === 0)
+                            fail("x.gif_size", "GIF must be a non-empty Blob.");
+                        else if (item.source.blob.size > xMaxGifBytes)
+                            fail("x.gif_size", "GIF exceeds the 15 MiB limit.");
+                    }
+                    else if (item.kind === "video")
+                        fail("x.video", "X video uploads require a video/mp4 Blob.");
+                    else if (item.kind !== "image" ||
                         item.source.kind !== "blob" ||
                         !["image/jpeg", "image/png"].includes(item.mimeType ?? ""))
                         fail("x.image", "This slice requires a JPEG or PNG image Blob.");
@@ -779,18 +1159,33 @@ export function x(options) {
                 authorize(target.account, context);
                 const ids = [];
                 for (const media of target.content.media ?? [])
-                    ids.push(await uploadImage(media, context));
-                const settings = target.options === undefined ? {} : object(target.options);
-                return createPost(target.account, target.content.text ?? "", context, {
-                    // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-                    ...(ids.length ? { media: { media_ids: ids } } : {}),
-                    // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-                    ...(target.replyTo ? { reply: { in_reply_to_tweet_id: target.replyTo.postId } } : {}),
-                    // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-                    ...(settings["replySettings"] && settings["replySettings"] !== "everyone"
-                        ? { reply_settings: string(settings["replySettings"]) }
-                        : {}),
-                }, target.targetIndex);
+                    ids.push(await uploadXMedia(media, context));
+                const replySettings = optionsObject(target)["replySettings"];
+                const hasVideo = (target.content.media ?? []).some((media) => chunkedCategory(media) === "tweet_video");
+                try {
+                    return await createPost(target.account, target.content.text ?? "", context, {
+                        ...definedFields({
+                            media: ids.length ? { media_ids: ids } : undefined,
+                            reply: target.replyTo ? { in_reply_to_tweet_id: target.replyTo.postId } : undefined,
+                            reply_settings: replySettings && replySettings !== "everyone" ? string(replySettings) : undefined,
+                        }),
+                    }, target.targetIndex);
+                }
+                catch (error) {
+                    // X checks video duration only at attach time and answers 403. The transport drops the
+                    // response body, so the adapter cannot tell a duration limit from a missing permission.
+                    if (hasVideo && error instanceof SocialError && error.upstreamStatus === 403)
+                        throw new SocialError({
+                            code: "missing_permission",
+                            operation: error.operation,
+                            backend: error.backend,
+                            correlationId: error.correlationId,
+                            message: "X rejected the post with its attached video (HTTP 403). The video may exceed this account's duration limit, or the token may lack post permission. No post was created.",
+                            upstreamStatus: 403,
+                            retryDisposition: { kind: "never" },
+                        });
+                    throw error;
+                }
             },
             async get(ref, context) {
                 return publicFields(await readPost(ref, context), [
@@ -815,12 +1210,8 @@ export function x(options) {
             },
         },
         comments: {
-            async list() {
-                throw new SocialError({
-                    code: "unsupported_capability",
-                    operation: "comments.read",
-                    message: "X reply search is not implemented in this slice.",
-                });
+            async list(ref, input, context) {
+                return listReplies(ref, input, context);
             },
             async reply(ref, content, context) {
                 await validateReplyParent(ref, context);
@@ -861,7 +1252,10 @@ export function x(options) {
                 const seen = [];
                 if (input.cursor !== undefined) {
                     try {
-                        const state = parseObject(JSON.parse(input.cursor));
+                        const parsed = JSON.parse(input.cursor);
+                        if (!isJsonValue(parsed))
+                            throw new Error("bad cursor");
+                        const state = object(parsed);
                         eventCursor = optionalString(state["c"]);
                         const hashes = string(state["s"]);
                         if (hashes.length % conversationHashWidth !== 0)
@@ -887,8 +1281,7 @@ export function x(options) {
                 for (let fetches = 0; fetches < 10; fetches++) {
                     const page = await nativeAdapter.listDirectMessages({
                         account,
-                        ...(eventCursor === undefined ? {} : { cursor: eventCursor }),
-                        ...(input.limit === undefined ? {} : { limit: input.limit }),
+                        ...definedFields({ cursor: eventCursor, limit: input.limit }),
                         context,
                     });
                     for (const event of page.items) {
@@ -924,8 +1317,7 @@ export function x(options) {
                         accountId: conversation.accountId,
                     }),
                     conversationId: conversation.conversationId,
-                    ...(input.cursor === undefined ? {} : { cursor: input.cursor }),
-                    ...(input.limit === undefined ? {} : { limit: input.limit }),
+                    ...definedFields({ cursor: input.cursor, limit: input.limit }),
                     context,
                 });
             },
@@ -979,6 +1371,7 @@ export function x(options) {
                 });
             },
         },
+        webhooks: directWebhooks("x", (input) => verifyXWebhook({ ...input, secret: options.webhookSecret ?? "" }), now),
         native: (nativeAdapter = {
             async searchRecentPosts({ account, search, context }) {
                 return searchPosts(account, { ...search, scope: "recent" }, context, search);
@@ -989,20 +1382,83 @@ export function x(options) {
             readPost,
             async repost({ account, postId, context }) {
                 authorize(account, context);
-                // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- validated boundary or fixture contract.
                 return object(await request(`/2/users/${encodeURIComponent(account.accountId)}/retweets`, context, {
                     tweet_id: postId,
                 }));
             },
             async quote({ account, text, quotedPostId, context }) {
                 authorize(account, context);
-                // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- validated boundary or fixture contract.
                 return object(await request("/2/tweets", context, { text, quote_tweet_id: quotedPostId }));
             },
             async deletePost({ account, postId, context }) {
                 authorize(account, context);
                 await request(`/2/tweets/${encodeURIComponent(postId)}`, context, undefined, {}, "DELETE");
             },
+            async updatePost({ account, postId, text, context }) {
+                authorize(account, context);
+                if (!/^[0-9]{1,19}$/.test(postId))
+                    throw new SocialError({
+                        code: "invalid_input",
+                        operation: "posts.update",
+                        message: "X post edits require a numeric post ID.",
+                    });
+                if (!text || !isValidXText(text))
+                    throw new SocialError({
+                        code: "invalid_input",
+                        operation: "posts.update",
+                        message: "Edited text is empty, exceeds X's weighted 280-character limit, or contains invalid characters.",
+                    });
+                const result = object(await request("/2/tweets", context, {
+                    text,
+                    edit_options: { previous_post_id: postId },
+                }));
+                const data = result["data"] === undefined ? {} : object(result["data"]);
+                const id = optionalString(data["id"]);
+                if (!id)
+                    throw new SocialError({
+                        code: "ambiguous_outcome",
+                        operation: "posts.update",
+                        backend: context.backendInstance,
+                        correlationId: context.correlationId,
+                        message: "X edit response lacks a new post ID. Reconcile before retrying.",
+                        retryDisposition: { kind: "reconcile-first" },
+                    });
+                const history = data["edit_history_post_ids"] ?? data["edit_history_tweet_ids"];
+                const editHistoryPostIds = Array.isArray(history)
+                    ? history.filter((entry) => typeof entry === "string")
+                    : undefined;
+                return {
+                    post: {
+                        kind: "platform-post",
+                        version: 1,
+                        backend: account.backend,
+                        platform: "x",
+                        accountId: account.accountId,
+                        postId: id,
+                    },
+                    previousPostId: postId,
+                    text: optionalString(data["text"]) ?? text,
+                    ...definedFields({ editHistoryPostIds }),
+                };
+            },
+            async uploadVideo({ account, video, context }) {
+                authorize(account, context);
+                const media = {
+                    kind: "video",
+                    mimeType: "video/mp4",
+                    source: { kind: "blob", blob: video, fingerprint: "native-upload" },
+                };
+                return { mediaId: await uploadVideoOrGif(media, context) };
+            },
+            async uploadGif({ account, gif, context }) {
+                authorize(account, context);
+                const media = {
+                    kind: "image",
+                    mimeType: "image/gif",
+                    source: { kind: "blob", blob: gif, fingerprint: "native-upload" },
+                };
+                return { mediaId: await uploadVideoOrGif(media, context) };
+            },
             async createPoll({ account, text, options: pollOptions, durationMinutes, context }) {
                 authorize(account, context);
                 if (pollOptions.length < 2 ||
@@ -1014,7 +1470,6 @@ export function x(options) {
                         operation: "x.polls.create",
                         message: "X polls require 2-4 options and a duration from 5 minutes to 7 days.",
                     });
-                // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- validated boundary or fixture contract.
                 return object(await request("/2/tweets", context, {
                     text,
                     poll: { options: [...pollOptions], duration_minutes: durationMinutes },
@@ -1022,7 +1477,6 @@ export function x(options) {
             },
             async bookmarks({ account, context }) {
                 authorize(account, context);
-                // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- validated boundary or fixture contract.
                 return object(await request(`/2/users/${encodeURIComponent(account.accountId)}/bookmarks`, context));
             },
             async bookmark({ account, postId, context }) {
@@ -1037,7 +1491,6 @@ export function x(options) {
             },
             async follow({ account, userId, context }) {
                 authorize(account, context);
-                // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- validated boundary or fixture contract.
                 return object(await request(`/2/users/${encodeURIComponent(account.accountId)}/following`, context, {
                     target_user_id: userId,
                 }));
@@ -1062,14 +1515,13 @@ export function x(options) {
                 const result = object(await request(path, context, undefined, {
                     "dm_event.fields": "id,text,event_type,created_at,dm_conversation_id,attachments,entities",
                     expansions: "sender_id,participant_ids",
-                    ...(cursor === undefined ? {} : { pagination_token: cursor }),
-                    ...(limit === undefined ? {} : { max_results: String(limit) }),
+                    ...definedFields({ pagination_token: cursor, max_results: limit?.toString() }),
                 }));
                 const meta = result["meta"] === undefined ? {} : object(result["meta"]);
                 const nextCursor = optionalString(meta["next_token"]);
                 return {
                     items: result["data"] === undefined ? [] : array(result["data"]).map(object),
-                    ...(nextCursor === undefined ? {} : { nextCursor }),
+                    ...definedFields({ nextCursor }),
                 };
             },
             async sendDirectMessage({ account, participantId, text, context }) {
@@ -1091,7 +1543,7 @@ export function x(options) {
                         operation: "messages.conversation.write",
                         message: "X direct messages require non-empty text.",
                     });
-                return object(await requireUserToken("messages.conversation.write")(`/2/dm_conversations/${encodeURIComponent(conversationId)}/messages`, context, { text, ...(attachments === undefined ? {} : { attachments }) }));
+                return object(await requireUserToken("messages.conversation.write")(`/2/dm_conversations/${encodeURIComponent(conversationId)}/messages`, context, { text, ...definedFields({ attachments }) }));
             },
             async createGroupConversation({ account, participantIds, message, context }) {
                 authorize(account, context);
@@ -1206,16 +1658,13 @@ export function x(options) {
                 authorize(account, context);
                 return object(await request("/2/lists", context, {
                     name,
-                    ...(description === undefined ? {} : { description }),
-                    ...(isPrivate === undefined ? {} : { private: isPrivate }),
+                    ...definedFields({ description, private: isPrivate }),
                 }));
             },
             async updateList({ account, listId, name, description, isPrivate, context }) {
                 authorize(account, context);
                 return object(await request(`/2/lists/${encodeURIComponent(listId)}`, context, {
-                    ...(name === undefined ? {} : { name }),
-                    ...(description === undefined ? {} : { description }),
-                    ...(isPrivate === undefined ? {} : { private: isPrivate }),
+                    ...definedFields({ name, description, private: isPrivate }),
                 }, {}, "PUT"));
             },
             async deleteList({ account, listId, context }) {
@@ -1281,6 +1730,85 @@ export function x(options) {
                 authorize(account, context);
                 await request(`/2/users/${encodeURIComponent(account.accountId)}/retweets/${encodeURIComponent(postId)}`, context, undefined, {}, "DELETE");
             },
+            async listStreamRules({ account, ids, cursor, limit, context }) {
+                authorize(account, context);
+                if (ids !== undefined)
+                    validateRuleIds(ids, "x.streamRules.list", 1000);
+                if (limit !== undefined && (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000))
+                    throw new SocialError({
+                        code: "invalid_input",
+                        operation: "x.streamRules.list",
+                        message: "X stream rule limits must be integers from 1 through 1000.",
+                    });
+                const result = object(await appRequest()("/2/tweets/search/stream/rules", context, undefined, {
+                    ...definedFields({
+                        ids: ids?.join(","),
+                        pagination_token: cursor,
+                        max_results: limit === undefined ? undefined : String(limit),
+                    }),
+                }));
+                const items = (result["data"] === undefined ? [] : array(result["data"])).map((entry) => parseStreamRule(object(entry), "x.streamRules.list"));
+                const meta = result["meta"] === undefined ? {} : object(result["meta"]);
+                const nextCursor = optionalString(meta["next_token"]);
+                return { items, ...definedFields({ nextCursor }) };
+            },
+            async addStreamRules({ account, rules, dryRun = false, context }) {
+                authorize(account, context);
+                if (rules.length === 0)
+                    throw new SocialError({
+                        code: "invalid_input",
+                        operation: "x.streamRules.add",
+                        message: "Provide at least one X filtered-stream rule to add.",
+                    });
+                for (const rule of rules)
+                    validateRuleInput(rule);
+                const result = await appRequest()("/2/tweets/search/stream/rules", context, {
+                    add: rules.map((rule) => ({
+                        value: rule.value,
+                        ...definedFields({ tag: rule.tag }),
+                    })),
+                }, dryRun ? { dry_run: "true" } : {});
+                return parseRulesUpdate(object(result), dryRun);
+            },
+            async deleteStreamRules({ account, ids, dryRun = false, context }) {
+                authorize(account, context);
+                validateRuleIds(ids, "x.streamRules.delete", 1000);
+                const result = await appRequest()("/2/tweets/search/stream/rules", context, { delete: { ids: [...ids] } }, dryRun ? { dry_run: "true" } : {});
+                return parseRulesUpdate(object(result), dryRun);
+            },
+            async *stream({ account, context, ...streamOptions }) {
+                authorize(account, context);
+                const bearerToken = options.appBearerToken;
+                if (!bearerToken?.trim())
+                    throw new SocialError({
+                        code: "missing_permission",
+                        operation: "streams.read",
+                        message: "The X filtered stream requires an app-only bearer token. Configure appBearerToken.",
+                    });
+                yield* readFilteredStream({ bearerToken, fetch: options.fetch }, streamOptions, context);
+            },
+            async hideReply({ account, replyId, hidden, context }) {
+                authorize(account, context);
+                if (!/^[0-9]{1,19}$/.test(replyId))
+                    throw new SocialError({
+                        code: "invalid_input",
+                        operation: "comments.moderate",
+                        message: "X reply IDs are numeric strings of 1 to 19 digits.",
+                        retryDisposition: { kind: "never" },
+                    });
+                const result = object(await requireUserToken("comments.moderate")(`/2/tweets/${encodeURIComponent(replyId)}/hidden`, context, { hidden }, {}, "PUT"));
+                const state = result["data"] === undefined
+                    ? undefined
+                    : optionalBoolean(object(result["data"])["hidden"]);
+                if (state === undefined)
+                    throw new SocialError({
+                        code: "ambiguous_outcome",
+                        operation: "comments.moderate",
+                        message: "X did not report the reply's hidden state.",
+                        retryDisposition: { kind: "reconcile-first" },
+                    });
+                return { hidden: state };
+            },
         }),
     });
     return adapter;