@sellable/mcp 0.1.269 → 0.1.271

package/dist/tools/content-posts.js

@@ -1,13 +1,34 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { execFileSync } from "node:child_process";
+import { pathToFileURL } from "node:url";
 const CONTENT_ROOT_ENV = "SELLABLE_CONTENT_DIR";
 const DEFAULT_PREVIEW_CHARS = 220;
+const LINKEDIN_PREVIEW_CONTRACT_VERSION = "linkedin-preview-rendering/v2";
+const LINKEDIN_PREVIEW_FONT_SIZE_PX = 14;
+const LINKEDIN_PREVIEW_LINE_HEIGHT_PX = 21;
+const LINKEDIN_DEFAULT_CLAMP_LINES = 3;
+const LINKEDIN_MOBILE_CHAR_GUARDRAIL = 140;
+const LINKEDIN_DESKTOP_CHAR_GUARDRAIL = 210;
+const LINKEDIN_PREVIEW_SURFACES = {
+    mobile: {
+        textWidthPx: 308,
+        viewportWidthPx: 390,
+        viewportHeightPx: 760,
+    },
+    desktop: {
+        textWidthPx: 582,
+        viewportWidthPx: 744,
+        viewportHeightPx: 760,
+    },
+};
 const RELATIVE_DIRS = {
     ideas: "linkedin/ideas",
     hookResearch: "linkedin/research/hooks",
     drafts: "linkedin/drafts",
     published: "linkedin/published",
+    previews: "linkedin/previews",
     commentLibrary: "linkedin/comments/library",
 };
 export const contentPostToolDefinitions = [
@@ -104,6 +125,92 @@ export const contentPostToolDefinitions = [
             additionalProperties: false,
         },
     },
+    {
+        name: "calculate_linkedin_hook_preview",
+        description: "Functionally calculate the LinkedIn pre-see-more hook for mobile and desktop. Returns rendered visible lines and rule diagnostics without writing files.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                postText: {
+                    type: "string",
+                    description: "Full post text or hook block to calculate. Provide either postText or draftId.",
+                },
+                draftId: {
+                    type: "string",
+                    description: "Optional saved draft ID. When postText is omitted, the tool calculates this draft's Draft Body.",
+                },
+                sourceLabel: { type: "string" },
+                measurementMode: {
+                    type: "string",
+                    enum: ["browser", "estimated"],
+                    description: "Defaults to browser. Browser mode uses local Chrome layout measurement when available; estimated mode uses the deterministic width model.",
+                },
+                requireBrowserMeasurement: {
+                    type: "boolean",
+                    description: "Defaults to false. When true, fail if local Chrome cannot measure rendered lines.",
+                },
+                clampLines: {
+                    type: "number",
+                    description: "Visible rendered lines before see-more for both surfaces. Defaults to 3.",
+                },
+                mobileClampLines: {
+                    type: "number",
+                    description: "Optional mobile-specific visible rendered line count. Defaults to clampLines.",
+                },
+                desktopClampLines: {
+                    type: "number",
+                    description: "Optional desktop-specific visible rendered line count. Defaults to clampLines.",
+                },
+                mobileTextWidthPx: {
+                    type: "number",
+                    description: "Optional mobile text width override. Defaults to 308px.",
+                },
+                desktopTextWidthPx: {
+                    type: "number",
+                    description: "Optional desktop text width override. Defaults to 582px.",
+                },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "render_linkedin_post_preview",
+        description: "Render any LinkedIn post text through the Sellable LinkedIn preview CSS contract for mobile and desktop. Writes HTML artifacts and, when local Chrome is available, browser screenshots under ~/.sellable/content/linkedin/previews.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                postText: {
+                    type: "string",
+                    description: "Full post text to render. Provide either postText or draftId.",
+                },
+                draftId: {
+                    type: "string",
+                    description: "Optional saved draft ID. When postText is omitted, the tool renders this draft's Draft Body.",
+                },
+                renderId: {
+                    type: "string",
+                    description: "Optional stable render ID. Must be a safe filename without slashes.",
+                },
+                sourceLabel: { type: "string" },
+                createdAt: { type: "string" },
+                renderScreenshots: {
+                    type: "boolean",
+                    description: "Defaults to true. When true, tries to use local Chrome headless to write PNG screenshots.",
+                },
+                requireScreenshots: {
+                    type: "boolean",
+                    description: "Defaults to false. When true, fail if local Chrome cannot produce PNG screenshots.",
+                },
+                reviewClampLines: {
+                    type: "number",
+                    description: "Visible review lines before see-more. Defaults to 3.",
+                },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+    },
     {
         name: "update_post_draft",
         description: "Update an existing LinkedIn post draft in place while preserving omitted fields. Useful for adding iteration receipts, status changes, or final copy edits without rewriting the whole artifact.",
@@ -389,6 +496,147 @@ export function savePostDraftTool(input) {
         preview: sanitizedPreview(input.body),
     };
 }
