@webmcp-bridge/adapter-x 0.5.0 → 0.5.2

package/dist/adapter.js

@@ -3,21 +3,24 @@
  * It depends on Playwright page evaluation and shared adapter contracts to execute browser-side tool actions.
  */
 import { buildRequestCaptureInitScript, captureRoutedResponseText, collectTextByTag, joinTextParts, parseNdjsonLines, TemplateCache, } from "@webmcp-bridge/adapter-utils";
-import { mkdtemp, rm, stat, writeFile } from "node:fs/promises";
+import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { basename, extname, isAbsolute, join } from "node:path";
+import { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
 const DEFAULT_TIMELINE_LIMIT = 10;
 const MAX_TIMELINE_LIMIT = 20;
 const MAX_READ_PAGE_CACHE_SIZE = 8;
 const DEFAULT_COMPOSE_CONFIRM_TIMEOUT_MS = 10_000;
 const DEFAULT_GROK_RESPONSE_TIMEOUT_MS = 90_000;
+const DEFAULT_ARTICLE_PUBLISH_TIMEOUT_MS = 30_000;
 const DEFAULT_MAX_POST_LENGTH = 280;
 const AUTH_STABILIZE_ATTEMPTS = 6;
 const AUTH_STABILIZE_DELAY_MS = 750;
 const AUTH_WARMUP_TIMEOUT_MS = 12_000;
 const GROK_ARTIFACT_DIR_PREFIX = "webmcp-bridge-grok-";
 const TWEET_MEDIA_ARTIFACT_DIR_PREFIX = "webmcp-bridge-x-media-";
+const ARTICLE_INLINE_IMAGE_MARKER_PREFIX = "[[WEBMCP_INLINE_IMAGE_";
 const ALLOWED_TWEET_MEDIA_HOSTS = new Set(["pbs.twimg.com", "video.twimg.com"]);
+const ALLOWED_X_HOSTS = new Set(["x.com", "www.x.com", "twitter.com", "www.twitter.com"]);
 const CAPTURE_INJECT_SCRIPT = buildRequestCaptureInitScript({
     globalKey: "__WEBMCP_X_CAPTURE__",
     shouldCaptureSource: String.raw `((url) => {
@@ -32,7 +35,10 @@ const CAPTURE_INJECT_SCRIPT = buildRequestCaptureInitScript({
         url.includes("/UserTweets") ||
         url.includes("/UserMedia") ||
         url.includes("/UserTweetsAndReplies") ||
-        url.includes("/SearchTimeline")
+        url.includes("/SearchTimeline") ||
+        url.includes("/ArticleEntitiesSlice") ||
+        url.includes("/ArticleRedirectScreenQuery") ||
+        url.includes("/UserArticlesTweets")
       )
     );
   })`,
@@ -47,6 +53,9 @@ const CAPTURE_INJECT_SCRIPT = buildRequestCaptureInitScript({
     else if (url.includes("/UserMedia")) op = "UserMedia";
     else if (url.includes("/UserTweets")) op = "UserTweets";
     else if (url.includes("/SearchTimeline")) op = "SearchTimeline";
+    else if (url.includes("/ArticleEntitiesSlice")) op = "ArticleEntitiesSlice";
+    else if (url.includes("/ArticleRedirectScreenQuery")) op = "ArticleRedirectScreenQuery";
+    else if (url.includes("/UserArticlesTweets")) op = "UserArticlesTweets";
     return { ...entry, op };
   })`,
     maxEntries: 80,
@@ -390,6 +399,26 @@ const TOOL_DEFINITIONS = [
             additionalProperties: false,
         },
     },
+    {
+        name: "tweet.delete",
+        description: "Delete one tweet by url or id",
+        annotations: {
+            readOnlyHint: false,
+        },
+        inputSchema: {
+            type: "object",
+            description: "Open a tweet detail page and delete one tweet owned by the authenticated account.",
+            properties: {
+                url: { type: "string", description: "Tweet URL, for example https://x.com/<user>/status/<id>." },
+                id: { type: "string", description: "Tweet id. Used when url is not provided." },
+                dryRun: {
+                    type: "boolean",
+                    description: "When true, validate delete controls without confirming the destructive action.",
+                },
+            },
+            additionalProperties: false,
+        },
+    },
     {
         name: "grok.chat",
         description: "Send one prompt to Grok from the authenticated X session",
@@ -422,6 +451,280 @@ const TOOL_DEFINITIONS = [
             additionalProperties: false,
         },
     },
+    {
+        name: "article.get",
+        description: "Read one X article by public url, edit url, or id",
+        inputSchema: {
+            type: "object",
+            description: "Fetch one X article using public article URL, edit URL, or article id.",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "Public article URL or edit URL.",
+                    minLength: 1,
+                },
+                id: {
+                    type: "string",
+                    description: "Article id. Used when url is not provided.",
+                    minLength: 1,
+                },
+                authorHandle: {
+                    type: "string",
+                    description: "Optional article author handle, for example jolestar or @jolestar. Used for profile articles fallback when public article route is unavailable.",
+                    minLength: 1,
+                },
+            },
+            additionalProperties: false,
+        },
+        annotations: {
+            readOnlyHint: true,
+        },
+    },
+    {
+        name: "article.listDrafts",
+        description: "List existing X article drafts from the authenticated account",
+        inputSchema: {
+            type: "object",
+            description: "List article drafts owned by the authenticated X account.",
+            properties: {},
+            additionalProperties: false,
+        },
+        annotations: {
+            readOnlyHint: true,
+        },
+    },
+    {
+        name: "article.getDraft",
+        description: "Read one X article draft by id, preview url, or edit url",
+        inputSchema: {
+            type: "object",
+            description: "Fetch one draft from the X article editor using article id, preview URL, or edit URL.",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "Draft preview URL or edit URL.",
+                    minLength: 1,
+                },
+                id: {
+                    type: "string",
+                    description: "Draft article id. Used when url is not provided.",
+                    minLength: 1,
+                },
+            },
+            additionalProperties: false,
+        },
+        annotations: {
+            readOnlyHint: true,
+        },
+    },
+    {
+        name: "article.draftMarkdown",
+        description: "Create one X article draft from a local markdown file",
+        inputSchema: {
+            type: "object",
+            description: "Create one X article draft from a local markdown file. The adapter derives the title from the first markdown heading when title is omitted.",
+            properties: {
+                markdownPath: {
+                    type: "string",
+                    description: "Absolute local file path to the markdown file to draft.",
+                    minLength: 1,
+                    "x-uxc-kind": "file-path",
+                },
+                title: {
+                    type: "string",
+                    description: "Optional title override. When omitted, the first markdown heading becomes the article title.",
+                    minLength: 1,
+                },
+                coverImagePath: {
+                    type: "string",
+                    description: "Optional absolute local image path for the article cover image.",
+                    minLength: 1,
+                    "x-uxc-kind": "file-path",
+                },
+            },
+            required: ["markdownPath"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "article.upsertDraftMarkdown",
+        description: "Create or update one X article draft from a local markdown file",
+        inputSchema: {
+            type: "object",
+            description: "Create a new draft when id/url is omitted, or update the existing draft identified by id, preview URL, or edit URL.",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "Draft preview URL or edit URL.",
+                    minLength: 1,
+                },
+                id: {
+                    type: "string",
+                    description: "Draft article id. Used when url is not provided.",
+                    minLength: 1,
+                },
+                markdownPath: {
+                    type: "string",
+                    description: "Absolute local file path to the markdown file to apply.",
+                    minLength: 1,
+                    "x-uxc-kind": "file-path",
+                },
+                title: {
+                    type: "string",
+                    description: "Optional title override. When omitted, the first markdown heading becomes the article title.",
+                    minLength: 1,
+                },
+                coverImagePath: {
+                    type: "string",
+                    description: "Optional absolute local image path for the article cover image when creating a new draft.",
+                    minLength: 1,
+                    "x-uxc-kind": "file-path",
+                },
+            },
+            required: ["markdownPath"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "article.publishMarkdown",
+        description: "Publish one X article from a local markdown file",
+        inputSchema: {
+            type: "object",
+            description: "Create and publish one X article from a local markdown file. The adapter derives the title from the first markdown heading when title is omitted.",
+            properties: {
+                markdownPath: {
+                    type: "string",
+                    description: "Absolute local file path to the markdown file to publish.",
+                    minLength: 1,
+                    "x-uxc-kind": "file-path",
+                },
+                title: {
+                    type: "string",
+                    description: "Optional title override. When omitted, the first markdown heading becomes the article title.",
+                    minLength: 1,
+                },
+                coverImagePath: {
+                    type: "string",
+                    description: "Optional absolute local image path for the article cover image.",
+                    minLength: 1,
+                    "x-uxc-kind": "file-path",
+                },
+                dryRun: {
+                    type: "boolean",
+                    description: "When true, validate article creation and editor population without publishing.",
+                },
+            },
+            required: ["markdownPath"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "article.publish",
+        description: "Publish one existing X article draft by edit url, public url, or id",
+        inputSchema: {
+            type: "object",
+            description: "Open one article editor page and publish the current draft.",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "Article edit URL or public article URL.",
+                    minLength: 1,
+                },
+                id: {
+                    type: "string",
+                    description: "Article id. Used when url is not provided.",
+                    minLength: 1,
+                },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "article.setCoverImage",
+        description: "Set or replace the cover image for one existing X article draft",
+        inputSchema: {
+            type: "object",
+            description: "Open one article editor page and set the cover image for the current draft.",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "Article edit URL or public article URL.",
+                    minLength: 1,
+                },
+                id: {
+                    type: "string",
+                    description: "Article id. Used when url is not provided.",
+                    minLength: 1,
+                },
+                coverImagePath: {
+                    type: "string",
+                    description: "Absolute local image path for the article cover image.",
+                    minLength: 1,
+                    "x-uxc-kind": "file-path",
+                },
+            },
+            required: ["coverImagePath"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "article.updateMarkdown",
+        description: "Replace the title and body of one existing X article draft from a local markdown file",
+        inputSchema: {
+            type: "object",
+            description: "Open one article editor page, replace the current title and body from a local markdown file, and upload any local inline images referenced by markdown image syntax.",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "Article edit URL or public article URL.",
+                    minLength: 1,
+                },
+                id: {
+                    type: "string",
+                    description: "Article id. Used when url is not provided.",
+                    minLength: 1,
+                },
+                markdownPath: {
+                    type: "string",
+                    description: "Absolute local file path to the markdown file to apply.",
+                    minLength: 1,
+                    "x-uxc-kind": "file-path",
+                },
+                title: {
+                    type: "string",
+                    description: "Optional title override. When omitted, the first markdown heading becomes the article title.",
+                    minLength: 1,
+                },
+            },
+            required: ["markdownPath"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "article.delete",
+        description: "Delete one X article draft or published article by edit url, public url, or id",
+        inputSchema: {
+            type: "object",
+            description: "Open one article editor page and delete the article after confirmation.",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "Article edit URL or public article URL.",
+                    minLength: 1,
+                },
+                id: {
+                    type: "string",
+                    description: "Article id. Used when url is not provided.",
+                    minLength: 1,
+                },
+                dryRun: {
+                    type: "boolean",
+                    description: "When true, validate delete controls without confirming the destructive action.",
+                },
+            },
+            additionalProperties: false,
+        },
+    },
 ];
 function toRecord(value) {
     if (typeof value === "object" && value !== null && !Array.isArray(value)) {
@@ -520,65 +823,6 @@ function parseDataUri(uri) {
         return undefined;
     }
 }
-function toTweetMediaArray(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    const output = [];
-    for (const rawEntry of value) {
-        if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
-            continue;
-        }
-        const entry = rawEntry;
-        const type = entry.type;
-        const url = entry.url;
-        if ((type !== "photo" && type !== "video" && type !== "animated_gif")
-            || typeof url !== "string"
-            || url.trim().length === 0) {
-            continue;
-        }
-        const media = {
-            type,
-            url,
-        };
-        if (typeof entry.previewUrl === "string" && entry.previewUrl.trim()) {
-            media.previewUrl = entry.previewUrl;
-        }
-        if (typeof entry.width === "number" && Number.isFinite(entry.width)) {
-            media.width = entry.width;
-        }
-        if (typeof entry.height === "number" && Number.isFinite(entry.height)) {
-            media.height = entry.height;
-        }
-        if (typeof entry.durationMs === "number" && Number.isFinite(entry.durationMs)) {
-            media.durationMs = entry.durationMs;
-        }
-        if (Array.isArray(entry.variants)) {
-            const variants = entry.variants.flatMap((rawVariant) => {
-                if (!rawVariant || typeof rawVariant !== "object" || Array.isArray(rawVariant)) {
-                    return [];
-                }
-                const variantRecord = rawVariant;
-                if (typeof variantRecord.url !== "string" || !variantRecord.url.trim()) {
-                    return [];
-                }
-                const variant = { url: variantRecord.url };
-                if (typeof variantRecord.contentType === "string" && variantRecord.contentType.trim()) {
-                    variant.contentType = variantRecord.contentType;
-                }
-                if (typeof variantRecord.bitrate === "number" && Number.isFinite(variantRecord.bitrate)) {
-                    variant.bitrate = variantRecord.bitrate;
-                }
-                return [variant];
-            });
-            if (variants.length > 0) {
-                media.variants = variants;
-            }
-        }
-        output.push(media);
-    }
-    return output;
-}
 function normalizeTweetMediaForDownload(media) {
     if (media.type !== "photo") {
         return media;
@@ -776,27 +1020,322 @@ async function resolveGrokAttachments(input) {
     }
     return { ok: true, attachments };
 }
-function normalizeTimelineLimit(input) {
-    const rawLimit = input.limit;
-    if (typeof rawLimit !== "number" || !Number.isFinite(rawLimit)) {
-        return DEFAULT_TIMELINE_LIMIT;
+async function resolveArticleAttachment(value, fieldName) {
+    if (value === undefined) {
+        return { ok: true };
     }
-    return Math.max(1, Math.min(MAX_TIMELINE_LIMIT, Math.floor(rawLimit)));
+    const path = typeof value === "string" ? value.trim() : "";
+    if (!path) {
+        return {
+            ok: false,
+            result: errorResult("VALIDATION_ERROR", `${fieldName} must be a non-empty string`),
+        };
+    }
+    if (!isAbsolute(path)) {
+        return {
+            ok: false,
+            result: errorResult("VALIDATION_ERROR", `${fieldName} must be an absolute file path`),
+        };
+    }
+    try {
+        const fileStat = await stat(path);
+        if (!fileStat.isFile()) {
+            return {
+                ok: false,
+                result: errorResult("VALIDATION_ERROR", `${fieldName} must point to a file`),
+            };
+        }
+    }
+    catch {
+        return {
+            ok: false,
+            result: errorResult("VALIDATION_ERROR", `${fieldName} was not found`),
+        };
+    }
+    return {
+        ok: true,
+        attachment: {
+            path,
+            name: basename(path),
+        },
+    };
 }
-async function ensureNetworkCaptureInstalled(page) {
-    await page.addInitScript(CAPTURE_INJECT_SCRIPT);
-    await page.evaluate(CAPTURE_INJECT_SCRIPT);
+function stripMarkdownImageDestination(rawDestination) {
+    const trimmed = rawDestination.trim();
+    const withoutAngle = trimmed.startsWith("<") && trimmed.endsWith(">") ? trimmed.slice(1, -1) : trimmed;
+    const titleMatch = withoutAngle.match(/^(.+?)(?:\s+["'(].*)?$/);
+    return (titleMatch?.[1] ?? withoutAngle).trim();
 }
-async function hasCapturedTemplate(page, mode) {
-    const result = await page.evaluate(({ targetMode }) => {
-        const globalAny = window;
-        const entries = Array.isArray(globalAny.__WEBMCP_X_CAPTURE__?.entries)
-            ? globalAny.__WEBMCP_X_CAPTURE__?.entries ?? []
-            : [];
-        const ops = targetMode === "home"
-            ? ["HomeTimeline", "TweetDetail"]
-            : targetMode === "bookmarks"
-                ? ["BookmarksAll", "Bookmarks"]
+function extractArticleTitle(markdown, markdownPath, explicitTitle) {
+    const title = typeof explicitTitle === "string" ? explicitTitle.trim() : "";
+    if (title) {
+        return title;
+    }
+    const headingMatch = markdown.match(/^\s*#\s+(.+?)\s*$/m);
+    if (headingMatch?.[1]) {
+        return headingMatch[1].trim();
+    }
+    return basename(markdownPath, extname(markdownPath)).trim() || "Untitled";
+}
+function normalizeArticleTitleForComparison(value) {
+    return value
+        .normalize("NFKC")
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}]+/gu, " ")
+        .trim();
+}
+function normalizeArticleMarkdown(markdown, markdownPath, explicitTitle) {
+    const normalized = markdown.replace(/\r\n/g, "\n");
+    const lines = normalized.split("\n");
+    const explicit = typeof explicitTitle === "string" ? explicitTitle.trim() : "";
+    const derivedTitle = extractArticleTitle(normalized, markdownPath, explicitTitle);
+    const comparisonTitle = normalizeArticleTitleForComparison(derivedTitle);
+    const output = [];
+    let insideFence = false;
+    let firstH1Handled = false;
+    for (const line of lines) {
+        if (/^\s*```/.test(line)) {
+            insideFence = !insideFence;
+            output.push(line);
+            continue;
+        }
+        if (insideFence) {
+            output.push(line);
+            continue;
+        }
+        const match = line.match(/^(\s*)#\s+(.+?)\s*$/);
+        if (!match) {
+            output.push(line);
+            continue;
+        }
+        const headingText = (match[2] ?? "").trim();
+        if (!firstH1Handled) {
+            firstH1Handled = true;
+            if (!explicit || normalizeArticleTitleForComparison(headingText) === comparisonTitle) {
+                continue;
+            }
+        }
+        output.push(`${match[1]}## ${headingText}`);
+    }
+    const bodyMarkdown = output.join("\n").replace(/^\s*\n/, "").trim();
+    return {
+        title: derivedTitle,
+        bodyMarkdown,
+    };
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+function convertMarkdownInlineToHtml(value) {
+    const placeholders = [];
+    const reserve = (html) => {
+        const token = `__WEBMCP_HTML_${placeholders.length}__`;
+        placeholders.push(html);
+        return token;
+    };
+    let rendered = value
+        .replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (_match, altRaw, destinationRaw) => {
+        const alt = escapeHtml(altRaw.trim());
+        const destination = escapeHtml(stripMarkdownImageDestination(destinationRaw));
+        return reserve(`<img src="${destination}" alt="${alt}">`);
+    })
+        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_match, textRaw, hrefRaw) => {
+        const text = escapeHtml(textRaw.trim() || hrefRaw.trim());
+        const href = escapeHtml(hrefRaw.trim());
+        return reserve(`<a href="${href}">${text}</a>`);
+    })
+        .replace(/`([^`]+)`/g, (_match, codeRaw) => reserve(`<code>${escapeHtml(codeRaw)}</code>`))
+        .replace(/\*\*([^*]+)\*\*/g, (_match, textRaw) => reserve(`<strong>${escapeHtml(textRaw)}</strong>`))
+        .replace(/\*([^*]+)\*/g, (_match, textRaw) => reserve(`<em>${escapeHtml(textRaw)}</em>`));
+    rendered = escapeHtml(rendered);
+    return rendered.replace(/__WEBMCP_HTML_(\d+)__/g, (_match, indexRaw) => {
+        const index = Number.parseInt(indexRaw, 10);
+        return placeholders[index] ?? "";
+    });
+}
+function convertMarkdownToHtml(markdown) {
+    const lines = markdown.replace(/\r\n/g, "\n").split("\n");
+    const blocks = [];
+    let index = 0;
+    const flushParagraph = (paragraphLines) => {
+        if (paragraphLines.length === 0) {
+            return;
+        }
+        const text = paragraphLines.join(" ").trim();
+        if (!text) {
+            return;
+        }
+        blocks.push(`<p>${convertMarkdownInlineToHtml(text)}</p>`);
+    };
+    while (index < lines.length) {
+        const line = lines[index] ?? "";
+        const trimmed = line.trim();
+        if (!trimmed) {
+            index += 1;
+            continue;
+        }
+        const fenceMatch = trimmed.match(/^```([^`]*)$/);
+        if (fenceMatch) {
+            const language = escapeHtml(fenceMatch[1]?.trim() ?? "");
+            const codeLines = [];
+            index += 1;
+            while (index < lines.length && !lines[index].trim().startsWith("```")) {
+                codeLines.push(lines[index]);
+                index += 1;
+            }
+            if (index < lines.length) {
+                index += 1;
+            }
+            const code = escapeHtml(codeLines.join("\n"));
+            blocks.push(language ? `<pre><code class="language-${language}">${code}</code></pre>` : `<pre><code>${code}</code></pre>`);
+            continue;
+        }
+        const headingMatch = trimmed.match(/^(#{1,6})\s+(.+)$/);
+        if (headingMatch) {
+            const level = Math.min(6, headingMatch[1].length);
+            const content = convertMarkdownInlineToHtml(headingMatch[2].trim());
+            blocks.push(`<h${level}>${content}</h${level}>`);
+            index += 1;
+            continue;
+        }
+        const bulletMatch = trimmed.match(/^[-*+]\s+(.+)$/);
+        if (bulletMatch) {
+            const items = [];
+            while (index < lines.length) {
+                const itemLine = lines[index].trim();
+                const match = itemLine.match(/^[-*+]\s+(.+)$/);
+                if (!match) {
+                    break;
+                }
+                items.push(`<li>${convertMarkdownInlineToHtml(match[1].trim())}</li>`);
+                index += 1;
+            }
+            blocks.push(`<ul>${items.join("")}</ul>`);
+            continue;
+        }
+        const orderedMatch = trimmed.match(/^\d+\.\s+(.+)$/);
+        if (orderedMatch) {
+            const items = [];
+            while (index < lines.length) {
+                const itemLine = lines[index].trim();
+                const match = itemLine.match(/^\d+\.\s+(.+)$/);
+                if (!match) {
+                    break;
+                }
+                items.push(`<li>${convertMarkdownInlineToHtml(match[1].trim())}</li>`);
+                index += 1;
+            }
+            blocks.push(`<ol>${items.join("")}</ol>`);
+            continue;
+        }
+        const paragraphLines = [];
+        while (index < lines.length) {
+            const paragraphLine = lines[index] ?? "";
+            const paragraphTrimmed = paragraphLine.trim();
+            if (!paragraphTrimmed) {
+                break;
+            }
+            if (/^```/.test(paragraphTrimmed) || /^(#{1,6})\s+/.test(paragraphTrimmed) || /^[-*+]\s+/.test(paragraphTrimmed) || /^\d+\.\s+/.test(paragraphTrimmed)) {
+                break;
+            }
+            paragraphLines.push(paragraphLine.trim());
+            index += 1;
+        }
+        flushParagraph(paragraphLines);
+    }
+    return blocks.join("\n");
+}
+function convertMarkdownLineToPlainText(line) {
+    return line
+        .replace(/^#{1,6}\s+/, "")
+        .replace(/^[-*+]\s+/, "")
+        .replace(/^\d+\.\s+/, "")
+        .replace(/^>\s+/, "")
+        .replace(/!\[([^\]]*)\]\(([^)]+)\)/g, "$1")
+        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1")
+        .replace(/\*\*([^*]+)\*\*/g, "$1")
+        .replace(/\*([^*]+)\*/g, "$1")
+        .replace(/`([^`]+)`/g, "$1")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function extractArticleConfirmationSnippets(markdown) {
+    const snippets = [];
+    let insideFence = false;
+    for (const rawLine of markdown.replace(/\r\n/g, "\n").split("\n")) {
+        const trimmed = rawLine.trim();
+        if (!trimmed) {
+            continue;
+        }
+        if (/^```/.test(trimmed)) {
+            insideFence = !insideFence;
+            continue;
+        }
+        const normalized = insideFence ? trimmed : convertMarkdownLineToPlainText(trimmed);
+        if (normalized) {
+            snippets.push(normalized);
+        }
+        if (snippets.length >= 3) {
+            break;
+        }
+    }
+    return snippets;
+}
+function prepareArticleMarkdown(markdown, markdownPath) {
+    const inlineImages = [];
+    let nextIndex = 1;
+    const prepared = markdown.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (_match, altRaw, destinationRaw) => {
+        const destination = stripMarkdownImageDestination(destinationRaw);
+        if (/^(?:https?:|data:)/i.test(destination)) {
+            return _match;
+        }
+        const resolvedPath = isAbsolute(destination) ? destination : resolve(dirname(markdownPath), destination);
+        const marker = `${ARTICLE_INLINE_IMAGE_MARKER_PREFIX}${nextIndex}]]`;
+        nextIndex += 1;
+        const image = {
+            marker,
+            path: resolvedPath,
+            name: basename(resolvedPath),
+        };
+        const alt = altRaw.trim();
+        if (alt) {
+            image.alt = alt;
+        }
+        inlineImages.push(image);
+        return `\n\n${marker}\n\n`;
+    });
+    return {
+        markdown: prepared,
+        html: convertMarkdownToHtml(prepared),
+        inlineImages,
+    };
+}
+function normalizeTimelineLimit(input) {
+    const rawLimit = input.limit;
+    if (typeof rawLimit !== "number" || !Number.isFinite(rawLimit)) {
+        return DEFAULT_TIMELINE_LIMIT;
+    }
+    return Math.max(1, Math.min(MAX_TIMELINE_LIMIT, Math.floor(rawLimit)));
+}
+async function ensureNetworkCaptureInstalled(page) {
+    await page.addInitScript(CAPTURE_INJECT_SCRIPT);
+    await page.evaluate(CAPTURE_INJECT_SCRIPT);
+}
+async function hasCapturedTemplate(page, mode) {
+    const result = await page.evaluate(({ targetMode }) => {
+        const globalAny = window;
+        const entries = Array.isArray(globalAny.__WEBMCP_X_CAPTURE__?.entries)
+            ? globalAny.__WEBMCP_X_CAPTURE__?.entries ?? []
+            : [];
+        const ops = targetMode === "home"
+            ? ["HomeTimeline", "TweetDetail"]
+            : targetMode === "bookmarks"
+                ? ["BookmarksAll", "Bookmarks"]
                 : targetMode === "tweet"
                     ? ["TweetDetail"]
                     : targetMode === "user_timeline"
@@ -885,22 +1424,48 @@ async function detectAuth(page) {
         return { state: "auth_required", signals };
     }, { op: "detect_auth" });
 }
+function isTransientExecutionContextError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const message = error.message.toLowerCase();
+    return (message.includes("execution context was destroyed") ||
+        message.includes("cannot find context with specified id") ||
+        message.includes("target closed"));
+}
+async function detectAuthWithRetry(page) {
+    for (let attempt = 0; attempt < AUTH_STABILIZE_ATTEMPTS; attempt += 1) {
+        try {
+            return await detectAuth(page);
+        }
+        catch (error) {
+            if (!isTransientExecutionContextError(error) || attempt === AUTH_STABILIZE_ATTEMPTS - 1) {
+                throw error;
+            }
+            await page.waitForLoadState("domcontentloaded").catch(() => {
+                // The page may still be mid-navigation; let the retry loop continue.
+            });
+            await page.waitForTimeout(AUTH_STABILIZE_DELAY_MS);
+        }
+    }
+    return { state: "auth_required", signals: ["auth_unknown"] };
+}
 async function detectAuthStable(page) {
-    let auth = await detectAuth(page);
+    let auth = await detectAuthWithRetry(page);
     for (let attempt = 1; attempt < AUTH_STABILIZE_ATTEMPTS; attempt += 1) {
         const shouldRetry = auth.state === "auth_required" && auth.signals.includes("auth_unknown");
         if (!shouldRetry) {
             return auth;
         }
         await page.waitForTimeout(AUTH_STABILIZE_DELAY_MS);
-        auth = await detectAuth(page);
+        auth = await detectAuthWithRetry(page);
     }
     return auth;
 }
 async function warmupAuthProbe(page) {
     const deadline = Date.now() + AUTH_WARMUP_TIMEOUT_MS;
     for (;;) {
-        const auth = await detectAuth(page);
+        const auth = await detectAuthWithRetry(page);
         const stable = !(auth.state === "auth_required" && auth.signals.includes("auth_unknown"));
         if (stable || Date.now() >= deadline) {
             return;
@@ -939,6 +1504,33 @@ function canonicalizeStatusUrl(input, fallbackId) {
         return input;
     }
 }
+function canonicalizeArticleUrl(input, fallbackId) {
+    if (!input) {
+        return fallbackId ? `https://x.com/i/article/${fallbackId}` : undefined;
+    }
+    try {
+        const url = new URL(input);
+        if (!ALLOWED_X_HOSTS.has(url.hostname.toLowerCase())) {
+            return input;
+        }
+        const segments = url.pathname.split("/").filter(Boolean);
+        const articleIndex = segments.findIndex((segment) => segment === "article" || segment === "articles");
+        if (articleIndex < 0) {
+            return input;
+        }
+        const articleId = segments[articleIndex + 1] ?? fallbackId;
+        if (!articleId) {
+            return input;
+        }
+        if (articleIndex > 0 && segments[0] !== "i") {
+            return `${url.origin}/${segments[0]}/article/${articleId}`;
+        }
+        return `${url.origin}/i/article/${articleId}`;
+    }
+    catch {
+        return input;
+    }
+}
 function enrichNotificationItem(item) {
     const text = normalizeInlineText(item.text);
     const summary = item.summary ? normalizeInlineText(item.summary) : undefined;
@@ -998,6 +1590,7 @@ function enrichNotificationItem(item) {
     return next;
 }
 const READ_PAGE_CACHE = new WeakMap();
+const ARTICLE_DRAFT_PAGE_CACHE = new WeakMap();
 const PROCESS_TEMPLATE_CACHE = new TemplateCache();
 async function readTimelineViaNetwork(page, options) {
     const fallbackTemplate = PROCESS_TEMPLATE_CACHE.get(options.mode);
@@ -1202,7 +1795,20 @@ async function readTimelineViaNetwork(page, options) {
                             item.createdAt = createdAt;
                         }
                         if (media.length > 0) {
-                            item.media = toTweetMediaArray(media);
+                            item.media = media;
+                        }
+                        const articleResult = tweet?.article?.article_results
+                            ?.result ?? undefined;
+                        const articleRestId = typeof articleResult?.rest_id === "string" ? articleResult.rest_id : "";
+                        if (articleRestId) {
+                            const screenName = typeof userLegacy.screen_name === "string" ? userLegacy.screen_name : "";
+                            const articleUrl = screenName
+                                ? `https://x.com/${screenName.replace(/^@+/, "")}/article/${articleRestId}`
+                                : `https://x.com/i/article/${articleRestId}`;
+                            item.article = {
+                                id: articleRestId,
+                                url: articleUrl,
+                            };
                         }
                         outputItems.push(item);
                     }
@@ -1468,7 +2074,15 @@ async function extractTweetCards(page, limit) {
             }
             const media = collectDomMedia(article);
             if (media.length > 0) {
-                item.media = toTweetMediaArray(media);
+                item.media = media;
+            }
+            const articleAnchor = article.querySelector("a[href*='/article/'], a[href*='/i/article/'], a[href*='/articles/']");
+            const articleUrl = canonicalizeArticleUrl(articleAnchor?.href);
+            const articleId = articleUrl ? articleUrl.match(/\/article(?:s)?\/(\d+)/)?.[1] : undefined;
+            if (articleId) {
+                item.article = articleUrl
+                    ? { id: articleId, url: articleUrl }
+                    : { id: articleId };
             }
             pushItem(item);
             if (items.length >= maxItems) {
@@ -1496,7 +2110,15 @@ async function extractTweetCards(page, limit) {
                 }
                 const media = collectDomMedia(cell);
                 if (media.length > 0) {
-                    item.media = toTweetMediaArray(media);
+                    item.media = media;
+                }
+                const articleAnchor = cell.querySelector("a[href*='/article/'], a[href*='/i/article/'], a[href*='/articles/']");
+                const articleUrl = canonicalizeArticleUrl(articleAnchor?.href);
+                const articleId = articleUrl ? articleUrl.match(/\/article(?:s)?\/(\d+)/)?.[1] : undefined;
+                if (articleId) {
+                    item.article = articleUrl
+                        ? { id: articleId, url: articleUrl }
+                        : { id: articleId };
                 }
                 pushItem(item);
             }
@@ -1791,6 +2413,51 @@ async function closeCachedReadPages(ownerPage) {
         }
     }
 }
+function getArticleDraftPageCache(ownerPage) {
+    let cache = ARTICLE_DRAFT_PAGE_CACHE.get(ownerPage);
+    if (!cache) {
+        cache = new Map();
+        ARTICLE_DRAFT_PAGE_CACHE.set(ownerPage, cache);
+    }
+    return cache;
+}
+async function cacheArticleDraftPage(ownerPage, articleId, articlePage) {
+    const cache = getArticleDraftPageCache(ownerPage);
+    const existing = cache.get(articleId);
+    if (existing && existing !== articlePage && !existing.isClosed()) {
+        await existing.close().catch(() => { });
+    }
+    cache.set(articleId, articlePage);
+}
+function getCachedArticleDraftPage(ownerPage, articleId) {
+    const cache = ARTICLE_DRAFT_PAGE_CACHE.get(ownerPage);
+    const page = cache?.get(articleId);
+    if (!page || page.isClosed()) {
+        cache?.delete(articleId);
+        return undefined;
+    }
+    return page;
+}
+async function removeCachedArticleDraftPage(ownerPage, articleId) {
+    const cache = ARTICLE_DRAFT_PAGE_CACHE.get(ownerPage);
+    const page = cache?.get(articleId);
+    cache?.delete(articleId);
+    if (page && !page.isClosed()) {
+        await page.close().catch(() => { });
+    }
+}
+async function closeCachedArticleDraftPages(ownerPage) {
+    const cache = ARTICLE_DRAFT_PAGE_CACHE.get(ownerPage);
+    ARTICLE_DRAFT_PAGE_CACHE.delete(ownerPage);
+    if (!cache) {
+        return;
+    }
+    for (const articlePage of cache.values()) {
+        if (!articlePage.isClosed()) {
+            await articlePage.close().catch(() => { });
+        }
+    }
+}
 async function waitForTweetSurface(page) {
     await page
         .waitForFunction(() => {
@@ -1814,6 +2481,9 @@ function mapTweetCards(items) {
         if (item.media && item.media.length > 0) {
             mapped.media = item.media;
         }
+        if (item.article) {
+            mapped.article = item.article;
+        }
         return mapped;
     });
 }
@@ -2576,62 +3246,2344 @@ async function waitForReplyConfirmation(page, targetUrl, text, timeoutMs) {
     const secondPassTimeoutMs = Math.max(2_500, timeoutMs - firstPassTimeoutMs);
     return await waitForComposeConfirmation(page, text, secondPassTimeoutMs);
 }
-async function waitForGrokSurface(page) {
+async function deleteTweetDetail(page, targetUrl, dryRun) {
+    const matchId = targetUrl.match(/status\/(\d+)/)?.[1];
+    return await withEphemeralPage(page, targetUrl, async (detailPage) => {
+        await waitForTweetSurface(detailPage);
+        const menuOpened = await detailPage.evaluate(({ op }) => {
+            if (op !== "tweet_open_delete_menu") {
+                return false;
+            }
+            const menuButton = Array.from(document.querySelectorAll("button, div[role='button']")).find((element) => {
+                const testId = element.getAttribute("data-testid") || "";
+                const aria = (element.getAttribute("aria-label") || "").replace(/\s+/g, " ").trim();
+                return testId === "caret" || aria === "More";
+            });
+            if (!menuButton) {
+                return false;
+            }
+            menuButton.click();
+            return true;
+        }, { op: "tweet_open_delete_menu" }).catch(() => false);
+        if (!menuOpened) {
+            return errorResult("UPSTREAM_CHANGED", "tweet delete controls not found", {
+                reason: "more_button_not_found",
+            });
+        }
+        const deleteReady = await detailPage.waitForFunction(() => {
+            return Array.from(document.querySelectorAll("[role='menuitem'], button, div[role='button']")).some((element) => {
+                const text = (element.textContent || "").replace(/\s+/g, " ").trim();
+                return text === "Delete";
+            });
+        }, undefined, { timeout: 5_000 }).then(() => true).catch(() => false);
+        if (!deleteReady) {
+            return errorResult("UPSTREAM_CHANGED", "tweet delete controls not found", {
+                reason: "delete_menu_item_not_found",
+            });
+        }
+        if (dryRun) {
+            const output = {
+                ok: true,
+                dryRun: true,
+                deleteVisible: true,
+            };
+            if (matchId) {
+                output.tweetId = matchId;
+            }
+            output.url = targetUrl;
+            return output;
+        }
+        const firstDelete = await detailPage.evaluate(({ op }) => {
+            if (op !== "tweet_click_delete_menu_item") {
+                return false;
+            }
+            const item = Array.from(document.querySelectorAll("[role='menuitem'], button, div[role='button']")).find((element) => {
+                const text = (element.textContent || "").replace(/\s+/g, " ").trim();
+                return text === "Delete";
+            });
+            if (!item) {
+                return false;
+            }
+            item.click();
+            return true;
+        }, { op: "tweet_click_delete_menu_item" }).catch(() => false);
+        if (!firstDelete) {
+            return errorResult("UPSTREAM_CHANGED", "tweet delete controls not found", {
+                reason: "delete_menu_click_failed",
+            });
+        }
+        await detailPage.waitForTimeout(700);
+        await detailPage.evaluate(({ op }) => {
+            if (op !== "tweet_confirm_delete") {
+                return;
+            }
+            const dialog = document.querySelector("[role='dialog'], [data-testid='confirmationSheetDialog']");
+            const dialogButtons = dialog
+                ? Array.from(dialog.querySelectorAll("button, div[role='button']"))
+                : [];
+            const dialogConfirm = dialogButtons.find((element) => {
+                const testId = element.getAttribute("data-testid") || "";
+                const text = (element.textContent || "").replace(/\s+/g, " ").trim();
+                return testId === "confirmationSheetConfirm" || text === "Delete";
+            });
+            if (dialogConfirm) {
+                dialogConfirm.click();
+                return;
+            }
+            const fallback = Array.from(document.querySelectorAll("button, div[role='button']")).filter((element) => {
+                const text = (element.textContent || "").replace(/\s+/g, " ").trim();
+                return text === "Delete";
+            });
+            fallback[fallback.length - 1]?.click();
+        }, { op: "tweet_confirm_delete" }).catch(() => { });
+        const deleted = await detailPage
+            .waitForFunction(({ tweetId }) => {
+            const bodyText = document.body?.innerText || "";
+            if (bodyText.includes("This Post was deleted") || bodyText.includes("This Tweet was deleted")) {
+                return true;
+            }
+            if (tweetId) {
+                const currentUrl = window.location.href;
+                return !currentUrl.includes(`/status/${tweetId}`);
+            }
+            return false;
+        }, { tweetId: matchId }, { timeout: 15_000 })
+            .then(() => true)
+            .catch(() => false);
+        if (!deleted) {
+            return errorResult("ACTION_UNCONFIRMED", "tweet delete was not confirmed");
+        }
+        const output = {
+            ok: true,
+            confirmed: true,
+            url: targetUrl,
+        };
+        if (matchId) {
+            output.tweetId = matchId;
+        }
+        return output;
+    });
+}
+async function waitForArticleEditorSurface(page) {
     await page
         .waitForFunction(() => {
-        const composer = document.querySelector("textarea") ||
-            document.querySelector("[contenteditable='true'][role='textbox']") ||
-            document.querySelector("[role='textbox'][contenteditable='true']");
-        const messages = document.querySelector("[data-message-author-role='assistant']") ||
-            document.querySelector("[data-testid*='assistant']") ||
-            document.querySelector("article");
-        return composer !== null || messages !== null;
-    }, undefined, { timeout: 12_000 })
+        const title = document.querySelector("textarea[placeholder='Add a title']");
+        const composer = document.querySelector("[data-testid='composer'][role='textbox']");
+        const publishButton = Array.from(document.querySelectorAll("button")).find((button) => (button.textContent || "").replace(/\s+/g, " ").trim() === "Publish");
+        return title !== null && composer !== null && publishButton !== undefined;
+    }, undefined, { timeout: 20_000 })
         .catch(() => { });
     await page.waitForTimeout(800);
 }
-async function submitGrokPrompt(page, prompt) {
-    const composerSelectors = [
-        "textarea",
-        "[contenteditable='true'][role='textbox']",
-        "[role='textbox'][contenteditable='true']",
-    ];
-    const submitSelectors = [
-        "button[aria-label*='Grok something']",
-        "button[aria-label*='Send']",
-        "button[aria-label*='send']",
-        "button[data-testid*='send']",
-        "button[type='submit']",
+async function ensureArticleDraftLoaded(page, articleId) {
+    if (!articleId) {
+        return;
+    }
+    const hasContent = async () => {
+        return await page.evaluate(() => {
+            const title = document.querySelector("textarea[placeholder='Add a title']");
+            const composer = document.querySelector("[data-testid='composer'][role='textbox']");
+            const titleValue = title instanceof HTMLTextAreaElement ? title.value.trim() : "";
+            const composerText = composer instanceof HTMLElement ? (composer.textContent || "").trim() : "";
+            return titleValue.length > 0 || composerText.length > 0;
+        }).catch(() => false);
+    };
+    if (await hasContent()) {
+        return;
+    }
+    await page.goto("https://x.com/compose/articles", { waitUntil: "domcontentloaded", timeout: 60_000 }).catch(() => { });
+    await page.waitForTimeout(1_200);
+    await page.evaluate(({ targetId }) => {
+        const anchors = Array.from(document.querySelectorAll("a[href]"));
+        const draftAnchor = anchors.find((anchor) => anchor.href.includes(`/compose/articles/edit/${targetId}`));
+        draftAnchor?.click();
+    }, { targetId: articleId }).catch(() => { });
+    await page.waitForTimeout(1_200);
+    if (await hasContent()) {
+        return;
+    }
+    await page.goto(`https://x.com/compose/articles/edit/${articleId}`, { waitUntil: "domcontentloaded", timeout: 60_000 }).catch(() => { });
+    await waitForArticleEditorSurface(page);
+    await page.waitForTimeout(1_000);
+}
+async function waitForArticleDraftPersisted(page, articleId, title) {
+    await page
+        .evaluate(() => {
+        const active = document.activeElement;
+        if (active instanceof HTMLElement) {
+            active.blur();
+        }
+    })
+        .catch(() => { });
+    await page.keyboard.press("Escape").catch(() => { });
+    return await page
+        .waitForFunction(({ targetId, expectedTitle }) => {
+        const anchors = Array.from(document.querySelectorAll("a[href]"));
+        const draftAnchor = anchors.find((anchor) => anchor.href.includes(`/compose/articles/edit/${targetId}`));
+        const containerText = draftAnchor?.closest("article, li, div")?.textContent || draftAnchor?.textContent || "";
+        const normalized = containerText.replace(/\s+/g, " ").trim();
+        return normalized.includes(expectedTitle) && !normalized.includes("(Needs title)");
+    }, { targetId: articleId, expectedTitle: title.trim() }, { timeout: 20_000 })
+        .then(() => true)
+        .catch(() => false);
+}
+async function openNewArticleEditor(page) {
+    await page.goto("https://x.com/compose/articles", { waitUntil: "domcontentloaded", timeout: 60_000 }).catch(() => { });
+    await page.waitForTimeout(2_500);
+    let clicked = false;
+    const createSelectors = [
+        "a[data-testid='empty_state_button_text']",
+        "button[aria-label='create']",
+        "a:has-text('Write')",
     ];
-    const selectAllShortcut = process.platform === "darwin" ? "Meta+A" : "Control+A";
-    let composerSelector;
-    for (const selector of composerSelectors) {
-        const handle = await page.waitForSelector(selector, { timeout: 1_200 }).catch(() => null);
-        if (!handle) {
-            continue;
+    for (const selector of createSelectors) {
+        try {
+            await page.click(selector, { timeout: 4_000 });
+            clicked = true;
+            break;
+        }
+        catch {
+            // Try the next known article entry point.
         }
-        await handle.dispose().catch(() => { });
-        composerSelector = selector;
-        break;
     }
-    if (!composerSelector) {
-        return { ok: false, reason: "composer_not_found" };
+    if (!clicked) {
+        const openedExistingDraft = await page
+            .evaluate(() => {
+            const draftAnchor = Array.from(document.querySelectorAll("a[href]")).find((anchor) => {
+                return anchor.href.includes("/compose/articles/edit/");
+            });
+            if (!draftAnchor) {
+                return false;
+            }
+            draftAnchor.click();
+            return true;
+        })
+            .catch(() => false);
+        if (openedExistingDraft) {
+            try {
+                await page.waitForFunction(() => window.location.pathname.includes("/compose/articles/edit/"), undefined, { timeout: 20_000 });
+                await waitForArticleEditorSurface(page);
+                return { ok: true, editUrl: page.url() };
+            }
+            catch {
+                // Fall through to existing edit-url fallback below.
+            }
+        }
+        if (page.url().includes("/compose/articles/edit/")) {
+            await waitForArticleEditorSurface(page);
+            return { ok: true, editUrl: page.url() };
+        }
+        return { ok: false, reason: "create_button_not_found" };
     }
     try {
-        await page.click(composerSelector);
-        await page.keyboard.press(selectAllShortcut).catch(() => { });
-        await page.keyboard.press("Backspace").catch(() => { });
-        await page.type(composerSelector, prompt, { delay: 12 });
+        await page.waitForFunction(({ op }) => op === "article_wait_editor" && window.location.pathname.includes("/compose/articles/edit/"), { op: "article_wait_editor" }, {
+            timeout: 20_000,
+        });
     }
     catch {
-        return { ok: false, reason: "compose_input_failed" };
+        return { ok: false, reason: "edit_url_not_reached" };
     }
-    const submitSelector = await page.evaluate((selectors) => {
-        const normalize = (value) => value.replace(/\s+/g, " ").trim().toLowerCase();
-        for (const selector of selectors) {
-            const element = document.querySelector(selector);
-            if (!element) {
-                continue;
+    await waitForArticleEditorSurface(page);
+    const editUrl = page.url();
+    return { ok: true, editUrl };
+}
+async function setArticleTitle(page, title) {
+    const trimmed = title.trim();
+    if (!trimmed) {
+        return false;
+    }
+    let interacted = false;
+    if (typeof page.locator === "function") {
+        const titleLocator = page.locator("textarea[placeholder='Add a title']").first();
+        interacted = await titleLocator.click().then(() => true).catch(() => false);
+        if (interacted) {
+            await page.keyboard.press("Meta+A").catch(() => { });
+            await page.keyboard.press("Backspace").catch(() => { });
+            const keyboard = page.keyboard;
+            if (typeof keyboard.insertText === "function") {
+                interacted = await keyboard.insertText(trimmed).then(() => true).catch(() => false);
+            }
+            else if (typeof keyboard.type === "function") {
+                interacted = await keyboard.type(trimmed).then(() => true).catch(() => false);
+            }
+            else {
+                interacted = await titleLocator.fill(trimmed).then(() => true).catch(() => false);
+            }
+            await titleLocator.blur().catch(() => { });
+        }
+    }
+    const injected = interacted
+        ? true
+        : await page.evaluate(({ op, value }) => {
+            if (op !== "article_set_title") {
+                return false;
+            }
+            const input = document.querySelector("textarea[placeholder='Add a title']");
+            if (!(input instanceof HTMLTextAreaElement)) {
+                return false;
+            }
+            input.focus();
+            input.value = "";
+            input.dispatchEvent(new Event("input", { bubbles: true }));
+            input.value = value;
+            input.dispatchEvent(new Event("input", { bubbles: true }));
+            input.dispatchEvent(new Event("change", { bubbles: true }));
+            return true;
+        }, { op: "article_set_title", value: trimmed }).catch(() => false);
+    if (!injected) {
+        return false;
+    }
+    return await page
+        .waitForFunction(({ expectedTitle }) => {
+        const input = document.querySelector("textarea[placeholder='Add a title']");
+        return input instanceof HTMLTextAreaElement && input.value.trim() === expectedTitle;
+    }, { expectedTitle: trimmed }, { timeout: 3_000 })
+        .then(() => true)
+        .catch(() => false);
+}
+async function pasteArticleMarkdown(page, markdown, html) {
+    let pasted = false;
+    if (typeof page.locator === "function") {
+        const composerLocator = page.locator("[data-testid='composer'][role='textbox']").first();
+        const clicked = await composerLocator.click().then(() => true).catch(() => false);
+        if (clicked) {
+            const wroteClipboard = await page.evaluate(async ({ plainText, htmlText }) => {
+                try {
+                    const ClipboardItemCtor = window.ClipboardItem;
+                    if (typeof navigator.clipboard?.write === "function" && ClipboardItemCtor) {
+                        const items = {
+                            "text/plain": new Blob([plainText], { type: "text/plain" }),
+                        };
+                        if (typeof htmlText === "string" && htmlText.trim().length > 0) {
+                            items["text/html"] = new Blob([htmlText], { type: "text/html" });
+                        }
+                        await navigator.clipboard.write([new ClipboardItemCtor(items)]);
+                    }
+                    else if (typeof navigator.clipboard?.writeText === "function") {
+                        await navigator.clipboard.writeText(plainText);
+                    }
+                    else {
+                        return false;
+                    }
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            }, { plainText: markdown, htmlText: html }).catch(() => false);
+            if (wroteClipboard) {
+                const pasteShortcut = process.platform === "darwin" ? "Meta+V" : "Control+V";
+                pasted = await page.keyboard.press(pasteShortcut).then(() => true).catch(() => false);
+            }
+            if (!pasted) {
+                const keyboard = page.keyboard;
+                if (typeof keyboard.insertText === "function") {
+                    pasted = await keyboard.insertText(markdown).then(() => true).catch(() => false);
+                }
+                else if (typeof keyboard.type === "function") {
+                    pasted = await keyboard.type(markdown).then(() => true).catch(() => false);
+                }
+            }
+        }
+    }
+    if (!pasted) {
+        pasted = await page.evaluate(({ op, markdownText, htmlText }) => {
+            if (op !== "article_paste_markdown") {
+                return false;
+            }
+            const composer = document.querySelector("[data-testid='composer'][role='textbox']");
+            if (!(composer instanceof HTMLElement)) {
+                return false;
+            }
+            composer.focus();
+            const data = new DataTransfer();
+            data.setData("text/plain", markdownText);
+            data.setData("text/markdown", markdownText);
+            if (typeof htmlText === "string" && htmlText.trim().length > 0) {
+                data.setData("text/html", htmlText);
+            }
+            const event = new ClipboardEvent("paste", {
+                bubbles: true,
+                cancelable: true,
+                clipboardData: data,
+            });
+            composer.dispatchEvent(event);
+            return true;
+        }, { op: "article_paste_markdown", markdownText: markdown, htmlText: html }).catch(() => false);
+    }
+    if (!pasted) {
+        return false;
+    }
+    const requiredSnippets = extractArticleConfirmationSnippets(markdown);
+    if (requiredSnippets.length === 0) {
+        return true;
+    }
+    try {
+        await page.waitForFunction(({ snippets }) => {
+            const bodyText = document.body?.innerText ?? "";
+            return snippets.every((snippet) => bodyText.includes(snippet));
+        }, { snippets: requiredSnippets }, { timeout: 10_000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function triggerArticleCoverUpload(page) {
+    return ((await page.evaluate(({ op }) => {
+        if (op !== "article_trigger_cover_upload") {
+            return false;
+        }
+        const hint = Array.from(document.querySelectorAll("button, div[role='button'], label, div")).find((element) => {
+            const text = (element.textContent || "").replace(/\s+/g, " ").trim();
+            return text.includes("5:2 aspect ratio");
+        });
+        if (hint) {
+            hint.click();
+            return true;
+        }
+        const button = Array.from(document.querySelectorAll("button")).find((element) => {
+            const aria = (element.getAttribute("aria-label") || "").toLowerCase();
+            const text = (element.textContent || "").replace(/\s+/g, " ").trim().toLowerCase();
+            return aria.includes("cover") || text.includes("cover");
+        });
+        if (button) {
+            button.click();
+            return true;
+        }
+        return document.querySelector("input[data-testid='fileInput']") !== null;
+    }, { op: "article_trigger_cover_upload" }).catch(() => false)) === true);
+}
+async function triggerArticleInlineImageUpload(page) {
+    return ((await page.evaluate(({ op }) => {
+        if (op !== "article_trigger_inline_upload") {
+            return false;
+        }
+        const candidates = [
+            "button[aria-label='Add Media']",
+            "button[aria-label='Add photos or video']",
+        ];
+        for (const selector of candidates) {
+            const button = document.querySelector(selector);
+            if (!button) {
+                continue;
+            }
+            button.click();
+            return true;
+        }
+        return document.querySelector("input[data-testid='fileInput']") !== null;
+    }, { op: "article_trigger_inline_upload" }).catch(() => false)) === true);
+}
+async function uploadArticleFile(page, filePath) {
+    try {
+        await page.setInputFiles("input[data-testid='fileInput']", filePath);
+        const applyReady = await page
+            .waitForFunction(() => {
+            const buttons = Array.from(document.querySelectorAll("button"));
+            const apply = buttons.find((button) => (button.textContent || "").replace(/\s+/g, " ").trim() === "Apply");
+            if (!apply) {
+                return false;
+            }
+            const ariaDisabled = (apply.getAttribute("aria-disabled") || "").toLowerCase();
+            return !apply.disabled && ariaDisabled !== "true";
+        }, undefined, { timeout: 8_000 })
+            .then(() => true)
+            .catch(() => false);
+        if (applyReady) {
+            if (typeof page.locator === "function") {
+                const applyLocator = page.locator("button:has-text('Apply')").last();
+                await applyLocator.click({ timeout: 2_000, force: true }).catch(() => { });
+            }
+            else {
+                await page.click("button:has-text('Apply')", { timeout: 2_000 }).catch(() => { });
+            }
+            await page
+                .evaluate(() => {
+                const buttons = Array.from(document.querySelectorAll("button, div[role='button']")).filter((element) => {
+                    const text = (element.textContent || "").replace(/\s+/g, " ").trim();
+                    return text === "Apply";
+                });
+                const button = buttons[buttons.length - 1];
+                button?.click();
+            })
+                .catch(() => { });
+            await page
+                .waitForFunction(() => {
+                const buttons = Array.from(document.querySelectorAll("button"));
+                return !buttons.some((button) => (button.textContent || "").replace(/\s+/g, " ").trim() === "Apply");
+            }, undefined, { timeout: 8_000 })
+                .catch(() => { });
+        }
+        else {
+            await page.waitForTimeout(1_500);
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForArticleCoverApplied(page) {
+    return await page
+        .waitForFunction(() => {
+        const hasRemoveControl = Array.from(document.querySelectorAll("button, div[role='button']")).some((element) => {
+            const aria = (element.getAttribute("aria-label") || "").toLowerCase();
+            const text = (element.textContent || "").replace(/\s+/g, " ").trim().toLowerCase();
+            return aria.includes("remove photo") || text === "remove photo";
+        });
+        const coverImages = Array.from((document.querySelector("main") ?? document.body).querySelectorAll("img[src]"))
+            .filter((img) => !img.closest("nav, header, aside"))
+            .map((img) => ({
+            url: img.currentSrc || img.src,
+            width: img.naturalWidth || 0,
+            height: img.naturalHeight || 0,
+        }))
+            .filter((item) => /^https?:\/\//.test(item.url))
+            .filter((item) => !/\/profile_images\/|\/emoji\/|\/hashflags\//.test(item.url))
+            .filter((item) => item.width >= 200 || item.height >= 120);
+        return hasRemoveControl && coverImages.length > 0;
+    }, undefined, { timeout: 15_000 })
+        .then(() => true)
+        .catch(() => false);
+}
+async function placeArticleCursorAtMarker(page, marker) {
+    return ((await page.evaluate(({ op, markerText }) => {
+        if (op !== "article_place_marker") {
+            return false;
+        }
+        const composer = document.querySelector("[data-testid='composer'][role='textbox']");
+        if (!(composer instanceof HTMLElement)) {
+            return false;
+        }
+        const walker = document.createTreeWalker(composer, NodeFilter.SHOW_TEXT);
+        let current = walker.nextNode();
+        while (current) {
+            const textNode = current;
+            const content = textNode.textContent ?? "";
+            const index = content.indexOf(markerText);
+            if (index >= 0) {
+                const selection = window.getSelection();
+                if (!selection) {
+                    return false;
+                }
+                const range = document.createRange();
+                range.setStart(textNode, index);
+                range.setEnd(textNode, index + markerText.length);
+                selection.removeAllRanges();
+                selection.addRange(range);
+                return true;
+            }
+            current = walker.nextNode();
+        }
+        return false;
+    }, { op: "article_place_marker", markerText: marker }).catch(() => false)) === true);
+}
+async function deleteArticleSelectedMarker(page) {
+    await page.keyboard.press("Backspace").catch(() => { });
+    await page.waitForTimeout(200);
+}
+async function uploadArticleInlineImages(page, images) {
+    for (const image of images) {
+        const resolved = await resolveArticleAttachment(image.path, image.marker);
+        if (!resolved.ok || !resolved.attachment) {
+            return { ok: false, reason: "inline_image_missing" };
+        }
+        const positioned = await placeArticleCursorAtMarker(page, image.marker);
+        if (!positioned) {
+            return { ok: false, reason: "inline_marker_not_found" };
+        }
+        await deleteArticleSelectedMarker(page);
+        const triggered = await triggerArticleInlineImageUpload(page);
+        if (!triggered) {
+            return { ok: false, reason: "inline_upload_trigger_not_found" };
+        }
+        const uploaded = await uploadArticleFile(page, resolved.attachment.path);
+        if (!uploaded) {
+            return { ok: false, reason: "inline_upload_failed" };
+        }
+    }
+    return { ok: true };
+}
+async function clearArticleBody(page) {
+    let cleared = false;
+    if (typeof page.locator === "function") {
+        const composerLocator = page.locator("[data-testid='composer'][role='textbox']").first();
+        cleared = await composerLocator.click().then(() => true).catch(() => false);
+        if (cleared) {
+            await page.keyboard.press("Meta+A").catch(() => { });
+            await page.keyboard.press("Backspace").catch(() => { });
+            await page.waitForTimeout(200);
+        }
+    }
+    if (cleared) {
+        return true;
+    }
+    return await page.evaluate(({ op }) => {
+        if (op !== "article_clear_body") {
+            return false;
+        }
+        const composer = document.querySelector("[data-testid='composer'][role='textbox']");
+        if (!(composer instanceof HTMLElement)) {
+            return false;
+        }
+        composer.focus();
+        composer.textContent = "";
+        composer.dispatchEvent(new Event("input", { bubbles: true }));
+        return true;
+    }, { op: "article_clear_body" }).catch(() => false);
+}
+function parseArticleIdFromUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url, "https://x.com");
+    }
+    catch {
+        return undefined;
+    }
+    if (!ALLOWED_X_HOSTS.has(parsed.hostname.toLowerCase())) {
+        return undefined;
+    }
+    const match = parsed.pathname.match(/^\/(?:compose\/articles\/edit|i\/article|i\/articles|[^/]+\/article|articles)\/(\d+)(?:\/preview)?(?:\/|$)/);
+    return match?.[1];
+}
+function buildArticleEditUrl(articleId) {
+    return `https://x.com/compose/articles/edit/${encodeURIComponent(articleId)}`;
+}
+function buildArticlePreviewUrl(articleId) {
+    return `https://x.com/i/articles/${encodeURIComponent(articleId)}/preview`;
+}
+function isArticlePreviewUrl(url) {
+    try {
+        const parsed = new URL(url, "https://x.com");
+        return /\/preview(?:\/|$)/.test(parsed.pathname) && parseArticleIdFromUrl(parsed.toString()) !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForCapturedOperation(page, op, timeoutMs = 10_000) {
+    await page.waitForFunction(({ targetOp }) => {
+        const globalAny = window;
+        const entries = Array.isArray(globalAny.__WEBMCP_X_CAPTURE__?.entries)
+            ? globalAny.__WEBMCP_X_CAPTURE__.entries
+            : [];
+        return entries.some((entry) => entry && entry.op === targetOp && !!entry.url && !!entry.method);
+    }, { targetOp: op }, { timeout: timeoutMs }).catch(() => { });
+}
+function normalizeArticleUrl(url, articleId) {
+    const trimmed = typeof url === "string" ? url.trim() : "";
+    if (trimmed) {
+        return trimmed;
+    }
+    return articleId ? `https://x.com/compose/articles/edit/${encodeURIComponent(articleId)}` : undefined;
+}
+function sanitizeArticleText(text) {
+    return text
+        .replace(/\u00a0/g, " ")
+        .replace(/\s+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+async function waitForArticleReadSurface(page) {
+    await page
+        .waitForFunction(() => {
+        const title = document.querySelector("h1, textarea");
+        const composer = document.querySelector("[data-testid='composer'][role='textbox']");
+        const articleNodes = document.querySelectorAll("article, main img[src], script[type='application/ld+json']").length;
+        return title !== null || composer !== null || articleNodes > 0;
+    }, undefined, { timeout: 12_000 })
+        .catch(() => { });
+    await page.waitForTimeout(600);
+}
+async function readArticleFromEditorPage(page, articleId, sessionScoped) {
+    const article = await page.evaluate(({ op }) => {
+        if (op !== "article_collect_editor") {
+            return undefined;
+        }
+        const normalize = (value) => value.replace(/\s+/g, " ").trim();
+        const title = document.querySelector("textarea")?.value?.trim() ||
+            normalize(document.querySelector("h1")?.innerText || "");
+        const composer = document.querySelector("[data-testid='composer'][role='textbox']");
+        const rawText = (composer?.innerText || composer?.textContent || "").trim();
+        const editorRoot = document.querySelector("main") ?? document.body;
+        const images = Array.from(editorRoot.querySelectorAll("img[src]"))
+            .filter((img) => !img.closest("nav, header, aside, [data-testid='SideNav_AccountSwitcher_Button']"))
+            .map((img) => ({
+            url: img.currentSrc || img.src,
+            alt: normalize(img.alt || ""),
+            width: img.naturalWidth || 0,
+            height: img.naturalHeight || 0,
+        }))
+            .filter((item) => /^https?:\/\//.test(item.url))
+            .filter((item) => item.width > 64 || item.height > 64)
+            .filter((item) => !/\/profile_images\/|\/emoji\/|\/hashflags\//.test(item.url));
+        const deduped = new Map();
+        for (const image of images) {
+            if (!deduped.has(image.url)) {
+                deduped.set(image.url, image.alt ? { url: image.url, alt: image.alt } : { url: image.url });
+            }
+        }
+        return {
+            title,
+            text: rawText,
+            images: Array.from(deduped.values()),
+            editUrl: window.location.href,
+        };
+    }, { op: "article_collect_editor" }).catch(() => undefined);
+    if (!article || typeof article !== "object") {
+        return errorResult("UPSTREAM_CHANGED", "article editor content not found");
+    }
+    const title = typeof article.title === "string" ? article.title : "";
+    const rawText = typeof article.text === "string" ? article.text : "";
+    const normalizedTitleHeading = title ? `# ${title}` : "";
+    let text = sanitizeArticleText(rawText);
+    if (normalizedTitleHeading && text.startsWith(normalizedTitleHeading)) {
+        text = sanitizeArticleText(text.slice(normalizedTitleHeading.length));
+    }
+    const images = Array.isArray(article.images) ? article.images : [];
+    const coverImage = images[0];
+    const inlineImages = coverImage ? images.slice(1) : images;
+    const output = {
+        article: {
+            ...(articleId ? { id: articleId } : {}),
+            title,
+            text,
+            editUrl: typeof article.editUrl === "string" ? article.editUrl : page.url(),
+            images: inlineImages,
+            source: "editor",
+            published: false,
+        },
+    };
+    if (articleId) {
+        output.article.previewUrl = buildArticlePreviewUrl(articleId);
+    }
+    if (coverImage && typeof coverImage === "object" && coverImage !== null && "url" in coverImage) {
+        output.article.coverImageUrl = coverImage.url;
+        output.article.hasCoverImage = true;
+    }
+    else {
+        output.article.hasCoverImage = false;
+    }
+    if (articleId) {
+        output.article.sessionScoped = sessionScoped === true;
+    }
+    return output;
+}
+async function listArticleDrafts(page) {
+    return await withEphemeralPage(page, "https://x.com/compose/articles", async (articlePage) => {
+        await articlePage.waitForTimeout(1_000);
+        await waitForCapturedOperation(articlePage, "ArticleEntitiesSlice", 12_000);
+        const result = await articlePage.evaluate(async ({ op }) => {
+            if (op !== "article_list_drafts") {
+                return undefined;
+            }
+            const normalizeInline = (value) => value.replace(/\s+/g, " ").trim();
+            const parseJsonSafely = (value) => {
+                if (!value) {
+                    return {};
+                }
+                try {
+                    const parsed = JSON.parse(value);
+                    return typeof parsed === "object" && parsed !== null ? parsed : {};
+                }
+                catch {
+                    return {};
+                }
+            };
+            const toHttpsImage = (value) => typeof value === "string" && /^https?:\/\//.test(value) ? value : undefined;
+            const sanitizeHeaders = (headers) => {
+                const blockedPrefixes = ["sec-", ":"];
+                const blockedExact = new Set(["host", "content-length", "cookie", "origin", "referer", "connection"]);
+                const output = {};
+                if (!headers) {
+                    return output;
+                }
+                for (const [key, value] of Object.entries(headers)) {
+                    const normalized = key.toLowerCase();
+                    if (blockedExact.has(normalized) || blockedPrefixes.some((prefix) => normalized.startsWith(prefix))) {
+                        continue;
+                    }
+                    output[normalized] = value;
+                }
+                return output;
+            };
+            const extractUpdatedAt = (record) => {
+                const metadata = record.metadata ?? {};
+                const candidates = [
+                    metadata.updated_at_secs,
+                    metadata.last_edited_at_secs,
+                    metadata.last_updated_at_secs,
+                    metadata.created_at_secs,
+                    metadata.first_published_at_secs,
+                ];
+                for (const candidate of candidates) {
+                    if (typeof candidate === "number" && Number.isFinite(candidate) && candidate > 0) {
+                        return new Date(candidate * 1000).toISOString();
+                    }
+                }
+                return undefined;
+            };
+            const extractNextCursor = (sliceInfo) => {
+                if (!sliceInfo || typeof sliceInfo !== "object" || Array.isArray(sliceInfo)) {
+                    return undefined;
+                }
+                const record = sliceInfo;
+                const keys = ["next_cursor", "nextCursor", "cursor", "bottom_cursor"];
+                for (const key of keys) {
+                    if (typeof record[key] === "string" && record[key]) {
+                        return record[key];
+                    }
+                }
+                return undefined;
+            };
+            const globalAny = window;
+            const entries = Array.isArray(globalAny.__WEBMCP_X_CAPTURE__?.entries)
+                ? globalAny.__WEBMCP_X_CAPTURE__?.entries ?? []
+                : [];
+            const template = (() => {
+                for (let i = entries.length - 1; i >= 0; i -= 1) {
+                    const entry = entries[i];
+                    if (!entry || entry.op !== "ArticleEntitiesSlice" || !entry.url || !entry.method) {
+                        continue;
+                    }
+                    return {
+                        url: entry.url,
+                        method: entry.method,
+                        headers: entry.headers ?? {},
+                    };
+                }
+                return null;
+            })();
+            if (!template) {
+                return { drafts: [] };
+            }
+            const templateUrl = new URL(template.url, location.origin);
+            const templateVariables = parseJsonSafely(templateUrl.searchParams.get("variables"));
+            const templateFeatures = parseJsonSafely(templateUrl.searchParams.get("features"));
+            const headers = sanitizeHeaders(template.headers);
+            const userId = typeof templateVariables.userId === "string" ? templateVariables.userId : "";
+            if (!userId) {
+                return { drafts: [] };
+            }
+            const fetchSlice = async (cursor) => {
+                const vars = {
+                    ...templateVariables,
+                    userId,
+                    lifecycle: "Draft",
+                    count: 20,
+                };
+                if (cursor) {
+                    vars.cursor = cursor;
+                }
+                else {
+                    delete vars.cursor;
+                }
+                const requestUrl = new URL(template.url, location.origin);
+                requestUrl.searchParams.set("variables", JSON.stringify(vars));
+                if (Object.keys(templateFeatures).length > 0) {
+                    requestUrl.searchParams.set("features", JSON.stringify(templateFeatures));
+                }
+                const response = await fetch(requestUrl.toString(), {
+                    method: template.method,
+                    headers,
+                    credentials: "include",
+                });
+                if (!response.ok) {
+                    throw new Error(`http_${response.status}`);
+                }
+                return await response.json();
+            };
+            const drafts = [];
+            let cursor;
+            for (let pageIndex = 0; pageIndex < 8; pageIndex += 1) {
+                let responseJson;
+                try {
+                    responseJson = await fetchSlice(cursor);
+                }
+                catch {
+                    break;
+                }
+                const slice = responseJson?.data?.user;
+                const result = slice?.result?.articles_article_mixer_slice;
+                const items = Array.isArray(result?.items) ? result.items : [];
+                for (const rawItem of items) {
+                    if (!rawItem || typeof rawItem !== "object" || Array.isArray(rawItem)) {
+                        continue;
+                    }
+                    const item = rawItem;
+                    const articleResult = item.article_entity_results?.result;
+                    if (!articleResult) {
+                        continue;
+                    }
+                    const restId = typeof articleResult.rest_id === "string" ? articleResult.rest_id : "";
+                    if (!restId) {
+                        continue;
+                    }
+                    const coverMedia = articleResult.cover_media;
+                    const hasCoverImage = toHttpsImage(coverMedia?.original_img_url) ??
+                        toHttpsImage(coverMedia?.media_url_https) ??
+                        toHttpsImage(coverMedia?.media_url);
+                    drafts.push({
+                        id: restId,
+                        title: typeof articleResult.title === "string" ? normalizeInline(articleResult.title) : "",
+                        updatedAt: extractUpdatedAt(articleResult),
+                        hasCoverImage: Boolean(hasCoverImage),
+                        editUrl: buildArticleEditUrl(restId),
+                        previewUrl: buildArticlePreviewUrl(restId),
+                    });
+                }
+                cursor = extractNextCursor(result?.slice_info);
+                if (!cursor) {
+                    break;
+                }
+            }
+            return { drafts };
+        }, { op: "article_list_drafts" }).catch(() => undefined);
+        if (!result || typeof result !== "object" || Array.isArray(result)) {
+            return errorResult("UPSTREAM_CHANGED", "article drafts could not be listed");
+        }
+        const drafts = Array.isArray(result.drafts)
+            ? result.drafts
+            : [];
+        const normalizedDrafts = drafts
+            .map((draft) => {
+            if (!draft || typeof draft !== "object" || Array.isArray(draft)) {
+                return undefined;
+            }
+            const entry = draft;
+            if (typeof entry.id !== "string" ||
+                typeof entry.editUrl !== "string" ||
+                typeof entry.previewUrl !== "string") {
+                return undefined;
+            }
+            return {
+                id: entry.id,
+                editUrl: entry.editUrl,
+                previewUrl: entry.previewUrl,
+                title: typeof entry.title === "string" ? entry.title : "",
+                hasCoverImage: entry.hasCoverImage === true,
+                ...(typeof entry.updatedAt === "string" ? { updatedAt: entry.updatedAt } : {}),
+            };
+        })
+            .filter((draft) => draft !== undefined);
+        for (const draft of normalizedDrafts) {
+            if (draft.hasCoverImage) {
+                continue;
+            }
+            const cachedPage = getCachedArticleDraftPage(page, draft.id);
+            if (cachedPage) {
+                const cachedRead = await readArticleFromEditorPage(cachedPage, draft.id, true);
+                if (cachedRead &&
+                    typeof cachedRead === "object" &&
+                    !Array.isArray(cachedRead) &&
+                    "article" in cachedRead &&
+                    cachedRead.article &&
+                    typeof cachedRead.article === "object" &&
+                    !Array.isArray(cachedRead.article) &&
+                    cachedRead.article.hasCoverImage === true) {
+                    draft.hasCoverImage = true;
+                    continue;
+                }
+            }
+            const liveRead = await withEphemeralPage(page, buildArticleEditUrl(draft.id), async (draftPage) => {
+                await waitForArticleEditorSurface(draftPage);
+                await ensureArticleDraftLoaded(draftPage, draft.id);
+                return await readArticleFromEditorPage(draftPage, draft.id, false);
+            }).catch(() => undefined);
+            if (liveRead &&
+                typeof liveRead === "object" &&
+                !Array.isArray(liveRead) &&
+                "article" in liveRead &&
+                liveRead.article &&
+                typeof liveRead.article === "object" &&
+                !Array.isArray(liveRead.article) &&
+                liveRead.article.hasCoverImage === true) {
+                draft.hasCoverImage = true;
+            }
+        }
+        return {
+            drafts: normalizedDrafts,
+        };
+    });
+}
+async function getArticleDraft(page, targetUrl) {
+    const articleId = parseArticleIdFromUrl(targetUrl);
+    if (!articleId) {
+        return errorResult("VALIDATION_ERROR", "url or id is required");
+    }
+    return await withArticleDraftPage(page, buildArticleEditUrl(articleId), async (articlePage, resolvedId, sessionScoped) => {
+        return await readArticleFromEditorPage(articlePage, resolvedId ?? articleId, sessionScoped);
+    });
+}
+function parseArticleReadErrorCode(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const error = "error" in value ? value.error : undefined;
+    if (!error || typeof error !== "object" || Array.isArray(error)) {
+        return undefined;
+    }
+    return typeof error.code === "string"
+        ? error.code
+        : undefined;
+}
+async function readArticleFromOwnedSlices(page, articleId) {
+    return await withEphemeralPage(page, "https://x.com/compose/articles", async (articlePage) => {
+        await waitForCapturedOperation(articlePage, "ArticleEntitiesSlice", 12_000);
+        const article = await articlePage.evaluate(async ({ op, articleId: targetArticleId }) => {
+            if (op !== "article_collect_owned") {
+                return undefined;
+            }
+            const globalAny = window;
+            const capture = globalAny.__WEBMCP_X_CAPTURE__;
+            const entries = Array.isArray(capture?.entries) ? capture.entries : [];
+            const pickTemplate = () => {
+                for (let i = entries.length - 1; i >= 0; i -= 1) {
+                    const entry = entries[i];
+                    if (!entry || entry.op !== "ArticleEntitiesSlice" || !entry.url || !entry.method) {
+                        continue;
+                    }
+                    return {
+                        url: entry.url,
+                        method: entry.method,
+                        headers: entry.headers ?? {},
+                    };
+                }
+                return null;
+            };
+            const template = pickTemplate();
+            if (!template) {
+                return { error: "no_template" };
+            }
+            const sanitizeHeaders = (headers) => {
+                const blockedPrefixes = ["sec-", ":"];
+                const blockedExact = new Set(["host", "content-length", "cookie", "origin", "referer", "connection"]);
+                const output = {};
+                if (!headers) {
+                    return output;
+                }
+                for (const [key, value] of Object.entries(headers)) {
+                    const normalized = key.toLowerCase();
+                    if (blockedExact.has(normalized) || blockedPrefixes.some((prefix) => normalized.startsWith(prefix))) {
+                        continue;
+                    }
+                    output[normalized] = value;
+                }
+                return output;
+            };
+            const normalizeText = (value) => value.replace(/\u00a0/g, " ").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+            const normalizeInline = (value) => value.replace(/\s+/g, " ").trim();
+            const parseJsonSafely = (value) => {
+                if (!value) {
+                    return {};
+                }
+                try {
+                    const parsed = JSON.parse(value);
+                    return typeof parsed === "object" && parsed !== null ? parsed : {};
+                }
+                catch {
+                    return {};
+                }
+            };
+            const toHttpsImage = (value) => typeof value === "string" && /^https?:\/\//.test(value) ? value : undefined;
+            const parseMediaImage = (value) => {
+                if (!value || typeof value !== "object" || Array.isArray(value)) {
+                    return [];
+                }
+                const record = value;
+                const url = toHttpsImage(record.original_img_url) ??
+                    toHttpsImage(record.media_url_https) ??
+                    toHttpsImage(record.media_url) ??
+                    toHttpsImage(record.image_info?.original_img_url);
+                if (!url) {
+                    return [];
+                }
+                const alt = typeof record.alt_text === "string" ? normalizeInline(record.alt_text) : "";
+                return [alt ? { url, alt } : { url }];
+            };
+            const parseBlocksText = (value) => {
+                if (!Array.isArray(value)) {
+                    return "";
+                }
+                const lines = [];
+                for (const rawBlock of value) {
+                    if (!rawBlock || typeof rawBlock !== "object" || Array.isArray(rawBlock)) {
+                        continue;
+                    }
+                    const block = rawBlock;
+                    const rawText = typeof block.text === "string" ? block.text : "";
+                    const text = normalizeText(rawText);
+                    if (!text) {
+                        lines.push("");
+                        continue;
+                    }
+                    const type = typeof block.type === "string" ? block.type : "";
+                    if (type === "unordered-list-item") {
+                        lines.push(`- ${text}`);
+                    }
+                    else if (type === "ordered-list-item") {
+                        lines.push(`1. ${text}`);
+                    }
+                    else {
+                        lines.push(text);
+                    }
+                }
+                return normalizeText(lines.join("\n"));
+            };
+            const extractNextCursor = (sliceInfo) => {
+                if (!sliceInfo || typeof sliceInfo !== "object" || Array.isArray(sliceInfo)) {
+                    return undefined;
+                }
+                const record = sliceInfo;
+                const keys = ["next_cursor", "nextCursor", "cursor", "bottom_cursor"];
+                for (const key of keys) {
+                    if (typeof record[key] === "string" && record[key]) {
+                        return record[key];
+                    }
+                }
+                return undefined;
+            };
+            const templateUrl = new URL(template.url, location.origin);
+            const templateVariables = parseJsonSafely(templateUrl.searchParams.get("variables"));
+            const templateFeatures = parseJsonSafely(templateUrl.searchParams.get("features"));
+            const headers = sanitizeHeaders(template.headers);
+            const userId = typeof templateVariables.userId === "string" ? templateVariables.userId : "";
+            if (!userId) {
+                return { error: "missing_user_id" };
+            }
+            const fetchSlice = async (lifecycle, cursor) => {
+                const vars = {
+                    ...templateVariables,
+                    userId,
+                    lifecycle,
+                    count: 20,
+                };
+                if (cursor) {
+                    vars.cursor = cursor;
+                }
+                else {
+                    delete vars.cursor;
+                }
+                const requestUrl = new URL(template.url, location.origin);
+                requestUrl.searchParams.set("variables", JSON.stringify(vars));
+                if (Object.keys(templateFeatures).length > 0) {
+                    requestUrl.searchParams.set("features", JSON.stringify(templateFeatures));
+                }
+                const response = await fetch(requestUrl.toString(), {
+                    method: template.method,
+                    headers,
+                    credentials: "include",
+                });
+                if (!response.ok) {
+                    throw new Error(`http_${response.status}`);
+                }
+                return await response.json();
+            };
+            for (const lifecycle of ["Draft", "Published"]) {
+                let cursor;
+                for (let pageIndex = 0; pageIndex < 8; pageIndex += 1) {
+                    let responseJson;
+                    try {
+                        responseJson = await fetchSlice(lifecycle, cursor);
+                    }
+                    catch (error) {
+                        return { error: String(error) };
+                    }
+                    const slice = responseJson?.data?.user;
+                    const result = slice?.result?.articles_article_mixer_slice;
+                    const items = Array.isArray(result?.items) ? result.items : [];
+                    for (const rawItem of items) {
+                        if (!rawItem || typeof rawItem !== "object" || Array.isArray(rawItem)) {
+                            continue;
+                        }
+                        const item = rawItem;
+                        const articleResult = item.article_entity_results?.result;
+                        if (!articleResult) {
+                            continue;
+                        }
+                        const restId = typeof articleResult.rest_id === "string" ? articleResult.rest_id : "";
+                        if (restId !== targetArticleId) {
+                            continue;
+                        }
+                        const title = typeof articleResult.title === "string" ? normalizeInline(articleResult.title) : "";
+                        const text = parseBlocksText(articleResult.content_state?.blocks);
+                        const metadata = articleResult.metadata ?? {};
+                        const authorResult = (metadata.author_results?.result ??
+                            {});
+                        const authorCore = authorResult.core ?? {};
+                        const authorName = typeof authorCore.name === "string" ? normalizeInline(authorCore.name) : "";
+                        const authorHandleRaw = typeof authorCore.screen_name === "string" ? authorCore.screen_name : "";
+                        const authorHandle = authorHandleRaw ? `@${authorHandleRaw.replace(/^@+/, "")}` : "";
+                        const coverMedia = articleResult.cover_media;
+                        const mediaEntities = Array.isArray(articleResult.media_entities) ? articleResult.media_entities : [];
+                        const coverImage = parseMediaImage(coverMedia)[0];
+                        const inlineImages = mediaEntities.flatMap((entry) => parseMediaImage(entry));
+                        const dedupedImages = [];
+                        const seenImageUrls = new Set();
+                        for (const image of inlineImages) {
+                            if (!seenImageUrls.has(image.url) && image.url !== coverImage?.url) {
+                                seenImageUrls.add(image.url);
+                                dedupedImages.push(image);
+                            }
+                        }
+                        const output = {
+                            id: restId,
+                            title,
+                            text,
+                            url: `https://x.com/i/article/${restId}`,
+                            images: dedupedImages,
+                            source: "owner_slice",
+                            published: lifecycle === "Published",
+                        };
+                        if (coverImage?.url) {
+                            output.coverImageUrl = coverImage.url;
+                        }
+                        if (authorName) {
+                            output.authorName = authorName;
+                        }
+                        if (authorHandle) {
+                            output.authorHandle = authorHandle;
+                        }
+                        return output;
+                    }
+                    cursor = extractNextCursor(result?.slice_info);
+                    if (!cursor) {
+                        break;
+                    }
+                }
+            }
+            return { error: "not_found" };
+        }, { op: "article_collect_owned", articleId }).catch(() => undefined);
+        if (!article || typeof article !== "object") {
+            return errorResult("UPSTREAM_CHANGED", "article owner fallback failed");
+        }
+        if ("error" in article) {
+            return errorResult("UPSTREAM_CHANGED", "article owner fallback failed", article);
+        }
+        const outputArticle = {
+            id: articleId,
+            title: typeof article.title === "string" ? article.title : "",
+            text: sanitizeArticleText(typeof article.text === "string" ? article.text : ""),
+            url: typeof article.url === "string" ? article.url : `https://x.com/i/article/${articleId}`,
+            images: Array.isArray(article.images) ? article.images : [],
+            source: typeof article.source === "string" ? article.source : "owner_slice",
+            published: article.published === true,
+        };
+        if (typeof article.coverImageUrl === "string" && article.coverImageUrl) {
+            outputArticle.coverImageUrl = article.coverImageUrl;
+        }
+        if (typeof article.authorName === "string" && article.authorName) {
+            outputArticle.authorName = article.authorName;
+        }
+        if (typeof article.authorHandle === "string" && article.authorHandle) {
+            outputArticle.authorHandle = article.authorHandle;
+        }
+        return { article: outputArticle };
+    });
+}
+async function readArticleFromProfileArticles(page, articleId, authorHandle) {
+    const normalizedHandle = authorHandle.replace(/^@+/, "").trim();
+    if (!normalizedHandle) {
+        return errorResult("VALIDATION_ERROR", "authorHandle must be a non-empty string");
+    }
+    return await withEphemeralPage(page, `https://x.com/${encodeURIComponent(normalizedHandle)}/articles`, async (articlePage) => {
+        await waitForCapturedOperation(articlePage, "UserArticlesTweets", 15_000);
+        const article = await articlePage.evaluate(async ({ op, articleId: targetArticleId }) => {
+            if (op !== "article_collect_profile") {
+                return undefined;
+            }
+            const globalAny = window;
+            const capture = globalAny.__WEBMCP_X_CAPTURE__;
+            const entries = Array.isArray(capture?.entries) ? capture.entries : [];
+            const template = (() => {
+                for (let i = entries.length - 1; i >= 0; i -= 1) {
+                    const entry = entries[i];
+                    if (!entry || entry.op !== "UserArticlesTweets" || !entry.url || !entry.method) {
+                        continue;
+                    }
+                    return {
+                        url: entry.url,
+                        method: entry.method,
+                        headers: entry.headers ?? {},
+                    };
+                }
+                return null;
+            })();
+            if (!template) {
+                return { error: "no_template" };
+            }
+            const sanitizeHeaders = (headers) => {
+                const blockedPrefixes = ["sec-", ":"];
+                const blockedExact = new Set(["host", "content-length", "cookie", "origin", "referer", "connection"]);
+                const output = {};
+                if (!headers) {
+                    return output;
+                }
+                for (const [key, value] of Object.entries(headers)) {
+                    const normalized = key.toLowerCase();
+                    if (blockedExact.has(normalized) || blockedPrefixes.some((prefix) => normalized.startsWith(prefix))) {
+                        continue;
+                    }
+                    output[normalized] = value;
+                }
+                return output;
+            };
+            const normalizeText = (value) => value.replace(/\u00a0/g, " ").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+            const normalizeInline = (value) => value.replace(/\s+/g, " ").trim();
+            const parseJsonSafely = (value) => {
+                if (!value) {
+                    return {};
+                }
+                try {
+                    const parsed = JSON.parse(value);
+                    return typeof parsed === "object" && parsed !== null ? parsed : {};
+                }
+                catch {
+                    return {};
+                }
+            };
+            const toHttpsImage = (value) => typeof value === "string" && /^https?:\/\//.test(value) ? value : undefined;
+            const parseMediaImage = (value) => {
+                if (!value || typeof value !== "object" || Array.isArray(value)) {
+                    return [];
+                }
+                const record = value;
+                const url = toHttpsImage(record.original_img_url) ??
+                    toHttpsImage(record.media_url_https) ??
+                    toHttpsImage(record.media_url) ??
+                    toHttpsImage(record.image_info?.original_img_url);
+                if (!url) {
+                    return [];
+                }
+                const alt = typeof record.alt_text === "string" ? normalizeInline(record.alt_text) : "";
+                return [alt ? { url, alt } : { url }];
+            };
+            const parseBlocksText = (value) => {
+                if (!Array.isArray(value)) {
+                    return "";
+                }
+                const lines = [];
+                for (const rawBlock of value) {
+                    if (!rawBlock || typeof rawBlock !== "object" || Array.isArray(rawBlock)) {
+                        continue;
+                    }
+                    const block = rawBlock;
+                    const rawText = typeof block.text === "string" ? block.text : "";
+                    const text = normalizeText(rawText);
+                    if (!text) {
+                        lines.push("");
+                        continue;
+                    }
+                    const type = typeof block.type === "string" ? block.type : "";
+                    if (type === "unordered-list-item") {
+                        lines.push(`- ${text}`);
+                    }
+                    else if (type === "ordered-list-item") {
+                        lines.push(`1. ${text}`);
+                    }
+                    else {
+                        lines.push(text);
+                    }
+                }
+                return normalizeText(lines.join("\n"));
+            };
+            const extractNextCursor = (instructions) => {
+                for (const instruction of instructions) {
+                    if (!instruction || typeof instruction !== "object" || Array.isArray(instruction)) {
+                        continue;
+                    }
+                    const entries = Array.isArray(instruction.entries)
+                        ? instruction.entries
+                        : [];
+                    for (const rawEntry of entries) {
+                        if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
+                            continue;
+                        }
+                        const entry = rawEntry;
+                        const content = entry.content ?? {};
+                        const cursorType = typeof content.cursorType === "string" ? content.cursorType : "";
+                        const value = typeof content.value === "string" ? content.value : "";
+                        if (cursorType === "Bottom" && value) {
+                            return value;
+                        }
+                    }
+                }
+                return undefined;
+            };
+            const templateUrl = new URL(template.url, location.origin);
+            const templateVariables = parseJsonSafely(templateUrl.searchParams.get("variables"));
+            const templateFeatures = parseJsonSafely(templateUrl.searchParams.get("features"));
+            const templateFieldToggles = parseJsonSafely(templateUrl.searchParams.get("fieldToggles"));
+            const headers = sanitizeHeaders(template.headers);
+            templateFieldToggles.withArticlePlainText = true;
+            const fetchTimeline = async (cursor) => {
+                const vars = {
+                    ...templateVariables,
+                    count: 20,
+                };
+                if (cursor) {
+                    vars.cursor = cursor;
+                }
+                else {
+                    delete vars.cursor;
+                }
+                const requestUrl = new URL(template.url, location.origin);
+                requestUrl.searchParams.set("variables", JSON.stringify(vars));
+                if (Object.keys(templateFeatures).length > 0) {
+                    requestUrl.searchParams.set("features", JSON.stringify(templateFeatures));
+                }
+                if (Object.keys(templateFieldToggles).length > 0) {
+                    requestUrl.searchParams.set("fieldToggles", JSON.stringify(templateFieldToggles));
+                }
+                const response = await fetch(requestUrl.toString(), {
+                    method: template.method,
+                    headers,
+                    credentials: "include",
+                });
+                if (!response.ok) {
+                    throw new Error(`http_${response.status}`);
+                }
+                return await response.json();
+            };
+            let cursor;
+            for (let pageIndex = 0; pageIndex < 8; pageIndex += 1) {
+                let responseJson;
+                try {
+                    responseJson = await fetchTimeline(cursor);
+                }
+                catch (error) {
+                    return { error: String(error) };
+                }
+                const dataRecord = responseJson?.data;
+                const userRecord = dataRecord?.user;
+                const resultRecord = userRecord?.result;
+                const timelineRecord = resultRecord?.timeline;
+                const timelineInnerRecord = timelineRecord?.timeline;
+                const instructions = timelineInnerRecord?.instructions;
+                const entries = Array.isArray(instructions) ? instructions : [];
+                for (const instruction of entries) {
+                    if (!instruction || typeof instruction !== "object" || Array.isArray(instruction)) {
+                        continue;
+                    }
+                    const timelineEntries = Array.isArray(instruction.entries)
+                        ? instruction.entries
+                        : [];
+                    for (const rawEntry of timelineEntries) {
+                        if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
+                            continue;
+                        }
+                        const entry = rawEntry;
+                        const tweetResult = entry.content?.itemContent
+                            ?.tweet_results?.result;
+                        const articleResult = tweetResult?.article?.article_results
+                            ?.result ?? undefined;
+                        if (!articleResult) {
+                            continue;
+                        }
+                        const restId = typeof articleResult.rest_id === "string" ? articleResult.rest_id : "";
+                        if (restId !== targetArticleId) {
+                            continue;
+                        }
+                        const metadata = articleResult.metadata ?? {};
+                        const title = typeof articleResult.title === "string" ? normalizeInline(articleResult.title) : "";
+                        const previewText = typeof articleResult.preview_text === "string" ? normalizeText(articleResult.preview_text) : "";
+                        const plainText = typeof articleResult.plain_text === "string" ? normalizeText(articleResult.plain_text) : "";
+                        const text = plainText || parseBlocksText(articleResult.content_state?.blocks) || previewText;
+                        const coverImage = parseMediaImage(articleResult.cover_media)[0];
+                        const mediaEntities = Array.isArray(articleResult.media_entities) ? articleResult.media_entities : [];
+                        const inlineImages = mediaEntities.flatMap((entry) => parseMediaImage(entry));
+                        const dedupedImages = [];
+                        const seenImageUrls = new Set();
+                        for (const image of inlineImages) {
+                            if (!seenImageUrls.has(image.url) && image.url !== coverImage?.url) {
+                                seenImageUrls.add(image.url);
+                                dedupedImages.push(image);
+                            }
+                        }
+                        const output = {
+                            id: restId,
+                            title,
+                            text,
+                            url: `https://x.com/i/article/${restId}`,
+                            images: dedupedImages,
+                            source: "profile_articles",
+                            published: true,
+                        };
+                        if (coverImage?.url) {
+                            output.coverImageUrl = coverImage.url;
+                        }
+                        if (typeof metadata.first_published_at_secs === "number") {
+                            output.firstPublishedAtSecs = metadata.first_published_at_secs;
+                        }
+                        return output;
+                    }
+                }
+                cursor = extractNextCursor(entries);
+                if (!cursor) {
+                    break;
+                }
+            }
+            return { error: "not_found" };
+        }, { op: "article_collect_profile", articleId }).catch(() => undefined);
+        if (!article || typeof article !== "object") {
+            return errorResult("UPSTREAM_CHANGED", "article profile fallback failed");
+        }
+        if ("error" in article) {
+            return errorResult("UPSTREAM_CHANGED", "article profile fallback failed", article);
+        }
+        const outputArticle = {
+            id: articleId,
+            title: typeof article.title === "string" ? article.title : "",
+            text: sanitizeArticleText(typeof article.text === "string" ? article.text : ""),
+            url: typeof article.url === "string" ? article.url : `https://x.com/i/article/${articleId}`,
+            images: Array.isArray(article.images) ? article.images : [],
+            source: typeof article.source === "string" ? article.source : "profile_articles",
+            published: true,
+            authorHandle: `@${normalizedHandle}`,
+        };
+        if (typeof article.coverImageUrl === "string" && article.coverImageUrl) {
+            outputArticle.coverImageUrl = article.coverImageUrl;
+        }
+        return { article: outputArticle };
+    });
+}
+async function readArticleFromPublicPage(page, targetUrl) {
+    return await withEphemeralPage(page, targetUrl, async (readPage) => {
+        await waitForArticleReadSurface(readPage);
+        const article = await readPage.evaluate(({ op }) => {
+            if (op !== "article_collect_public") {
+                return undefined;
+            }
+            const normalizeInline = (value) => value.replace(/\s+/g, " ").trim();
+            const normalizeBlock = (value) => value.replace(/\u00a0/g, " ").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+            const asArray = (value) => (Array.isArray(value) ? value : [value]);
+            const readJsonLd = () => {
+                const scripts = Array.from(document.querySelectorAll("script[type='application/ld+json']"));
+                for (const script of scripts) {
+                    const raw = script.textContent?.trim();
+                    if (!raw) {
+                        continue;
+                    }
+                    try {
+                        const parsed = JSON.parse(raw);
+                        const queue = asArray(parsed);
+                        while (queue.length > 0) {
+                            const next = queue.shift();
+                            if (!next || typeof next !== "object") {
+                                continue;
+                            }
+                            const record = next;
+                            const typeValue = record["@type"];
+                            const types = asArray(typeValue).filter((item) => typeof item === "string");
+                            if (types.some((item) => item.toLowerCase().includes("article"))) {
+                                return record;
+                            }
+                            const graph = record["@graph"];
+                            if (graph) {
+                                queue.push(...asArray(graph));
+                            }
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                return undefined;
+            };
+            const ld = readJsonLd();
+            const ldHeadline = typeof ld?.headline === "string" ? normalizeInline(ld.headline) : "";
+            const ldBody = typeof ld?.articleBody === "string" ? normalizeBlock(ld.articleBody) : "";
+            const ldImage = typeof ld?.image === "string"
+                ? ld.image
+                : Array.isArray(ld?.image)
+                    ? ld.image.find((item) => typeof item === "string")
+                    : undefined;
+            const ldAuthor = (() => {
+                const author = ld?.author;
+                if (!author || typeof author !== "object" || Array.isArray(author)) {
+                    return undefined;
+                }
+                const authorRecord = author;
+                const name = typeof authorRecord.name === "string" ? normalizeInline(authorRecord.name) : "";
+                const url = typeof authorRecord.url === "string" ? authorRecord.url : "";
+                const handleMatch = url.match(/x\.com\/([^/?#]+)/i);
+                return {
+                    name,
+                    handle: handleMatch?.[1] ? `@${handleMatch[1].replace(/^@+/, "")}` : undefined,
+                };
+            })();
+            const title = ldHeadline ||
+                normalizeInline(document.querySelector("h1")?.innerText || "") ||
+                normalizeInline(document.querySelector("meta[property='og:title']")?.getAttribute("content") || "");
+            const articleTextCandidates = [
+                ...Array.from(document.querySelectorAll("main article [dir='auto'], main article div[lang], main article p")),
+                ...Array.from(document.querySelectorAll("article [dir='auto'], article div[lang], article p")),
+            ]
+                .map((node) => normalizeBlock(node.innerText || node.textContent || ""))
+                .filter((value) => value.length > 0);
+            const text = ldBody || articleTextCandidates.join("\n\n");
+            const canonicalUrl = document.querySelector("link[rel='canonical']")?.href ||
+                document.querySelector("meta[property='og:url']")?.getAttribute("content") ||
+                window.location.href;
+            const articleIdMatch = canonicalUrl.match(/\/articles\/(\d+)(?:[/?#]|$)/) || window.location.href.match(/\/articles\/(\d+)(?:[/?#]|$)/);
+            const allImages = Array.from(document.querySelectorAll("img[src]"))
+                .map((img) => ({
+                url: img.currentSrc || img.src,
+                alt: normalizeInline(img.alt || ""),
+                width: img.naturalWidth || 0,
+                height: img.naturalHeight || 0,
+            }))
+                .filter((item) => /^https?:\/\//.test(item.url))
+                .filter((item) => item.width > 100 || item.height > 100);
+            const imageByUrl = new Map();
+            for (const image of allImages) {
+                if (!imageByUrl.has(image.url)) {
+                    imageByUrl.set(image.url, image.alt ? { url: image.url, alt: image.alt } : { url: image.url });
+                }
+            }
+            const coverImageUrl = (typeof ldImage === "string" && /^https?:\/\//.test(ldImage) ? ldImage : undefined) ||
+                Array.from(imageByUrl.keys())[0];
+            const images = Array.from(imageByUrl.values()).filter((item) => item.url !== coverImageUrl);
+            const bodyText = normalizeBlock(document.body?.innerText || "");
+            return {
+                id: articleIdMatch?.[1],
+                url: canonicalUrl,
+                title,
+                text,
+                coverImageUrl,
+                images,
+                authorName: ldAuthor?.name,
+                authorHandle: ldAuthor?.handle,
+                unsupported: bodyText.includes("This page is not supported."),
+            };
+        }, { op: "article_collect_public" }).catch(() => undefined);
+        if (!article || typeof article !== "object") {
+            return errorResult("UPSTREAM_CHANGED", "article content not found");
+        }
+        if (article.unsupported === true) {
+            return errorResult("UPSTREAM_CHANGED", "article unavailable on public article route", {
+                reason: "public_article_unsupported",
+            });
+        }
+        const title = typeof article.title === "string" ? article.title : "";
+        const text = sanitizeArticleText(typeof article.text === "string" ? article.text : "");
+        const images = Array.isArray(article.images) ? article.images : [];
+        const coverImageUrl = typeof article.coverImageUrl === "string" ? article.coverImageUrl : "";
+        if ((!title || title === "X") && !text && images.length === 0 && !coverImageUrl) {
+            return errorResult("UPSTREAM_CHANGED", "article content not found on public article route", {
+                reason: "public_article_empty",
+            });
+        }
+        const outputArticle = {
+            source: "public",
+            published: true,
+            title,
+            text,
+            url: typeof article.url === "string" ? article.url : targetUrl,
+            images,
+        };
+        if (typeof article.id === "string" && article.id) {
+            outputArticle.id = article.id;
+        }
+        if (typeof article.coverImageUrl === "string" && article.coverImageUrl) {
+            outputArticle.coverImageUrl = article.coverImageUrl;
+        }
+        if (typeof article.authorName === "string" && article.authorName) {
+            outputArticle.authorName = article.authorName;
+        }
+        if (typeof article.authorHandle === "string" && article.authorHandle) {
+            outputArticle.authorHandle = article.authorHandle;
+        }
+        return { article: outputArticle };
+    });
+}
+async function readArticleByUrl(page, targetUrl, authorHandle) {
+    let articleId = parseArticleIdFromUrl(targetUrl);
+    if (!articleId && /\/status\/\d+(?:[/?#]|$)/.test(targetUrl)) {
+        const tweetResult = await readTweetByUrl(page, targetUrl);
+        if (tweetResult &&
+            typeof tweetResult === "object" &&
+            "tweet" in tweetResult &&
+            tweetResult.tweet &&
+            typeof tweetResult.tweet === "object" &&
+            !Array.isArray(tweetResult.tweet)) {
+            const tweetRecord = tweetResult.tweet;
+            const article = tweetRecord.article;
+            if (article && typeof article === "object" && !Array.isArray(article)) {
+                const articleRecord = article;
+                const nestedUrl = typeof articleRecord.url === "string" ? articleRecord.url : "";
+                const nestedId = typeof articleRecord.id === "string" ? articleRecord.id : "";
+                if (nestedUrl) {
+                    targetUrl = nestedUrl;
+                }
+                articleId = nestedId || parseArticleIdFromUrl(nestedUrl);
+            }
+        }
+    }
+    const useEditor = targetUrl.includes("/compose/articles/edit/") || isArticlePreviewUrl(targetUrl);
+    if (articleId) {
+        const cachedPage = getCachedArticleDraftPage(page, articleId);
+        if (cachedPage) {
+            await waitForArticleEditorSurface(cachedPage);
+            await ensureArticleDraftLoaded(cachedPage, articleId);
+            return await readArticleFromEditorPage(cachedPage, articleId, true);
+        }
+    }
+    if (useEditor) {
+        return await withEphemeralPage(page, articleId ? buildArticleEditUrl(articleId) : targetUrl, async (articlePage) => {
+            await waitForArticleEditorSurface(articlePage);
+            await ensureArticleDraftLoaded(articlePage, articleId);
+            return await readArticleFromEditorPage(articlePage, articleId, false);
+        });
+    }
+    const publicResult = await readArticleFromPublicPage(page, targetUrl);
+    if (!articleId) {
+        return publicResult;
+    }
+    if (!parseArticleReadErrorCode(publicResult)) {
+        return publicResult;
+    }
+    if (typeof authorHandle === "string" && authorHandle.trim()) {
+        const profileResult = await readArticleFromProfileArticles(page, articleId, authorHandle);
+        if (!parseArticleReadErrorCode(profileResult)) {
+            return profileResult;
+        }
+    }
+    const ownerResult = await readArticleFromOwnedSlices(page, articleId);
+    return parseArticleReadErrorCode(ownerResult) ? publicResult : ownerResult;
+}
+async function publishArticleEditor(page, timeoutMs) {
+    const editUrl = page.url();
+    await page
+        .evaluate(() => {
+        const active = document.activeElement;
+        if (active instanceof HTMLElement) {
+            active.blur();
+        }
+    })
+        .catch(() => { });
+    await page.keyboard.press("Escape").catch(() => { });
+    await page
+        .waitForFunction(() => {
+        const buttons = Array.from(document.querySelectorAll("button"));
+        return buttons.some((button) => {
+            const label = (button.textContent || "").replace(/\s+/g, " ").trim();
+            const ariaDisabled = (button.getAttribute("aria-disabled") || "").toLowerCase();
+            return label === "Publish" && !button.disabled && ariaDisabled !== "true";
+        });
+    }, undefined, { timeout: Math.min(timeoutMs, 15_000) })
+        .catch(() => { });
+    const clickPrimaryPublish = async () => {
+        return ((await page.evaluate(({ op }) => {
+            if (op !== "article_click_publish") {
+                return false;
+            }
+            const buttons = Array.from(document.querySelectorAll("button")).filter((button) => {
+                const label = (button.textContent || "").replace(/\s+/g, " ").trim();
+                const ariaDisabled = (button.getAttribute("aria-disabled") || "").toLowerCase();
+                return label === "Publish" && !button.disabled && ariaDisabled !== "true";
+            });
+            const button = buttons[buttons.length - 1];
+            if (!button) {
+                return false;
+            }
+            button.click();
+            return true;
+        }, { op: "article_click_publish" }).catch(() => false)) === true);
+    };
+    if (!(await clickPrimaryPublish())) {
+        const details = await page
+            .evaluate(() => {
+            const titleAreas = Array.from(document.querySelectorAll("textarea")).map((input) => ({
+                placeholder: input.getAttribute("placeholder") || "",
+                value: input instanceof HTMLTextAreaElement ? input.value : "",
+            }));
+            const composers = Array.from(document.querySelectorAll("[data-testid='composer'][role='textbox']")).map((node) => ({
+                text: (node.textContent || "").slice(0, 500),
+            }));
+            const buttonLabels = Array.from(document.querySelectorAll("button"))
+                .map((button) => ({
+                text: (button.textContent || "").replace(/\s+/g, " ").trim(),
+                aria: button.getAttribute("aria-label") || "",
+                disabled: button.disabled || (button.getAttribute("aria-disabled") || "").toLowerCase() === "true",
+            }))
+                .filter((item) => item.text || item.aria)
+                .slice(0, 30);
+            const bodyLines = (document.body?.innerText || "")
+                .split(/\n+/)
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0)
+                .slice(0, 40);
+            return {
+                currentUrl: window.location.href,
+                titleAreas,
+                composers,
+                buttonLabels,
+                bodyLines,
+            };
+        })
+            .catch(() => undefined);
+        return details
+            ? { ok: false, reason: "publish_button_not_found", details }
+            : { ok: false, reason: "publish_button_not_found" };
+    }
+    await page.waitForTimeout(1_000);
+    await clickPrimaryPublish().catch(() => false);
+    try {
+        await page.waitForFunction(({ previousUrl }) => {
+            const currentUrl = window.location.href;
+            if (!currentUrl.includes("/compose/articles/edit/")) {
+                return true;
+            }
+            if (currentUrl !== previousUrl && !currentUrl.includes("/preview")) {
+                return true;
+            }
+            return (document.body?.innerText || "").includes("Published");
+        }, { previousUrl: editUrl }, { timeout: timeoutMs });
+    }
+    catch {
+        return { ok: false, reason: "publish_not_confirmed" };
+    }
+    const details = await page.evaluate(({ op }) => {
+        if (op !== "article_collect_publish_details") {
+            return {
+                currentUrl: window.location.href,
+                editUrl: undefined,
+                publicUrl: undefined,
+            };
+        }
+        const editAnchor = Array.from(document.querySelectorAll("a[href]")).find((anchor) => anchor.href.includes("/compose/articles/edit/"));
+        const publicAnchor = Array.from(document.querySelectorAll("a[href]")).find((anchor) => {
+            return anchor.href.includes("/articles/") && !anchor.href.includes("/compose/articles/edit/");
+        });
+        return {
+            currentUrl: window.location.href,
+            editUrl: editAnchor?.href,
+            publicUrl: publicAnchor?.href,
+        };
+    }, { op: "article_collect_publish_details" }).catch(() => ({ currentUrl: page.url(), editUrl: undefined, publicUrl: undefined }));
+    const articleId = parseArticleIdFromUrl(details.currentUrl) ??
+        (typeof details.editUrl === "string" ? parseArticleIdFromUrl(details.editUrl) : undefined) ??
+        undefined;
+    const articleUrl = typeof details.publicUrl === "string" && details.publicUrl.length > 0
+        ? details.publicUrl
+        : !details.currentUrl.includes("/compose/articles/edit/")
+            ? details.currentUrl
+            : undefined;
+    const output = {
+        ok: true,
+        editUrl: typeof details.editUrl === "string" && details.editUrl.length > 0 ? details.editUrl : editUrl,
+    };
+    if (articleId) {
+        output.articleId = articleId;
+    }
+    if (articleUrl) {
+        output.articleUrl = articleUrl;
+    }
+    return output;
+}
+async function deleteArticleEditor(page, dryRun) {
+    const menuOpened = await page.evaluate(({ op }) => {
+        if (op !== "article_open_delete_menu") {
+            return false;
+        }
+        const buttons = Array.from(document.querySelectorAll("button[aria-label='More']"));
+        const button = buttons[buttons.length - 1];
+        if (!button) {
+            return false;
+        }
+        button.click();
+        return true;
+    }, { op: "article_open_delete_menu" }).catch(() => false);
+    if (!menuOpened) {
+        return errorResult("UPSTREAM_CHANGED", "article delete controls not found", {
+            reason: "more_button_not_found",
+        });
+    }
+    const deleteReady = await page.waitForFunction(() => {
+        return Array.from(document.querySelectorAll("[role='menuitem'], button, div[role='button']")).some((element) => {
+            const text = (element.textContent || "").replace(/\s+/g, " ").trim();
+            return text === "Delete Article";
+        });
+    }, undefined, { timeout: 5_000 }).then(() => true).catch(() => false);
+    if (!deleteReady) {
+        return errorResult("UPSTREAM_CHANGED", "article delete controls not found", {
+            reason: "delete_menu_item_not_found",
+        });
+    }
+    if (dryRun) {
+        return {
+            ok: true,
+            dryRun: true,
+            deleteVisible: true,
+        };
+    }
+    const firstDelete = await page.evaluate(({ op }) => {
+        if (op !== "article_click_delete_menu_item") {
+            return false;
+        }
+        const item = Array.from(document.querySelectorAll("[role='menuitem'], button, div[role='button']")).find((element) => {
+            const text = (element.textContent || "").replace(/\s+/g, " ").trim();
+            return text === "Delete Article";
+        });
+        if (!item) {
+            return false;
+        }
+        item.click();
+        return true;
+    }, { op: "article_click_delete_menu_item" }).catch(() => false);
+    if (!firstDelete) {
+        return errorResult("UPSTREAM_CHANGED", "article delete controls not found", {
+            reason: "delete_menu_click_failed",
+        });
+    }
+    await page.waitForTimeout(700);
+    await page.evaluate(({ op }) => {
+        if (op !== "article_confirm_delete") {
+            return;
+        }
+        const dialog = document.querySelector("[role='dialog'], [data-testid='confirmationSheetDialog']");
+        const dialogButtons = dialog
+            ? Array.from(dialog.querySelectorAll("button, div[role='button']"))
+            : [];
+        const dialogConfirm = dialogButtons.find((element) => {
+            const testId = element.getAttribute("data-testid") || "";
+            const text = (element.textContent || "").replace(/\s+/g, " ").trim();
+            return testId === "confirmationSheetConfirm" || text === "Delete Article";
+        });
+        if (dialogConfirm) {
+            dialogConfirm.click();
+            return;
+        }
+        const buttons = Array.from(document.querySelectorAll("button, div[role='button']")).filter((element) => {
+            const text = (element.textContent || "").replace(/\s+/g, " ").trim();
+            return text === "Delete Article";
+        });
+        const button = buttons[buttons.length - 1];
+        button?.click();
+    }, { op: "article_confirm_delete" }).catch(() => { });
+    const deleted = await page
+        .waitForFunction(() => {
+        const bodyText = document.body?.innerText || "";
+        return window.location.pathname === "/compose/articles" || bodyText.includes("Continue a draft or create a new Article");
+    }, undefined, { timeout: 15_000 })
+        .then(() => true)
+        .catch(() => false);
+    if (!deleted) {
+        const details = await page.evaluate(() => {
+            const buttonLabels = Array.from(document.querySelectorAll("button, div[role='button']"))
+                .map((element) => ({
+                text: (element.textContent || "").replace(/\s+/g, " ").trim(),
+                aria: element.getAttribute("aria-label") || "",
+                testId: element.getAttribute("data-testid") || "",
+            }))
+                .filter((item) => item.text || item.aria || item.testId)
+                .slice(0, 40);
+            const bodyLines = (document.body?.innerText || "")
+                .split(/\n+/)
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0)
+                .slice(0, 40);
+            return {
+                currentUrl: window.location.href,
+                dialogOpen: document.querySelector("[role='dialog'], [data-testid='confirmationSheetDialog']") !== null,
+                buttonLabels,
+                bodyLines,
+            };
+        }).catch(() => undefined);
+        return errorResult("ACTION_UNCONFIRMED", "article delete was not confirmed", details);
+    }
+    return {
+        ok: true,
+        confirmed: true,
+    };
+}
+async function draftArticleMarkdown(page, markdownPath, explicitTitle, coverImagePath) {
+    const resolvedMarkdown = await resolveArticleAttachment(markdownPath, "markdownPath");
+    if (!resolvedMarkdown.ok || !resolvedMarkdown.attachment) {
+        return resolvedMarkdown.ok ? errorResult("VALIDATION_ERROR", "markdownPath was not found") : resolvedMarkdown.result;
+    }
+    const markdown = await readFile(resolvedMarkdown.attachment.path, "utf8").catch(() => undefined);
+    if (markdown === undefined) {
+        return errorResult("VALIDATION_ERROR", `markdownPath was not found: ${markdownPath}`);
+    }
+    const normalized = normalizeArticleMarkdown(markdown, resolvedMarkdown.attachment.path, explicitTitle);
+    const title = normalized.title;
+    const draftAssets = prepareArticleMarkdown(normalized.bodyMarkdown, resolvedMarkdown.attachment.path);
+    const resolvedInlineImages = [];
+    for (const image of draftAssets.inlineImages) {
+        const resolved = await resolveArticleAttachment(image.path, image.marker);
+        if (!resolved.ok || !resolved.attachment) {
+            return resolved.ok
+                ? errorResult("VALIDATION_ERROR", `${image.marker} was not found`)
+                : resolved.result;
+        }
+        resolvedInlineImages.push({
+            ...image,
+            path: resolved.attachment.path,
+            name: resolved.attachment.name,
+        });
+    }
+    const articlePage = await page.context().newPage();
+    let shouldClose = true;
+    try {
+        await ensureNetworkCaptureInstalled(articlePage);
+        await articlePage.goto("https://x.com/compose/articles", { waitUntil: "domcontentloaded", timeout: 60_000 });
+        const started = await openNewArticleEditor(articlePage);
+        if (!started.ok) {
+            return errorResult("UPSTREAM_CHANGED", "article editor could not be opened", {
+                reason: started.reason,
+            });
+        }
+        const titleSet = await setArticleTitle(articlePage, title);
+        if (!titleSet) {
+            return errorResult("UPSTREAM_CHANGED", "article title controls not found");
+        }
+        if (coverImagePath) {
+            const resolvedCover = await resolveArticleAttachment(coverImagePath, "coverImagePath");
+            if (!resolvedCover.ok || !resolvedCover.attachment) {
+                return resolvedCover.ok ? errorResult("VALIDATION_ERROR", "coverImagePath was not found") : resolvedCover.result;
+            }
+            const coverTriggered = await triggerArticleCoverUpload(articlePage);
+            if (!coverTriggered) {
+                return errorResult("UPSTREAM_CHANGED", "article cover upload controls not found");
+            }
+            const coverUploaded = await uploadArticleFile(articlePage, resolvedCover.attachment.path);
+            if (!coverUploaded) {
+                return errorResult("UPSTREAM_CHANGED", "article cover upload failed");
+            }
+            const coverApplied = await waitForArticleCoverApplied(articlePage);
+            if (!coverApplied) {
+                return errorResult("ACTION_UNCONFIRMED", "article cover upload was not confirmed");
+            }
+        }
+        const pasted = await pasteArticleMarkdown(articlePage, draftAssets.markdown, draftAssets.html);
+        if (!pasted) {
+            return errorResult("UPSTREAM_CHANGED", "article markdown paste failed");
+        }
+        const inlineUploadResult = await uploadArticleInlineImages(articlePage, resolvedInlineImages);
+        if (!inlineUploadResult.ok) {
+            return errorResult("UPSTREAM_CHANGED", "article inline image upload failed", {
+                reason: inlineUploadResult.reason,
+            });
+        }
+        const editUrl = started.editUrl;
+        const articleId = parseArticleIdFromUrl(editUrl);
+        const output = {
+            ok: true,
+            editUrl,
+            title,
+            inlineImageCount: resolvedInlineImages.length,
+            hasCoverImage: typeof coverImagePath === "string" && coverImagePath.trim().length > 0,
+        };
+        if (articleId) {
+            output.articleId = articleId;
+            output.draftId = articleId;
+            output.previewUrl = buildArticlePreviewUrl(articleId);
+            const persisted = await waitForArticleDraftPersisted(articlePage, articleId, title);
+            output.persisted = persisted;
+            output.sessionScoped = !persisted;
+            await cacheArticleDraftPage(page, articleId, articlePage);
+            shouldClose = false;
+        }
+        return output;
+    }
+    finally {
+        if (shouldClose) {
+            await articlePage.close().catch(() => { });
+        }
+    }
+}
+async function publishArticleMarkdown(page, markdownPath, explicitTitle, coverImagePath, dryRun, timeoutMs) {
+    const drafted = await draftArticleMarkdown(page, markdownPath, explicitTitle, coverImagePath);
+    if (dryRun) {
+        if (drafted && typeof drafted === "object" && !Array.isArray(drafted) && !("error" in drafted)) {
+            return { ...drafted, dryRun: true };
+        }
+        return drafted;
+    }
+    if (!drafted || typeof drafted !== "object" || Array.isArray(drafted) || ("error" in drafted)) {
+        return drafted;
+    }
+    const editUrl = typeof drafted.editUrl === "string" ? drafted.editUrl : "";
+    if (!editUrl) {
+        return errorResult("UPSTREAM_CHANGED", "article draft edit url not found");
+    }
+    return await withEphemeralPage(page, editUrl, async (articlePage) => {
+        await waitForArticleEditorSurface(articlePage);
+        const published = await publishArticleEditor(articlePage, timeoutMs);
+        if (!published.ok) {
+            const details = {
+                reason: published.reason,
+            };
+            if (published.details) {
+                details.debug = published.details;
+            }
+            return errorResult("ACTION_UNCONFIRMED", "article publish was not confirmed", {
+                ...details,
+            });
+        }
+        const output = {
+            ...drafted,
+            confirmed: true,
+            editUrl: published.editUrl,
+        };
+        if (published.articleId) {
+            output.articleId = published.articleId;
+        }
+        if (published.articleUrl) {
+            output.articleUrl = published.articleUrl;
+        }
+        return output;
+    });
+}
+async function publishExistingArticle(page, targetUrl, timeoutMs) {
+    const articleId = parseArticleIdFromUrl(targetUrl);
+    const cachedPage = articleId ? getCachedArticleDraftPage(page, articleId) : undefined;
+    const runPublish = async (articlePage) => {
+        await waitForArticleEditorSurface(articlePage);
+        await ensureArticleDraftLoaded(articlePage, articleId);
+        const published = await publishArticleEditor(articlePage, timeoutMs);
+        if (!published.ok) {
+            const details = {
+                reason: published.reason,
+            };
+            if (published.details) {
+                details.debug = published.details;
+            }
+            return errorResult("ACTION_UNCONFIRMED", "article publish was not confirmed", details);
+        }
+        const output = {
+            ok: true,
+            confirmed: true,
+            editUrl: published.editUrl,
+        };
+        if (published.articleId) {
+            output.articleId = published.articleId;
+        }
+        if (published.articleUrl) {
+            output.articleUrl = published.articleUrl;
+        }
+        return output;
+    };
+    if (cachedPage) {
+        const result = await runPublish(cachedPage);
+        if (articleId && (!result || typeof result !== "object" || Array.isArray(result) || !("error" in result))) {
+            await removeCachedArticleDraftPage(page, articleId);
+        }
+        return result;
+    }
+    return await withEphemeralPage(page, targetUrl, runPublish);
+}
+async function withArticleDraftPage(ownerPage, targetUrl, run) {
+    const articleId = parseArticleIdFromUrl(targetUrl);
+    const cachedPage = articleId ? getCachedArticleDraftPage(ownerPage, articleId) : undefined;
+    if (cachedPage) {
+        const cachedUrl = cachedPage.url();
+        const cachedArticleId = parseArticleIdFromUrl(cachedUrl);
+        if (!articleId || cachedArticleId === articleId) {
+            await waitForArticleEditorSurface(cachedPage);
+            await ensureArticleDraftLoaded(cachedPage, articleId);
+            return await run(cachedPage, articleId, true);
+        }
+    }
+    return await withEphemeralPage(ownerPage, targetUrl, async (articlePage) => {
+        await waitForArticleEditorSurface(articlePage);
+        await ensureArticleDraftLoaded(articlePage, articleId);
+        return await run(articlePage, articleId, false);
+    });
+}
+async function setArticleCoverImage(page, targetUrl, coverImagePath) {
+    const resolvedCover = await resolveArticleAttachment(coverImagePath, "coverImagePath");
+    if (!resolvedCover.ok || !resolvedCover.attachment) {
+        return resolvedCover.ok ? errorResult("VALIDATION_ERROR", "coverImagePath was not found") : resolvedCover.result;
+    }
+    const coverAttachment = resolvedCover.attachment;
+    return await withArticleDraftPage(page, targetUrl, async (articlePage, articleId, sessionScoped) => {
+        const coverTriggered = await triggerArticleCoverUpload(articlePage);
+        if (!coverTriggered) {
+            return errorResult("UPSTREAM_CHANGED", "article cover upload controls not found");
+        }
+        const coverUploaded = await uploadArticleFile(articlePage, coverAttachment.path);
+        if (!coverUploaded) {
+            return errorResult("UPSTREAM_CHANGED", "article cover upload failed");
+        }
+        const coverApplied = await waitForArticleCoverApplied(articlePage);
+        if (!coverApplied) {
+            return errorResult("ACTION_UNCONFIRMED", "article cover upload was not confirmed");
+        }
+        const output = {
+            ok: true,
+            editUrl: articlePage.url(),
+            hasCoverImage: true,
+        };
+        if (articleId) {
+            output.articleId = articleId;
+            output.sessionScoped = sessionScoped === true;
+        }
+        return output;
+    });
+}
+async function updateArticleMarkdown(page, targetUrl, markdownPath, explicitTitle) {
+    const resolvedMarkdown = await resolveArticleAttachment(markdownPath, "markdownPath");
+    if (!resolvedMarkdown.ok || !resolvedMarkdown.attachment) {
+        return resolvedMarkdown.ok ? errorResult("VALIDATION_ERROR", "markdownPath was not found") : resolvedMarkdown.result;
+    }
+    const markdown = await readFile(resolvedMarkdown.attachment.path, "utf8").catch(() => undefined);
+    if (markdown === undefined) {
+        return errorResult("VALIDATION_ERROR", `markdownPath was not found: ${markdownPath}`);
+    }
+    const normalized = normalizeArticleMarkdown(markdown, resolvedMarkdown.attachment.path, explicitTitle);
+    const title = normalized.title;
+    const draftAssets = prepareArticleMarkdown(normalized.bodyMarkdown, resolvedMarkdown.attachment.path);
+    const resolvedInlineImages = [];
+    for (const image of draftAssets.inlineImages) {
+        const resolved = await resolveArticleAttachment(image.path, image.marker);
+        if (!resolved.ok || !resolved.attachment) {
+            return resolved.ok
+                ? errorResult("VALIDATION_ERROR", `${image.marker} was not found`)
+                : resolved.result;
+        }
+        resolvedInlineImages.push({
+            ...image,
+            path: resolved.attachment.path,
+            name: resolved.attachment.name,
+        });
+    }
+    return await withArticleDraftPage(page, targetUrl, async (articlePage, articleId, sessionScoped) => {
+        const titleSet = await setArticleTitle(articlePage, title);
+        if (!titleSet) {
+            return errorResult("UPSTREAM_CHANGED", "article title controls not found");
+        }
+        const cleared = await clearArticleBody(articlePage);
+        if (!cleared) {
+            return errorResult("UPSTREAM_CHANGED", "article body controls not found");
+        }
+        const pasted = await pasteArticleMarkdown(articlePage, draftAssets.markdown, draftAssets.html);
+        if (!pasted) {
+            return errorResult("UPSTREAM_CHANGED", "article markdown paste failed");
+        }
+        const inlineUploadResult = await uploadArticleInlineImages(articlePage, resolvedInlineImages);
+        if (!inlineUploadResult.ok) {
+            return errorResult("UPSTREAM_CHANGED", "article inline image upload failed", {
+                reason: inlineUploadResult.reason,
+            });
+        }
+        const output = {
+            ok: true,
+            title,
+            editUrl: articlePage.url(),
+            inlineImageCount: resolvedInlineImages.length,
+        };
+        if (articleId) {
+            output.articleId = articleId;
+            output.draftId = articleId;
+            output.previewUrl = buildArticlePreviewUrl(articleId);
+            const persisted = await waitForArticleDraftPersisted(articlePage, articleId, title);
+            output.persisted = persisted;
+            output.sessionScoped = sessionScoped === true || !persisted;
+        }
+        return output;
+    });
+}
+async function upsertArticleDraftMarkdown(page, targetUrl, markdownPath, explicitTitle, coverImagePath) {
+    if (targetUrl) {
+        return await updateArticleMarkdown(page, targetUrl, markdownPath, explicitTitle);
+    }
+    return await draftArticleMarkdown(page, markdownPath, explicitTitle, coverImagePath);
+}
+async function waitForGrokSurface(page) {
+    await page
+        .waitForFunction(() => {
+        const composer = document.querySelector("textarea") ||
+            document.querySelector("[contenteditable='true'][role='textbox']") ||
+            document.querySelector("[role='textbox'][contenteditable='true']");
+        const messages = document.querySelector("[data-message-author-role='assistant']") ||
+            document.querySelector("[data-testid*='assistant']") ||
+            document.querySelector("article");
+        return composer !== null || messages !== null;
+    }, undefined, { timeout: 12_000 })
+        .catch(() => { });
+    await page.waitForTimeout(800);
+}
+async function submitGrokPrompt(page, prompt) {
+    const composerSelectors = [
+        "textarea",
+        "[contenteditable='true'][role='textbox']",
+        "[role='textbox'][contenteditable='true']",
+    ];
+    const submitSelectors = [
+        "button[aria-label*='Grok something']",
+        "button[aria-label*='Send']",
+        "button[aria-label*='send']",
+        "button[data-testid*='send']",
+        "button[type='submit']",
+    ];
+    const selectAllShortcut = process.platform === "darwin" ? "Meta+A" : "Control+A";
+    let composerSelector;
+    for (const selector of composerSelectors) {
+        const handle = await page.waitForSelector(selector, { timeout: 1_200 }).catch(() => null);
+        if (!handle) {
+            continue;
+        }
+        await handle.dispose().catch(() => { });
+        composerSelector = selector;
+        break;
+    }
+    if (!composerSelector) {
+        return { ok: false, reason: "composer_not_found" };
+    }
+    try {
+        await page.click(composerSelector);
+        await page.keyboard.press(selectAllShortcut).catch(() => { });
+        await page.keyboard.press("Backspace").catch(() => { });
+        const setPromptInOneShot = await page.evaluate(({ selector, value }) => {
+            const element = document.querySelector(selector);
+            if (!element) {
+                return false;
+            }
+            if (element instanceof HTMLTextAreaElement || element instanceof HTMLInputElement) {
+                element.focus();
+                element.value = value;
+                element.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "insertText", data: value }));
+                element.dispatchEvent(new Event("change", { bubbles: true }));
+                return true;
+            }
+            if (element instanceof HTMLElement && element.isContentEditable) {
+                element.focus();
+                try {
+                    const selection = window.getSelection();
+                    const range = document.createRange();
+                    range.selectNodeContents(element);
+                    selection?.removeAllRanges();
+                    selection?.addRange(range);
+                    document.execCommand("insertText", false, value);
+                }
+                catch {
+                    // Ignore and fallback to direct assignment below.
+                }
+                if ((element.textContent ?? "").trim() !== value) {
+                    element.textContent = value;
+                }
+                element.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "insertText", data: value }));
+                element.dispatchEvent(new Event("change", { bubbles: true }));
+                return true;
+            }
+            return false;
+        }, { selector: composerSelector, value: prompt }).catch(() => false);
+        if (!setPromptInOneShot) {
+            await page.type(composerSelector, prompt, { delay: 12 });
+        }
+    }
+    catch {
+        return { ok: false, reason: "compose_input_failed" };
+    }
+    const submitSelector = await page.evaluate((selectors) => {
+        const normalize = (value) => value.replace(/\s+/g, " ").trim().toLowerCase();
+        for (const selector of selectors) {
+            const element = document.querySelector(selector);
+            if (!element) {
+                continue;
             }
             if (element instanceof HTMLButtonElement && element.disabled) {
                 continue;
@@ -2709,314 +5661,95 @@ async function prepareGrokSession(page, conversationId) {
 async function uploadGrokAttachments(page, attachments) {
     if (attachments.length === 0) {
         return { ok: true };
-    }
-    const uploadSelectors = [
-        "input[type='file'][accept*='application/pdf']",
-        "input[type='file'][accept*='text/csv']",
-        "input[type='file'][accept*='text/plain']",
-        "input[type='file']",
-    ];
-    let uploadSelector;
-    for (const selector of uploadSelectors) {
-        const handle = await page.waitForSelector(selector, { timeout: 1_200 }).catch(() => null);
-        if (!handle) {
-            continue;
-        }
-        await handle.dispose().catch(() => { });
-        uploadSelector = selector;
-        break;
-    }
-    if (!uploadSelector) {
-        return { ok: false, reason: "attachment_input_not_found" };
-    }
-    try {
-        await page.setInputFiles(uploadSelector, attachments.map((attachment) => attachment.path));
-    }
-    catch {
-        return { ok: false, reason: "attachment_upload_failed" };
-    }
-    const attachmentNames = attachments.map((attachment) => attachment.name);
-    await page
-        .waitForFunction(({ names }) => {
-        const bodyText = document.body?.innerText ?? "";
-        return names.every((name) => bodyText.includes(name));
-    }, { names: attachmentNames }, { timeout: 10_000 })
-        .catch(() => { });
-    await page.waitForTimeout(600);
-    return { ok: true };
-}
-async function askGrokViaNetwork(page, prompt, timeoutMs) {
-    const captured = await captureRoutedResponseText(page, "https://grok.x.com/2/grok/add_response.json*", async () => {
-        const submitResult = await submitGrokPrompt(page, prompt);
-        return submitResult.ok;
-    }, {
-        timeoutMs,
-    });
-    if (!captured || captured.status < 200 || captured.status >= 300) {
-        return undefined;
-    }
-    const responseText = captured.text;
-    const entries = parseNdjsonLines(responseText);
-    const finalParts = collectTextByTag(entries.map((entry) => {
-        const output = {};
-        if (typeof entry.result?.message === "string") {
-            output.message = entry.result.message;
-        }
-        if (typeof entry.result?.messageTag === "string") {
-            output.messageTag = entry.result.messageTag;
-        }
-        return output;
-    }), "final");
-    let conversationId;
-    for (const entry of entries) {
-        if (!conversationId && typeof entry.conversationId === "string") {
-            conversationId = entry.conversationId;
-        }
-    }
-    const finalResponse = joinTextParts(finalParts).trim();
-    if (!finalResponse) {
-        return undefined;
-    }
-    const artifactResult = await materializeGrokArtifacts(finalResponse);
-    const output = {
-        ok: true,
-        response: artifactResult.response,
-        url: typeof conversationId === "string" ? `https://x.com/i/grok?conversation=${conversationId}` : page.url(),
-    };
-    if (typeof conversationId === "string") {
-        output.conversationId = conversationId;
-    }
-    if (artifactResult.artifacts) {
-        output.artifacts = artifactResult.artifacts;
-    }
-    return output;
-}
-async function waitForGrokResponse(page, previousResponse, prompt, timeoutMs) {
-    try {
-        await page.waitForFunction(({ op, previous, promptText }) => {
-            if (op !== "grok_wait") {
-                return false;
-            }
-            const normalize = (value) => value.replace(/\s+/g, " ").trim();
-            const previousText = normalize(previous);
-            const normalizedPrompt = normalize(promptText);
-            const isIgnoredResponse = (value) => {
-                const lower = value.toLowerCase();
-                return (lower.length < 3 ||
-                    lower.startsWith("see new posts") ||
-                    lower.startsWith("thought for ") ||
-                    lower.startsWith("agents thinking") ||
-                    lower.startsWith("ask anything") ||
-                    lower === "agents" ||
-                    lower === "thinking" ||
-                    lower === "expert" ||
-                    lower.startsWith("grok") ||
-                    lower.includes("explore ") ||
-                    lower.includes("discuss ") ||
-                    lower.includes("create images") ||
-                    lower.includes("edit image") ||
-                    lower.includes("latest news") ||
-                    lower === normalizedPrompt.toLowerCase() ||
-                    lower === previousText.toLowerCase());
-            };
-            const scope = document.querySelector("div[aria-label='Grok']") ??
-                document.querySelector("main");
-            if (!scope) {
-                return false;
-            }
-            const lines = (scope.innerText || scope.textContent || "")
-                .split(/\n+/)
-                .map((line) => normalize(line))
-                .filter((line) => line.length > 0);
-            const linePromptIndex = lines.lastIndexOf(normalizedPrompt);
-            if (linePromptIndex >= 0) {
-                const hasStopControl = Array.from(document.querySelectorAll("button")).some((button) => {
-                    const label = normalize(button.getAttribute("aria-label") ?? button.textContent ?? "").toLowerCase();
-                    return label.includes("stop");
-                });
-                let hasLineCandidate = false;
-                for (let index = linePromptIndex + 1; index < lines.length; index += 1) {
-                    const candidate = lines[index];
-                    if (!candidate || isIgnoredResponse(candidate)) {
-                        continue;
-                    }
-                    hasLineCandidate = true;
-                }
-                if (!hasStopControl && hasLineCandidate) {
-                    return true;
-                }
-            }
-            const entries = [];
-            for (const node of Array.from(scope.querySelectorAll("div, span, p"))) {
-                if (node.closest("button, a, textarea, nav")) {
-                    continue;
-                }
-                const text = normalize(node.innerText || node.textContent || "");
-                if (!text) {
-                    continue;
-                }
-                const childWithSameText = Array.from(node.children).some((child) => {
-                    if (!(child instanceof HTMLElement)) {
-                        return false;
-                    }
-                    return normalize(child.innerText || child.textContent || "") === text;
-                });
-                if (childWithSameText) {
-                    continue;
-                }
-                if (entries[entries.length - 1] !== text) {
-                    entries.push(text);
-                }
-            }
-            const hasStopControl = Array.from(document.querySelectorAll("button")).some((button) => {
-                const label = normalize(button.getAttribute("aria-label") ?? button.textContent ?? "").toLowerCase();
-                return label.includes("stop");
-            });
-            const promptIndex = entries.lastIndexOf(normalizedPrompt);
-            if (promptIndex < 0) {
-                return false;
-            }
-            let hasCandidate = false;
-            for (let index = promptIndex + 1; index < entries.length; index += 1) {
-                const candidate = entries[index];
-                if (!candidate || isIgnoredResponse(candidate)) {
-                    continue;
-                }
-                hasCandidate = true;
-            }
-            return !hasStopControl && hasCandidate;
-        }, {
-            op: "grok_wait",
-            previous: (previousResponse ?? "").replace(/\s+/g, " ").trim(),
-            promptText: prompt,
-        }, { timeout: timeoutMs });
-    }
-    catch {
-        return { confirmed: false };
-    }
-    const state = await page.evaluate(({ op, promptText, previousText }) => {
-        if (op !== "grok_extract_state") {
-            return undefined;
-        }
-        const normalize = (value) => value.replace(/\s+/g, " ").trim();
-        const normalizedPrompt = normalize(promptText);
-        const normalizedPrevious = normalize(previousText);
-        const isIgnoredResponse = (value) => {
-            const lower = value.toLowerCase();
-            return (lower.length < 3 ||
-                lower.startsWith("see new posts") ||
-                lower.startsWith("thought for ") ||
-                lower.startsWith("agents thinking") ||
-                lower.startsWith("ask anything") ||
-                lower === "agents" ||
-                lower === "thinking" ||
-                lower === "expert" ||
-                lower.startsWith("grok") ||
-                lower.includes("explore ") ||
-                lower.includes("discuss ") ||
-                lower.includes("create images") ||
-                lower.includes("edit image") ||
-                lower.includes("latest news") ||
-                lower === normalizedPrompt.toLowerCase() ||
-                lower === normalizedPrevious.toLowerCase());
-        };
-        const scope = document.querySelector("div[aria-label='Grok']") ??
-            document.querySelector("main");
-        if (!scope) {
-            return undefined;
-        }
-        const lines = (scope.innerText || scope.textContent || "")
-            .split(/\n+/)
-            .map((line) => normalize(line))
-            .filter((line) => line.length > 0);
-        const lineResponseCandidates = [];
-        const linePromptIndex = lines.lastIndexOf(normalizedPrompt);
-        if (linePromptIndex >= 0) {
-            for (let index = linePromptIndex + 1; index < lines.length; index += 1) {
-                const candidate = lines[index];
-                if (!candidate || isIgnoredResponse(candidate)) {
-                    continue;
-                }
-                lineResponseCandidates.push(candidate);
-            }
-        }
-        let responseForPrompt;
-        if (lineResponseCandidates.length > 0) {
-            responseForPrompt = lineResponseCandidates.sort((left, right) => right.length - left.length)[0];
-        }
-        if (responseForPrompt) {
-            let latestResponse = responseForPrompt;
-            for (let index = lines.length - 1; index >= 0; index -= 1) {
-                const candidate = lines[index];
-                if (!candidate || isIgnoredResponse(candidate)) {
-                    continue;
-                }
-                latestResponse = candidate;
-                break;
-            }
-            return {
-                responseForPrompt,
-                latestResponse,
-            };
-        }
-        const entries = [];
-        for (const node of Array.from(scope.querySelectorAll("div, span, p"))) {
-            if (node.closest("button, a, textarea, nav")) {
-                continue;
-            }
-            const text = normalize(node.innerText || node.textContent || "");
-            if (!text) {
-                continue;
-            }
-            const childWithSameText = Array.from(node.children).some((child) => {
-                if (!(child instanceof HTMLElement)) {
-                    return false;
-                }
-                return normalize(child.innerText || child.textContent || "") === text;
-            });
-            if (childWithSameText) {
-                continue;
-            }
-            if (entries[entries.length - 1] !== text) {
-                entries.push(text);
-            }
+    }
+    const uploadSelectors = [
+        "input[type='file'][accept*='application/pdf']",
+        "input[type='file'][accept*='text/csv']",
+        "input[type='file'][accept*='text/plain']",
+        "input[type='file']",
+    ];
+    let uploadSelector;
+    for (const selector of uploadSelectors) {
+        const handle = await page.waitForSelector(selector, { timeout: 1_200 }).catch(() => null);
+        if (!handle) {
+            continue;
         }
-        const responseCandidates = [];
-        const promptIndex = entries.lastIndexOf(normalizedPrompt);
-        if (promptIndex >= 0) {
-            for (let index = promptIndex + 1; index < entries.length; index += 1) {
-                const candidate = entries[index];
-                if (!candidate || isIgnoredResponse(candidate)) {
-                    continue;
-                }
-                responseCandidates.push(candidate);
-            }
+        await handle.dispose().catch(() => { });
+        uploadSelector = selector;
+        break;
+    }
+    if (!uploadSelector) {
+        return { ok: false, reason: "attachment_input_not_found" };
+    }
+    try {
+        await page.setInputFiles(uploadSelector, attachments.map((attachment) => attachment.path));
+    }
+    catch {
+        return { ok: false, reason: "attachment_upload_failed" };
+    }
+    const attachmentNames = attachments.map((attachment) => attachment.name);
+    await page
+        .waitForFunction(({ names }) => {
+        const bodyText = document.body?.innerText ?? "";
+        return names.every((name) => bodyText.includes(name));
+    }, { names: attachmentNames }, { timeout: 10_000 })
+        .catch(() => { });
+    await page.waitForTimeout(600);
+    return { ok: true };
+}
+async function askGrokViaNetwork(page, prompt, timeoutMs) {
+    const captured = await captureRoutedResponseText(page, "https://grok.x.com/2/grok/add_response.json*", async () => {
+        const submitResult = await submitGrokPrompt(page, prompt);
+        return submitResult.ok;
+    }, {
+        timeoutMs,
+    });
+    if (!captured || captured.status < 200 || captured.status >= 300) {
+        return undefined;
+    }
+    const responseText = captured.text;
+    const entries = parseNdjsonLines(responseText);
+    const finalParts = collectTextByTag(entries.map((entry) => {
+        const output = {};
+        if (typeof entry.result?.message === "string") {
+            output.message = entry.result.message;
         }
-        responseForPrompt = undefined;
-        if (responseCandidates.length > 0) {
-            responseForPrompt = responseCandidates.sort((left, right) => right.length - left.length)[0];
+        if (typeof entry.result?.messageTag === "string") {
+            output.messageTag = entry.result.messageTag;
         }
-        let latestResponse;
-        for (let index = entries.length - 1; index >= 0; index -= 1) {
-            const candidate = entries[index];
-            if (!candidate || isIgnoredResponse(candidate)) {
-                continue;
-            }
-            latestResponse = candidate;
-            break;
+        return output;
+    }), "final");
+    let conversationId;
+    for (const entry of entries) {
+        if (!conversationId && typeof entry.conversationId === "string") {
+            conversationId = entry.conversationId;
         }
-        return {
-            responseForPrompt,
-            latestResponse,
-        };
-    }, {
-        op: "grok_extract_state",
-        promptText: prompt,
-        previousText: previousResponse ?? "",
-    });
-    if (state && typeof state === "object" && typeof state.responseForPrompt === "string" && state.responseForPrompt.length > 0) {
-        await page.waitForTimeout(600);
-        const settledState = await page.evaluate(({ op, promptText, previousText }) => {
+    }
+    const finalResponse = joinTextParts(finalParts).trim();
+    if (!finalResponse) {
+        return undefined;
+    }
+    const artifactResult = await materializeGrokArtifacts(finalResponse);
+    const output = {
+        ok: true,
+        response: artifactResult.response,
+        url: typeof conversationId === "string" ? `https://x.com/i/grok?conversation=${conversationId}` : page.url(),
+    };
+    if (typeof conversationId === "string") {
+        output.conversationId = conversationId;
+    }
+    if (artifactResult.artifacts) {
+        output.artifacts = artifactResult.artifacts;
+    }
+    return output;
+}
+async function waitForGrokResponse(page, previousResponse, prompt, timeoutMs) {
+    const startedAt = Date.now();
+    const hardDeadline = startedAt + Math.max(timeoutMs * 3, timeoutMs + 120_000);
+    let idleDeadline = startedAt + timeoutMs;
+    let previousSignature = "";
+    while (Date.now() < hardDeadline && Date.now() < idleDeadline) {
+        const state = await page.evaluate(({ op, promptText, previousText }) => {
             if (op !== "grok_extract_state") {
                 return undefined;
             }
@@ -3042,10 +5775,19 @@ async function waitForGrokResponse(page, previousResponse, prompt, timeoutMs) {
                     lower === normalizedPrompt.toLowerCase() ||
                     lower === normalizedPrevious.toLowerCase());
             };
+            const hasStopControl = Array.from(document.querySelectorAll("button")).some((button) => {
+                const label = normalize(button.getAttribute("aria-label") ?? button.textContent ?? "").toLowerCase();
+                return label.includes("stop");
+            });
             const scope = document.querySelector("div[aria-label='Grok']") ??
                 document.querySelector("main");
             if (!scope) {
-                return undefined;
+                return {
+                    hasStopControl,
+                    responseForPrompt: undefined,
+                    latestResponse: undefined,
+                    signature: `stop:${String(hasStopControl)}`,
+                };
             }
             const lines = (scope.innerText || scope.textContent || "")
                 .split(/\n+/)
@@ -3062,11 +5804,9 @@ async function waitForGrokResponse(page, previousResponse, prompt, timeoutMs) {
                     lineResponseCandidates.push(candidate);
                 }
             }
-            if (lineResponseCandidates.length > 0) {
-                return {
-                    responseForPrompt: lineResponseCandidates.sort((left, right) => right.length - left.length)[0],
-                };
-            }
+            let responseForPrompt = lineResponseCandidates.length > 0
+                ? lineResponseCandidates.sort((left, right) => right.length - left.length)[0]
+                : undefined;
             const entries = [];
             for (const node of Array.from(scope.querySelectorAll("div, span, p"))) {
                 if (node.closest("button, a, textarea, nav")) {
@@ -3089,44 +5829,69 @@ async function waitForGrokResponse(page, previousResponse, prompt, timeoutMs) {
                     entries.push(text);
                 }
             }
-            const responseCandidates = [];
-            const promptIndex = entries.lastIndexOf(normalizedPrompt);
-            if (promptIndex >= 0) {
-                for (let index = promptIndex + 1; index < entries.length; index += 1) {
-                    const candidate = entries[index];
-                    if (!candidate || isIgnoredResponse(candidate)) {
-                        continue;
+            if (!responseForPrompt) {
+                const promptIndex = entries.lastIndexOf(normalizedPrompt);
+                if (promptIndex >= 0) {
+                    const responseCandidates = [];
+                    for (let index = promptIndex + 1; index < entries.length; index += 1) {
+                        const candidate = entries[index];
+                        if (!candidate || isIgnoredResponse(candidate)) {
+                            continue;
+                        }
+                        responseCandidates.push(candidate);
+                    }
+                    if (responseCandidates.length > 0) {
+                        responseForPrompt = responseCandidates.sort((left, right) => right.length - left.length)[0];
                     }
-                    responseCandidates.push(candidate);
                 }
             }
-            let responseForPrompt;
-            if (responseCandidates.length > 0) {
-                responseForPrompt = responseCandidates.sort((left, right) => right.length - left.length)[0];
+            let latestResponse;
+            for (let index = entries.length - 1; index >= 0; index -= 1) {
+                const candidate = entries[index];
+                if (!candidate || isIgnoredResponse(candidate)) {
+                    continue;
+                }
+                latestResponse = candidate;
+                break;
             }
             return {
+                hasStopControl,
                 responseForPrompt,
+                latestResponse,
+                signature: JSON.stringify({
+                    hasStopControl,
+                    responseForPrompt: responseForPrompt ?? "",
+                    latestResponse: latestResponse ?? "",
+                }),
             };
         }, {
             op: "grok_extract_state",
             promptText: prompt,
             previousText: previousResponse ?? "",
-        });
-        if (settledState &&
-            typeof settledState === "object" &&
-            typeof settledState.responseForPrompt === "string" &&
-            settledState.responseForPrompt.length > 0) {
-            return {
-                confirmed: true,
-                response: settledState.responseForPrompt,
-            };
+        }).catch(() => undefined);
+        if (state && typeof state === "object") {
+            const signature = typeof state.signature === "string" ? state.signature : "";
+            if (signature && signature !== previousSignature) {
+                previousSignature = signature;
+                idleDeadline = Date.now() + timeoutMs;
+            }
+            if (state.hasStopControl === true) {
+                idleDeadline = Date.now() + timeoutMs;
+            }
+            if (state.hasStopControl !== true &&
+                typeof state.responseForPrompt === "string" &&
+                state.responseForPrompt.length > 0) {
+                return {
+                    confirmed: true,
+                    response: state.responseForPrompt,
+                };
+            }
+        }
+        const remainingIdleMs = idleDeadline - Date.now();
+        const sleepMs = Math.min(1_000, Math.max(0, remainingIdleMs));
+        if (sleepMs > 0) {
+            await page.waitForTimeout(sleepMs);
         }
-    }
-    if (state && typeof state === "object" && typeof state.responseForPrompt === "string" && state.responseForPrompt.length > 0) {
-        return {
-            confirmed: true,
-            response: state.responseForPrompt,
-        };
     }
     return { confirmed: false };
 }
@@ -3147,7 +5912,11 @@ async function readLatestGrokResponse(page) {
                 lower === "thinking" ||
                 lower === "expert" ||
                 lower.startsWith("grok") ||
-                lower.includes("explore "));
+                lower.includes("explore ") ||
+                lower.includes("discuss ") ||
+                lower.includes("create images") ||
+                lower.includes("edit image") ||
+                lower.includes("latest news"));
         };
         const scope = document.querySelector("div[aria-label='Grok']") ??
             document.querySelector("main");
@@ -3158,20 +5927,13 @@ async function readLatestGrokResponse(page) {
             .split(/\n+/)
             .map((line) => normalize(line))
             .filter((line) => line.length > 0);
-        for (let index = lines.length - 1; index >= 0; index -= 1) {
-            const candidate = lines[index];
-            if (!candidate || isIgnoredResponse(candidate)) {
-                continue;
-            }
-            return { latestResponse: candidate };
-        }
         const entries = [];
         for (const node of Array.from(scope.querySelectorAll("div, span, p"))) {
             if (node.closest("button, a, textarea, nav")) {
                 continue;
             }
             const text = normalize(node.innerText || node.textContent || "");
-            if (!text || isIgnoredResponse(text)) {
+            if (!text) {
                 continue;
             }
             const childWithSameText = Array.from(node.children).some((child) => {
@@ -3188,15 +5950,18 @@ async function readLatestGrokResponse(page) {
             }
         }
         let latestResponse;
-        for (let index = entries.length - 1; index >= 0; index -= 1) {
-            const candidate = entries[index];
+        const responseCandidates = entries.length > 0 ? entries : lines;
+        for (let index = responseCandidates.length - 1; index >= 0; index -= 1) {
+            const candidate = responseCandidates[index];
             if (!candidate || isIgnoredResponse(candidate)) {
                 continue;
             }
             latestResponse = candidate;
             break;
         }
-        return { latestResponse };
+        return {
+            latestResponse,
+        };
     }, { op: "grok_extract_state" });
     if (state && typeof state === "object" && typeof state.latestResponse === "string") {
         return state.latestResponse;
@@ -3259,8 +6024,6 @@ async function askGrok(page, prompt, timeoutMs, attachments, conversationId) {
                 }
                 return output;
             }
-            await grokPage.goto("https://x.com/i/grok", { waitUntil: "domcontentloaded", timeout: 60_000 }).catch(() => { });
-            await waitForGrokSurface(grokPage);
             const previousResponse = await readLatestGrokResponse(grokPage);
             logGrokPhase("previous_response_read", {
                 hasPreviousResponse: previousResponse !== undefined,
@@ -3386,6 +6149,7 @@ async function requireAuthenticated(page) {
 export function createXAdapter(options) {
     const composeConfirmTimeoutMs = options?.composeConfirmTimeoutMs ?? DEFAULT_COMPOSE_CONFIRM_TIMEOUT_MS;
     const grokResponseTimeoutMs = options?.grokResponseTimeoutMs ?? DEFAULT_GROK_RESPONSE_TIMEOUT_MS;
+    const articlePublishTimeoutMs = options?.articlePublishTimeoutMs ?? DEFAULT_ARTICLE_PUBLISH_TIMEOUT_MS;
     const maxPostLength = options?.maxPostLength ?? DEFAULT_MAX_POST_LENGTH;
     return {
         name: "adapter-x",
@@ -3642,6 +6406,20 @@ export function createXAdapter(options) {
                 const dryRun = args.dryRun === true;
                 return await replyToTweet(page, targetUrl, text, dryRun, composeConfirmTimeoutMs);
             }
+            if (name === "tweet.delete") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const url = typeof args.url === "string" ? args.url.trim() : "";
+                const id = typeof args.id === "string" ? args.id.trim() : "";
+                if (!url && !id) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                }
+                const targetUrl = url || `https://x.com/i/web/status/${encodeURIComponent(id)}`;
+                const dryRun = args.dryRun === true;
+                return await deleteTweetDetail(page, targetUrl, dryRun);
+            }
             if (name === "grok.chat") {
                 const authCheck = await requireAuthenticated(page);
                 if (!authCheck.ok) {
@@ -3658,10 +6436,209 @@ export function createXAdapter(options) {
                 const conversationId = typeof args.conversationId === "string" ? args.conversationId.trim() : "";
                 return await askGrok(page, prompt, grokResponseTimeoutMs, resolvedAttachments.attachments, conversationId || undefined);
             }
+            if (name === "article.get") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const url = typeof args.url === "string" ? args.url.trim() : "";
+                const id = typeof args.id === "string" ? args.id.trim() : "";
+                const authorHandle = typeof args.authorHandle === "string" ? args.authorHandle.trim() : "";
+                const targetUrl = normalizeArticleUrl(url, id);
+                if (!targetUrl) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                }
+                return await readArticleByUrl(page, targetUrl, authorHandle || undefined);
+            }
+            if (name === "article.listDrafts") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                return await listArticleDrafts(page);
+            }
+            if (name === "article.getDraft") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const url = typeof args.url === "string" ? args.url.trim() : "";
+                const id = typeof args.id === "string" ? args.id.trim() : "";
+                if (!id && !url) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                }
+                let articleId = id || undefined;
+                if (!articleId && url) {
+                    articleId = parseArticleIdFromUrl(url);
+                    if (!articleId) {
+                        return errorResult("VALIDATION_ERROR", "could not parse article id from url");
+                    }
+                }
+                if (!articleId) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                }
+                return await getArticleDraft(page, buildArticleEditUrl(articleId));
+            }
+            if (name === "article.draftMarkdown") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const markdownPath = typeof args.markdownPath === "string" ? args.markdownPath.trim() : "";
+                if (!markdownPath) {
+                    return errorResult("VALIDATION_ERROR", "markdownPath is required");
+                }
+                const explicitTitle = typeof args.title === "string" ? args.title.trim() : "";
+                const coverImagePath = typeof args.coverImagePath === "string" ? args.coverImagePath.trim() : "";
+                return await draftArticleMarkdown(page, markdownPath, explicitTitle || undefined, coverImagePath || undefined);
+            }
+            if (name === "article.upsertDraftMarkdown") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const url = typeof args.url === "string" ? args.url.trim() : "";
+                const id = typeof args.id === "string" ? args.id.trim() : "";
+                const markdownPath = typeof args.markdownPath === "string" ? args.markdownPath.trim() : "";
+                if (!markdownPath) {
+                    return errorResult("VALIDATION_ERROR", "markdownPath is required");
+                }
+                const explicitTitle = typeof args.title === "string" ? args.title.trim() : "";
+                const coverImagePath = typeof args.coverImagePath === "string" ? args.coverImagePath.trim() : "";
+                let articleId = id || undefined;
+                if (!articleId && url) {
+                    articleId = parseArticleIdFromUrl(url);
+                    if (!articleId) {
+                        return errorResult("VALIDATION_ERROR", "url is invalid or unsupported");
+                    }
+                }
+                const targetUrl = articleId ? buildArticleEditUrl(articleId) : undefined;
+                return await upsertArticleDraftMarkdown(page, targetUrl, markdownPath, explicitTitle || undefined, coverImagePath || undefined);
+            }
+            if (name === "article.publishMarkdown") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const markdownPath = typeof args.markdownPath === "string" ? args.markdownPath.trim() : "";
+                if (!markdownPath) {
+                    return errorResult("VALIDATION_ERROR", "markdownPath is required");
+                }
+                const explicitTitle = typeof args.title === "string" ? args.title.trim() : "";
+                const coverImagePath = typeof args.coverImagePath === "string" ? args.coverImagePath.trim() : "";
+                const dryRun = args.dryRun === true;
+                return await publishArticleMarkdown(page, markdownPath, explicitTitle || undefined, coverImagePath || undefined, dryRun, articlePublishTimeoutMs);
+            }
+            if (name === "article.publish") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const url = typeof args.url === "string" ? args.url.trim() : "";
+                const id = typeof args.id === "string" ? args.id.trim() : "";
+                const articleId = id || (url ? parseArticleIdFromUrl(url) : undefined);
+                if (!articleId && !url) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                }
+                const targetUrl = url && url.includes("/compose/articles/edit/")
+                    ? url
+                    : articleId
+                        ? `https://x.com/compose/articles/edit/${articleId}`
+                        : url;
+                if (!targetUrl) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                }
+                return await publishExistingArticle(page, targetUrl, articlePublishTimeoutMs);
+            }
+            if (name === "article.setCoverImage") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const url = typeof args.url === "string" ? args.url.trim() : "";
+                const id = typeof args.id === "string" ? args.id.trim() : "";
+                const articleId = id || (url ? parseArticleIdFromUrl(url) : undefined);
+                if (!articleId && !url) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                }
+                const coverImagePath = typeof args.coverImagePath === "string" ? args.coverImagePath.trim() : "";
+                if (!coverImagePath) {
+                    return errorResult("VALIDATION_ERROR", "coverImagePath is required");
+                }
+                const targetUrl = url && url.includes("/compose/articles/edit/")
+                    ? url
+                    : articleId
+                        ? `https://x.com/compose/articles/edit/${articleId}`
+                        : url;
+                if (!targetUrl) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                }
+                return await setArticleCoverImage(page, targetUrl, coverImagePath);
+            }
+            if (name === "article.updateMarkdown") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const url = typeof args.url === "string" ? args.url.trim() : "";
+                const id = typeof args.id === "string" ? args.id.trim() : "";
+                const articleId = id || (url ? parseArticleIdFromUrl(url) : undefined);
+                if (!articleId && !url) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                }
+                const markdownPath = typeof args.markdownPath === "string" ? args.markdownPath.trim() : "";
+                if (!markdownPath) {
+                    return errorResult("VALIDATION_ERROR", "markdownPath is required");
+                }
+                const explicitTitle = typeof args.title === "string" ? args.title.trim() : "";
+                const targetUrl = url && url.includes("/compose/articles/edit/")
+                    ? url
+                    : articleId
+                        ? `https://x.com/compose/articles/edit/${articleId}`
+                        : url;
+                if (!targetUrl) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                }
+                return await updateArticleMarkdown(page, targetUrl, markdownPath, explicitTitle || undefined);
+            }
+            if (name === "article.delete") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const url = typeof args.url === "string" ? args.url.trim() : "";
+                const id = typeof args.id === "string" ? args.id.trim() : "";
+                const dryRun = args.dryRun === true;
+                const articleId = id || (url ? parseArticleIdFromUrl(url) : undefined);
+                if (!articleId && !url) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                }
+                const targetUrl = url && url.includes("/compose/articles/edit/")
+                    ? url
+                    : articleId
+                        ? `https://x.com/compose/articles/edit/${articleId}`
+                        : url;
+                if (!targetUrl) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                }
+                const cachedPage = articleId ? getCachedArticleDraftPage(page, articleId) : undefined;
+                if (cachedPage) {
+                    const result = await deleteArticleEditor(cachedPage, dryRun);
+                    if (!dryRun && articleId && (!result || typeof result !== "object" || Array.isArray(result) || !("error" in result))) {
+                        await removeCachedArticleDraftPage(page, articleId);
+                    }
+                    return result;
+                }
+                return await withEphemeralPage(page, targetUrl, async (articlePage) => {
+                    await waitForArticleEditorSurface(articlePage);
+                    return await deleteArticleEditor(articlePage, dryRun);
+                });
+            }
             return errorResult("TOOL_NOT_FOUND", `unknown tool: ${name}`);
         },
         stop: async ({ page }) => {
             await closeCachedReadPages(page);
+            await closeCachedArticleDraftPages(page);
         },
     };
 }