+export function calculateLinkedInHookPreviewTool(input) {
+    const { postText, draftId } = resolveLinkedInPreviewPostText(input);
+    const defaultClampLines = boundedWholeNumber(input.clampLines, LINKEDIN_DEFAULT_CLAMP_LINES, 1, 8);
+    const measurementMode = input.measurementMode ?? "browser";
+    const mobile = calculateLinkedInHookPreviewSurface({
+        label: "mobile",
+        text: postText,
+        textWidthPx: boundedWholeNumber(input.mobileTextWidthPx, LINKEDIN_PREVIEW_SURFACES.mobile.textWidthPx, 160, 900),
+        clampLines: boundedWholeNumber(input.mobileClampLines, defaultClampLines, 1, 8),
+        measurementMode,
+        requireBrowserMeasurement: input.requireBrowserMeasurement,
+    });
+    const desktop = calculateLinkedInHookPreviewSurface({
+        label: "desktop",
+        text: postText,
+        textWidthPx: boundedWholeNumber(input.desktopTextWidthPx, LINKEDIN_PREVIEW_SURFACES.desktop.textWidthPx, 260, 1200),
+        clampLines: boundedWholeNumber(input.desktopClampLines, defaultClampLines, 1, 8),
+        measurementMode,
+        requireBrowserMeasurement: input.requireBrowserMeasurement,
+    });
+    return {
+        basis: "linkedin_rendering_rule_function",
+        ruleConfidence: "calibrated_from_observed_linkedin_feed_screenshots_and_public_line_clamp_behavior",
+        cssContractVersion: LINKEDIN_PREVIEW_CONTRACT_VERSION,
+        sourceLabel: input.sourceLabel || draftId,
+        draftId,
+        ruleSummary: "The hook is the text visible before see more. The review gate is rendered line count, not a fixed character count. Blank lines consume visible lines.",
+        rules: {
+            visibleUnit: "rendered_visual_line",
+            defaultClampLines: LINKEDIN_DEFAULT_CLAMP_LINES,
+            fontSizePx: LINKEDIN_PREVIEW_FONT_SIZE_PX,
+            lineHeightPx: LINKEDIN_PREVIEW_LINE_HEIGHT_PX,
+            whiteSpace: "pre-wrap",
+            overflowWrap: "break-word",
+            desktopCharGuardrail: LINKEDIN_DESKTOP_CHAR_GUARDRAIL,
+            mobileCharGuardrail: LINKEDIN_MOBILE_CHAR_GUARDRAIL,
+            characterCountsAreGuardrailsOnly: true,
+            notOfficialLinkedInApi: true,
+            strongestEvidence: "authenticated LinkedIn feed screenshot on the target surface",
+        },
+        mobile,
+        desktop,
+        diagnostics: previewDiagnostics(postText),
+    };
+}
+export function renderLinkedInPostPreviewTool(input) {
+    const now = normalizeDate(input.createdAt);
+    const { postText, draftId } = resolveLinkedInPreviewPostText(input);
+    const reviewClampLines = typeof input.reviewClampLines === "number" &&
+        Number.isFinite(input.reviewClampLines)
+        ? Math.max(1, Math.min(Math.floor(input.reviewClampLines), 8))
+        : 3;
+    const id = input.renderId ??
+        `preview_${dateStamp(now)}_${slugify(input.sourceLabel || draftId || postText)}`;
+    const safeId = normalizeArtifactId(id, "renderId");
+    const baseDir = `${RELATIVE_DIRS.previews}/${safeId}`;
+    const title = input.sourceLabel || draftId || safeId;
+    const renderScreenshots = input.renderScreenshots !== false;
+    const mobile = buildPreviewSurface({
+        label: "mobile",
+        text: postText,
+        baseDir,
+        textWidthPx: LINKEDIN_PREVIEW_SURFACES.mobile.textWidthPx,
+        viewportWidthPx: LINKEDIN_PREVIEW_SURFACES.mobile.viewportWidthPx,
+        viewportHeightPx: LINKEDIN_PREVIEW_SURFACES.mobile.viewportHeightPx,
+        reviewClampLines,
+    });
+    const desktop = buildPreviewSurface({
+        label: "desktop",
+        text: postText,
+        baseDir,
+        textWidthPx: LINKEDIN_PREVIEW_SURFACES.desktop.textWidthPx,
+        viewportWidthPx: LINKEDIN_PREVIEW_SURFACES.desktop.viewportWidthPx,
+        viewportHeightPx: LINKEDIN_PREVIEW_SURFACES.desktop.viewportHeightPx,
+        reviewClampLines,
+    });
+    const combinedHtmlRelativePath = `${baseDir}/preview.html`;
+    const combinedHtml = buildCombinedPreviewHtml({
+        title,
+        postText,
+        mobile,
+        desktop,
+    });
+    writeContentFile(combinedHtmlRelativePath, combinedHtml);
+    const screenshotResult = renderScreenshots
+        ? renderPreviewScreenshots([mobile, desktop], input.requireScreenshots)
+        : { status: "skipped", reason: "renderScreenshots=false" };
+    const metadata = {
+        id: safeId,
+        type: "linkedin_preview",
+        status: screenshotResult.status === "rendered" ? "rendered" : "html_rendered",
+        title,
+        draftId,
+        createdAt: now,
+        updatedAt: now,
+    };
+    const renderedPreview = {
+        basis: screenshotResult.status === "rendered"
+            ? "local_chrome_headless_screenshot"
+            : "linkedin_css_contract_html",
+        cssContractVersion: LINKEDIN_PREVIEW_CONTRACT_VERSION,
+        generatedAt: now,
+        sourceLabel: title,
+        mobile: surfaceRecord(mobile),
+        desktop: surfaceRecord(desktop),
+        diagnostics: previewDiagnostics(postText),
+        screenshotStatus: screenshotResult,
+    };
+    const recordRelativePath = `${baseDir}/render.md`;
+    const metadataJsonRelativePath = `${baseDir}/metadata.json`;
+    writeContentFile(metadataJsonRelativePath, `${JSON.stringify(renderedPreview, null, 2)}\n`);
+    writeArtifact(recordRelativePath, buildMarkdown(metadata, [
+        ["Rendered Preview Record", jsonBlock(renderedPreview)],
+        [
+            "Artifacts",
+            [
+                `- combinedHtml: ${combinedHtmlRelativePath}`,
+                `- mobileHtml: ${mobile.htmlPath}`,
+                mobile.screenshotPath
+                    ? `- mobileScreenshot: ${mobile.screenshotPath}`
+                    : "- mobileScreenshot: none",
+                `- desktopHtml: ${desktop.htmlPath}`,
+                desktop.screenshotPath
+                    ? `- desktopScreenshot: ${desktop.screenshotPath}`
+                    : "- desktopScreenshot: none",
+            ].join("\n"),
+        ],
+    ]));
+    return {
+        id: safeId,
+        path: recordRelativePath,
+        artifactDir: baseDir,
+        absoluteArtifactDir: safePath(resolveContentRoot(), baseDir),
+        combinedHtmlPath: combinedHtmlRelativePath,
+        absoluteCombinedHtmlPath: safePath(resolveContentRoot(), combinedHtmlRelativePath),
+        mobile: surfaceReturnRecord(mobile),
+        desktop: surfaceReturnRecord(desktop),
+        screenshotStatus: screenshotResult,
+        renderedPreview,
+    };
+}
 export function updatePostDraftTool(input) {
     const safeDraftId = normalizeArtifactId(input.draftId, "draftId");
     const relativePath = `${RELATIVE_DIRS.drafts}/${safeDraftId}.md`;
@@ -617,6 +865,555 @@ export function listPublishedPostsTool(input) {
     }
     return summarizeArtifacts(artifacts, input?.limit);
 }
+function resolveLinkedInPreviewPostText(input) {
+    const draftId = input.draftId
+        ? normalizeArtifactId(input.draftId, "draftId")
+        : undefined;
+    const draftBody = draftId
+        ? extractMarkdownSection(getArtifact(RELATIVE_DIRS.drafts, draftId, "draftId").markdown, "Draft Body")
+        : undefined;
+    const postText = input.postText ?? draftBody;
+    requireString(postText, "postText");
+    return { postText, draftId };
+}
+function boundedWholeNumber(value, fallback, min, max) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    return Math.max(min, Math.min(Math.floor(value), max));
+}
+function calculateLinkedInHookPreviewSurface(input) {
+    const measurement = measureLinkedInRenderedLines({
+        text: input.text,
+        textWidthPx: input.textWidthPx,
+        measurementMode: input.measurementMode,
+        requireBrowserMeasurement: input.requireBrowserMeasurement,
+    });
+    const visibleLines = measurement.lines.slice(0, input.clampLines);
+    const hiddenLines = measurement.lines.slice(input.clampLines);
+    const visibleTextBlock = visibleLines.join("\n");
+    const charGuardrail = input.label === "mobile"
+        ? LINKEDIN_MOBILE_CHAR_GUARDRAIL
+        : LINKEDIN_DESKTOP_CHAR_GUARDRAIL;
+    return {
+        label: input.label,
+        textWidthPx: input.textWidthPx,
+        fontSizePx: LINKEDIN_PREVIEW_FONT_SIZE_PX,
+        lineHeightPx: LINKEDIN_PREVIEW_LINE_HEIGHT_PX,
+        clampLines: input.clampLines,
+        charGuardrail,
+        renderedLines: measurement.lines,
+        visibleLines,
+        visibleTextBlock,
+        visibleTextBlockCharCount: visibleTextBlock.length,
+        withinCharGuardrail: visibleTextBlock.length <= charGuardrail,
+        lineCountBeforeClamp: measurement.lines.length,
+        blankLinesBeforeClamp: visibleLines.filter((line) => line.trim().length === 0).length,
+        truncated: hiddenLines.length > 0,
+        seeMoreWouldShow: hiddenLines.length > 0,
+        hiddenTextStartsWith: hiddenLines.find((line) => line.trim().length > 0),
+        measurementBasis: measurement.basis,
+        measurementWarning: measurement.warning,
+        chromePath: measurement.chromePath,
+    };
+}
+function measureLinkedInRenderedLines(input) {
+    if (input.measurementMode === "browser") {
+        const browserMeasurement = measureLinkedInRenderedLinesWithChrome(input.text, input.textWidthPx);
+        if (browserMeasurement)
+            return browserMeasurement;
+        if (input.requireBrowserMeasurement) {
+            throw new Error("Chrome executable not found or browser line measurement failed. Set CHROME_PATH or use measurementMode=estimated.");
+        }
+    }
+    return {
+        lines: estimateRenderedLines(input.text, input.textWidthPx),
+        basis: "estimated_width_model",
+        warning: input.measurementMode === "browser"
+            ? "local Chrome measurement unavailable; used deterministic width estimate"
+            : undefined,
+    };
+}
+function measureLinkedInRenderedLinesWithChrome(text, textWidthPx) {
+    const chromePath = findChromeExecutable();
+    if (!chromePath)
+        return null;
+    const htmlPath = path.join(os.tmpdir(), `sellable-linkedin-hook-preview-${process.pid}-${Date.now()}-${Math.random()
+        .toString(36)
+        .slice(2)}.html`);
+    try {
+        fs.writeFileSync(htmlPath, buildLineMeasurementHtml(text, textWidthPx), "utf8");
+        const dom = execFileSync(chromePath, [
+            "--headless=new",
+            "--disable-gpu",
+            "--no-sandbox",
+            "--disable-dev-shm-usage",
+            "--hide-scrollbars",
+            "--dump-dom",
+            pathToFileURL(htmlPath).href,
+        ], { encoding: "utf8", timeout: 20000, stdio: ["ignore", "pipe", "ignore"] });
+        const encoded = dom.match(/data-linkedin-lines="([^"]+)"/)?.[1];
+        if (!encoded)
+            return null;
+        const decoded = Buffer.from(encoded, "base64").toString("utf8");
+        const parsed = JSON.parse(decoded);
+        if (!Array.isArray(parsed) ||
+            parsed.some((line) => typeof line !== "string")) {
+            return null;
+        }
+        return {
+            lines: parsed,
+            basis: "local_chrome_browser_layout",
+            chromePath,
+        };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        fs.rmSync(htmlPath, { force: true });
+    }
+}
+function buildLineMeasurementHtml(text, textWidthPx) {
+    return [
+        "<!doctype html>",
+        '<html lang="en">',
+        "<head>",
+        '<meta charset="utf-8">',
+        '<meta name="viewport" content="width=device-width, initial-scale=1">',
+        "</head>",
+        "<body>",
+        "<script>",
+        `const text = ${jsonForInlineScript(text)};`,
+        `const textWidthPx = ${textWidthPx};`,
+        `const fontSizePx = ${LINKEDIN_PREVIEW_FONT_SIZE_PX};`,
+        `const lineHeightPx = ${LINKEDIN_PREVIEW_LINE_HEIGHT_PX};`,
+        `
+const div = document.createElement("div");
+div.style.cssText = [
+  "position:absolute",
+  "left:0",
+  "top:0",
+  "width:" + textWidthPx + "px",
+  "font-family:-apple-system,system-ui,'Segoe UI',Roboto,'Helvetica Neue','Fira Sans',Ubuntu,'Oxygen Sans',Cantarell,'Droid Sans','Lucida Grande',Helvetica,Arial,sans-serif",
+  "font-size:" + fontSizePx + "px",
+  "line-height:" + lineHeightPx + "px",
+  "font-weight:400",
+  "letter-spacing:normal",
+  "white-space:pre-wrap",
+  "overflow-wrap:break-word",
+  "color:#000"
+].join(";");
+Array.from(text).forEach((char, index) => {
+  if (char === "\\n") {
+    div.appendChild(document.createTextNode("\\n"));
+    return;
+  }
+  const span = document.createElement("span");
+  span.dataset.index = String(index);
+  span.textContent = char;
+  div.appendChild(span);
+});
+document.body.appendChild(div);
+
+const lines = [];
+let currentText = null;
+let currentTop = null;
+let previousTop = null;
+function flushLine() {
+  if (currentText !== null) {
+    lines.push(currentText.trimEnd());
+    currentText = null;
+    currentTop = null;
+  }
+}
+
+for (const span of div.querySelectorAll("span")) {
+  const rect = span.getClientRects()[0];
+  if (!rect) continue;
+  const top = Math.round(rect.top * 10) / 10;
+  if (currentTop === null || Math.abs(top - currentTop) > 2) {
+    flushLine();
+    if (previousTop !== null) {
+      const blankCount = Math.max(0, Math.round((top - previousTop) / lineHeightPx) - 1);
+      for (let index = 0; index < blankCount; index += 1) lines.push("");
+    }
+    currentText = "";
+    currentTop = top;
+    previousTop = top;
+  }
+  currentText += span.textContent;
+}
+flushLine();
+document.documentElement.setAttribute(
+  "data-linkedin-lines",
+  btoa(unescape(encodeURIComponent(JSON.stringify(lines))))
+);
+`,
+        "</script>",
+        "</body>",
+        "</html>",
+        "",
+    ].join("\n");
+}
+function jsonForInlineScript(value) {
+    return JSON.stringify(value).replace(/</g, "\\u003c");
+}
+function buildPreviewSurface(input) {
+    const estimatedLines = estimateRenderedLines(input.text, input.textWidthPx);
+    const htmlPath = `${input.baseDir}/${input.label}.html`;
+    const surface = {
+        label: input.label,
+        textWidthPx: input.textWidthPx,
+        viewportWidthPx: input.viewportWidthPx,
+        viewportHeightPx: input.viewportHeightPx,
+        fontSizePx: LINKEDIN_PREVIEW_FONT_SIZE_PX,
+        lineHeightPx: LINKEDIN_PREVIEW_LINE_HEIGHT_PX,
+        reviewClampLines: input.reviewClampLines,
+        estimatedLines,
+        estimatedVisibleTextBlock: estimatedLines
+            .slice(0, input.reviewClampLines)
+            .join("\n"),
+        estimatedLineCountBeforeClamp: estimatedLines.length,
+        estimatedBlankLinesBeforeClamp: estimatedLines
+            .slice(0, input.reviewClampLines)
+            .filter((line) => line.trim().length === 0).length,
+        htmlPath,
+        absoluteHtmlPath: safePath(resolveContentRoot(), htmlPath),
+    };
+    writeContentFile(htmlPath, buildSinglePreviewHtml({
+        title: `${input.label} LinkedIn preview`,
+        postText: input.text,
+        surface,
+    }));
+    return surface;
+}
+function buildSinglePreviewHtml(input) {
+    return htmlDocument({
+        title: input.title,
+        bodyClass: input.surface.label,
+        body: linkedInCardHtml(input.postText, input.surface),
+    });
+}
+function buildCombinedPreviewHtml(input) {
+    return htmlDocument({
+        title: `LinkedIn preview: ${input.title}`,
+        bodyClass: "combined",
+        body: [
+            `<main class="combined-grid">`,
+            `<section><h1>Mobile preview</h1>${linkedInCardHtml(input.postText, input.mobile)}</section>`,
+            `<section><h1>Desktop preview</h1>${linkedInCardHtml(input.postText, input.desktop)}</section>`,
+            `</main>`,
+        ].join("\n"),
+    });
+}
+function htmlDocument(input) {
+    return [
+        "<!doctype html>",
+        '<html lang="en">',
+        "<head>",
+        '<meta charset="utf-8">',
+        '<meta name="viewport" content="width=device-width, initial-scale=1">',
+        `<title>${escapeHtml(input.title)}</title>`,
+        "<style>",
+        linkedinPreviewCss(),
+        "</style>",
+        "</head>",
+        `<body class="${escapeHtml(input.bodyClass)}">`,
+        input.body,
+        "</body>",
+        "</html>",
+        "",
+    ].join("\n");
+}
+function linkedInCardHtml(postText, surface) {
+    const escapedText = escapeHtml(postText);
+    const cardWidth = surface.textWidthPx + 32;
+    return [
+        `<article class="linkedin-card" data-surface="${surface.label}" style="width:${cardWidth}px">`,
+        '<header class="post-header" aria-hidden="true">',
+        '<div class="avatar"></div>',
+        '<div class="byline"><div class="name">Preview Author</div><div class="meta">LinkedIn preview contract</div></div>',
+        "</header>",
+        `<div class="post-text" style="width:${surface.textWidthPx}px;-webkit-line-clamp:${surface.reviewClampLines}">${escapedText}</div>`,
+        surface.estimatedLineCountBeforeClamp > surface.reviewClampLines
+            ? '<div class="see-more">...see more</div>'
+            : "",
+        '<div class="post-actions" aria-hidden="true"><span>Like</span><span>Comment</span><span>Repost</span></div>',
+        "</article>",
+    ].join("\n");
+}
+function linkedinPreviewCss() {
+    return `
+:root {
+  color-scheme: light;
+  --linkedin-text: rgba(0, 0, 0, 0.9);
+  --linkedin-muted: rgba(0, 0, 0, 0.6);
+  --linkedin-border: #e0dfdc;
+  --linkedin-bg: #f3f2ef;
+}
+* { box-sizing: border-box; }
+body {
+  margin: 0;
+  min-height: 100vh;
+  background: var(--linkedin-bg);
+  font-family: -apple-system, system-ui, "Segoe UI", Roboto, "Helvetica Neue",
+    "Fira Sans", Ubuntu, "Oxygen Sans", Cantarell, "Droid Sans",
+    "Lucida Grande", Helvetica, Arial, sans-serif;
+}
+body.mobile, body.desktop {
+  display: flex;
+  align-items: flex-start;
+  justify-content: center;
+  padding: 20px;
+}
+.combined-grid {
+  display: grid;
+  grid-template-columns: max-content max-content;
+  gap: 28px;
+  align-items: start;
+  padding: 20px;
+}
+h1 {
+  margin: 0 0 10px;
+  font-size: 14px;
+  line-height: 20px;
+  font-weight: 600;
+  color: var(--linkedin-muted);
+}
+.linkedin-card {
+  background: #fff;
+  border: 1px solid var(--linkedin-border);
+  border-radius: 8px;
+  padding: 12px 16px 10px;
+  color: var(--linkedin-text);
+}
+.post-header {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-bottom: 8px;
+}
+.avatar {
+  width: 40px;
+  height: 40px;
+  border-radius: 50%;
+  background: linear-gradient(135deg, #d7dce0, #eef0f2);
+}
+.byline { min-width: 0; }
+.name {
+  height: 16px;
+  font-size: 14px;
+  line-height: 16px;
+  font-weight: 600;
+}
+.meta {
+  font-size: 12px;
+  line-height: 14px;
+  color: var(--linkedin-muted);
+}
+.post-text {
+  font-size: 14px;
+  line-height: 21px;
+  font-weight: 400;
+  letter-spacing: normal;
+  white-space: pre-wrap;
+  overflow-wrap: break-word;
+  color: var(--linkedin-text);
+  overflow: hidden;
+  display: -webkit-box;
+  -webkit-box-orient: vertical;
+}
+.see-more {
+  margin-top: 2px;
+  font-size: 14px;
+  line-height: 21px;
+  color: var(--linkedin-muted);
+}
+.post-actions {
+  display: flex;
+  gap: 18px;
+  border-top: 1px solid var(--linkedin-border);
+  margin-top: 10px;
+  padding-top: 8px;
+  color: var(--linkedin-muted);
+  font-size: 13px;
+  line-height: 18px;
+}
+`;
+}
+function renderPreviewScreenshots(surfaces, requireScreenshots) {
+    const chromePath = findChromeExecutable();
+    if (!chromePath) {
+        if (requireScreenshots) {
+            throw new Error("Chrome executable not found. Set CHROME_PATH or install Google Chrome to render LinkedIn preview screenshots.");
+        }
+        return { status: "skipped", reason: "chrome_not_found" };
+    }
+    try {
+        for (const surface of surfaces) {
+            const screenshotPath = surface.htmlPath.replace(/\.html$/, ".png");
+            const absoluteScreenshotPath = safePath(resolveContentRoot(), screenshotPath);
+            execFileSync(chromePath, [
+                "--headless=new",
+                "--disable-gpu",
+                "--no-sandbox",
+                "--disable-dev-shm-usage",
+                "--hide-scrollbars",
+                `--screenshot=${absoluteScreenshotPath}`,
+                `--window-size=${surface.viewportWidthPx},${surface.viewportHeightPx}`,
+                pathToFileURL(surface.absoluteHtmlPath).href,
+            ], { stdio: "ignore", timeout: 20000 });
+            surface.screenshotPath = screenshotPath;
+            surface.absoluteScreenshotPath = absoluteScreenshotPath;
+        }
+        return { status: "rendered", chromePath };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        if (requireScreenshots) {
+            throw new Error(`Chrome screenshot render failed: ${reason}`);
+        }
+        return { status: "failed", reason, chromePath };
+    }
+}
+function findChromeExecutable() {
+    const candidates = [
+        process.env.CHROME_PATH,
+        process.env.GOOGLE_CHROME_BIN,
+        "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+        "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+        "/Applications/Chromium.app/Contents/MacOS/Chromium",
+        "/usr/bin/google-chrome",
+        "/usr/bin/google-chrome-stable",
+        "/usr/bin/chromium",
+        "/usr/bin/chromium-browser",
+        "/snap/bin/chromium",
+    ].filter(Boolean);
+    return candidates.find((candidate) => fs.existsSync(candidate)) ?? null;
+}
+function surfaceRecord(surface) {
+    return {
+        textWidthPx: surface.textWidthPx,
+        viewportWidthPx: surface.viewportWidthPx,
+        fontSizePx: surface.fontSizePx,
+        lineHeightPx: surface.lineHeightPx,
+        reviewClampLines: surface.reviewClampLines,
+        estimatedVisibleTextBlock: surface.estimatedVisibleTextBlock,
+        estimatedRenderedLines: surface.estimatedLines.slice(0, surface.reviewClampLines),
+        estimatedLineCountBeforeClamp: surface.estimatedLineCountBeforeClamp,
+        estimatedBlankLinesBeforeClamp: surface.estimatedBlankLinesBeforeClamp,
+        htmlPath: surface.htmlPath,
+        screenshotPath: surface.screenshotPath,
+    };
+}
+function surfaceReturnRecord(surface) {
+    return {
+        ...surfaceRecord(surface),
+        absoluteHtmlPath: surface.absoluteHtmlPath,
+        absoluteScreenshotPath: surface.absoluteScreenshotPath,
+    };
+}
+function previewDiagnostics(text) {
+    const physicalLines = text.split("\n");
+    const nonblankLines = physicalLines.filter((line) => line.trim().length > 0);
+    return {
+        charCount: text.replace(/\s/g, "").length,
+        charCountIncludingNewlines: text.length,
+        firstLineChars: physicalLines[0]?.length ?? 0,
+        firstTwoPhysicalLinesChars: physicalLines.slice(0, 2).join("\n").length,
+        physicalLineCount: physicalLines.length,
+        contentLineCount: nonblankLines.length,
+        longestNonblankLineChars: nonblankLines.reduce((max, line) => Math.max(max, line.length), 0),
+        blankLineCount: physicalLines.length - nonblankLines.length,
+    };
+}
+function estimateRenderedLines(text, textWidthPx) {
+    const physicalLines = text.split("\n");
+    const rendered = [];
+    for (const physicalLine of physicalLines) {
+        if (physicalLine.length === 0) {
+            rendered.push("");
+            continue;
+        }
+        rendered.push(...wrapPhysicalLine(physicalLine, textWidthPx));
+    }
+    return rendered;
+}
+function wrapPhysicalLine(line, textWidthPx) {
+    const tokens = line.match(/\S+\s*/g) ?? [line];
+    const wrapped = [];
+    let current = "";
+    for (const token of tokens) {
+        const candidate = `${current}${token}`;
+        if (!current || measureTextPx(candidate) <= textWidthPx) {
+            current = candidate;
+            continue;
+        }
+        wrapped.push(current.trimEnd());
+        if (measureTextPx(token) <= textWidthPx) {
+            current = token;
+        }
+        else {
+            const broken = breakLongToken(token.trimEnd(), textWidthPx);
+            wrapped.push(...broken.slice(0, -1));
+            current = broken.at(-1) ?? "";
+            if (token.endsWith(" "))
+                current += " ";
+        }
+    }
+    if (current.length > 0)
+        wrapped.push(current.trimEnd());
+    return wrapped.length > 0 ? wrapped : [""];
+}
+function breakLongToken(token, textWidthPx) {
+    const parts = [];
+    let current = "";
+    for (const char of [...token]) {
+        const candidate = `${current}${char}`;
+        if (!current || measureTextPx(candidate) <= textWidthPx) {
+            current = candidate;
+        }
+        else {
+            parts.push(current);
+            current = char;
+        }
+    }
+    if (current)
+        parts.push(current);
+    return parts;
+}
+function measureTextPx(value) {
+    let width = 0;
+    for (const char of [...value]) {
+        width += estimateCharWidthPx(char);
+    }
+    return width;
+}
+function estimateCharWidthPx(char) {
+    if (char === " ")
+        return 3.6;
+    if (/[ilI|.,:;!'`]/.test(char))
+        return 3.8;
+    if (/[fjrt()[\]{}]/.test(char))
+        return 5.2;
+    if (/[mwMW@#%&]/.test(char))
+        return 10.2;
+    if (/[A-Z]/.test(char))
+        return 8.2;
+    if (/[0-9]/.test(char))
+        return 7.3;
+    if (/[^\x00-\x7F]/.test(char))
+        return 8.4;
+    return 7.0;
+}
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
 function getArtifact(relativeDir, id, label) {
     const safeId = normalizeArtifactId(id, label);
     const relativePath = `${relativeDir}/${safeId}.md`;
@@ -810,6 +1607,11 @@ function writeArtifact(relativePath, markdown) {
     const filePath = safeWritablePath(root, relativePath);
     fs.writeFileSync(filePath, markdown);
 }
+function writeContentFile(relativePath, contents) {
+    const root = resolveContentRoot();
+    const filePath = safeWritablePath(root, relativePath);
+    fs.writeFileSync(filePath, contents);
+}
 function safePath(root, relativePath) {
     validateRelativePath(relativePath);
     const fullPath = path.resolve(root, ...relativePath.split("/"));