@sellable/mcp 0.1.263 → 0.1.265

package/dist/server.js

@@ -9,7 +9,7 @@ import { getCampaignTableSchema, queueCampaignCells, reviseMessageTemplateAndRer
 import { createCampaign, duplicateCampaign, getCampaign, getCampaignMessagesPreview, getCampaigns, pauseCampaign, startCampaign, updateCampaign, updateCampaignBrief, } from "./tools/campaigns.js";
 import { queueCells, updateCell } from "./tools/cells.js";
 import { handleStartCliLogin, handleWaitForCliLogin, } from "./tools/cli-login.js";
-import { capturePostIdeaTool, getPostDraftTool, getPostIdeaTool, getPublishedPostTool, listPostDraftIterationsTool, listPostDraftsTool, listPostIdeasTool, listPublishedPostsTool, markPostPublishedTool, renderLinkedInPostPreviewTool, saveHookResearchTool, savePostDraftTool, updatePostDraftTool, updatePublishedPostMetricsTool, } from "./tools/content-posts.js";
+import { calculateLinkedInHookPreviewTool, capturePostIdeaTool, getPostDraftTool, getPostIdeaTool, getPublishedPostTool, listPostDraftIterationsTool, listPostDraftsTool, listPostIdeasTool, listPublishedPostsTool, markPostPublishedTool, renderLinkedInPostPreviewTool, saveHookResearchTool, savePostDraftTool, updatePostDraftTool, updatePublishedPostMetricsTool, } from "./tools/content-posts.js";
 import { getCampaignContext, hydrateCampaignContextFromCampaign, markCampaignContextDirty, } from "./tools/context.js";
 import { addToCommentCampaign, addToConnectionCampaign, addToInmailCampaign, getEngagedPosts, getOrCreateDirectCampaignTable, pauseDirectCampaign, startDirectCampaign, } from "./tools/direct-campaigns.js";
 import { bootstrapEngage, bootstrapEngageMulti, } from "./tools/engage-bootstrap.js";
@@ -244,6 +244,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "save_post_draft":
                 result = savePostDraftTool(args);
                 break;
+            case "calculate_linkedin_hook_preview":
+                result = calculateLinkedInHookPreviewTool(args);
+                break;
             case "render_linkedin_post_preview":
                 result = renderLinkedInPostPreviewTool(args);
                 break;

package/dist/tools/content-posts.d.ts

@@ -95,8 +95,15 @@ export declare const contentPostToolDefinitions: ({
             validationReceipt?: undefined;
             status?: undefined;
             postText?: undefined;
-            renderId?: undefined;
             sourceLabel?: undefined;
+            measurementMode?: undefined;
+            requireBrowserMeasurement?: undefined;
+            clampLines?: undefined;
+            mobileClampLines?: undefined;
+            desktopClampLines?: undefined;
+            mobileTextWidthPx?: undefined;
+            desktopTextWidthPx?: undefined;
+            renderId?: undefined;
             renderScreenshots?: undefined;
             requireScreenshots?: undefined;
             reviewClampLines?: undefined;
@@ -200,8 +207,15 @@ export declare const contentPostToolDefinitions: ({
             validationReceipt?: undefined;
             status?: undefined;
             postText?: undefined;
-            renderId?: undefined;
             sourceLabel?: undefined;
+            measurementMode?: undefined;
+            requireBrowserMeasurement?: undefined;
+            clampLines?: undefined;
+            mobileClampLines?: undefined;
+            desktopClampLines?: undefined;
+            mobileTextWidthPx?: undefined;
+            desktopTextWidthPx?: undefined;
+            renderId?: undefined;
             renderScreenshots?: undefined;
             requireScreenshots?: undefined;
             reviewClampLines?: undefined;
@@ -273,8 +287,15 @@ export declare const contentPostToolDefinitions: ({
             previewBudget?: undefined;
             notes?: undefined;
             postText?: undefined;
-            renderId?: undefined;
             sourceLabel?: undefined;
+            measurementMode?: undefined;
+            requireBrowserMeasurement?: undefined;
+            clampLines?: undefined;
+            mobileClampLines?: undefined;
+            desktopClampLines?: undefined;
+            mobileTextWidthPx?: undefined;
+            desktopTextWidthPx?: undefined;
+            renderId?: undefined;
             renderScreenshots?: undefined;
             requireScreenshots?: undefined;
             reviewClampLines?: undefined;
@@ -292,6 +313,91 @@ export declare const contentPostToolDefinitions: ({
         required: string[];
         additionalProperties: boolean;
     };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            postText: {
+                type: string;
+                description: string;
+            };
+            draftId: {
+                type: string;
+                description: string;
+            };
+            sourceLabel: {
+                type: string;
+            };
+            measurementMode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            requireBrowserMeasurement: {
+                type: string;
+                description: string;
+            };
+            clampLines: {
+                type: string;
+                description: string;
+            };
+            mobileClampLines: {
+                type: string;
+                description: string;
+            };
+            desktopClampLines: {
+                type: string;
+                description: string;
+            };
+            mobileTextWidthPx: {
+                type: string;
+                description: string;
+            };
+            desktopTextWidthPx: {
+                type: string;
+                description: string;
+            };
+            rawSource?: undefined;
+            title?: undefined;
+            distilledBrief?: undefined;
+            ideaId?: undefined;
+            sourceType?: undefined;
+            sourceUrl?: undefined;
+            capturedAt?: undefined;
+            researchId?: undefined;
+            topic?: undefined;
+            keywords?: undefined;
+            sourcePosts?: undefined;
+            selectedPatterns?: undefined;
+            previewBudget?: undefined;
+            notes?: undefined;
+            createdAt?: undefined;
+            hookResearchId?: undefined;
+            priorDraftId?: undefined;
+            iteration?: undefined;
+            body?: undefined;
+            validationReceipt?: undefined;
+            status?: undefined;
+            renderId?: undefined;
+            renderScreenshots?: undefined;
+            requireScreenshots?: undefined;
+            reviewClampLines?: undefined;
+            updatedAt?: undefined;
+            publishUrl?: undefined;
+            activityId?: undefined;
+            publishedAt?: undefined;
+            finalText?: undefined;
+            updateDraftStatus?: undefined;
+            publishedPostId?: undefined;
+            year?: undefined;
+            metrics?: undefined;
+            note?: undefined;
+        };
+        required: never[];
+        additionalProperties: boolean;
+    };
 } | {
     name: string;
     description: string;
@@ -348,6 +454,13 @@ export declare const contentPostToolDefinitions: ({
             body?: undefined;
             validationReceipt?: undefined;
             status?: undefined;
+            measurementMode?: undefined;
+            requireBrowserMeasurement?: undefined;
+            clampLines?: undefined;
+            mobileClampLines?: undefined;
+            desktopClampLines?: undefined;
+            mobileTextWidthPx?: undefined;
+            desktopTextWidthPx?: undefined;
             updatedAt?: undefined;
             publishUrl?: undefined;
             activityId?: undefined;
@@ -414,8 +527,15 @@ export declare const contentPostToolDefinitions: ({
             notes?: undefined;
             createdAt?: undefined;
             postText?: undefined;
-            renderId?: undefined;
             sourceLabel?: undefined;
+            measurementMode?: undefined;
+            requireBrowserMeasurement?: undefined;
+            clampLines?: undefined;
+            mobileClampLines?: undefined;
+            desktopClampLines?: undefined;
+            mobileTextWidthPx?: undefined;
+            desktopTextWidthPx?: undefined;
+            renderId?: undefined;
             renderScreenshots?: undefined;
             requireScreenshots?: undefined;
             reviewClampLines?: undefined;
@@ -482,8 +602,15 @@ export declare const contentPostToolDefinitions: ({
             validationReceipt?: undefined;
             status?: undefined;
             postText?: undefined;
-            renderId?: undefined;
             sourceLabel?: undefined;
+            measurementMode?: undefined;
+            requireBrowserMeasurement?: undefined;
+            clampLines?: undefined;
+            mobileClampLines?: undefined;
+            desktopClampLines?: undefined;
+            mobileTextWidthPx?: undefined;
+            desktopTextWidthPx?: undefined;
+            renderId?: undefined;
             renderScreenshots?: undefined;
             requireScreenshots?: undefined;
             reviewClampLines?: undefined;
@@ -540,8 +667,15 @@ export declare const contentPostToolDefinitions: ({
             validationReceipt?: undefined;
             status?: undefined;
             postText?: undefined;
-            renderId?: undefined;
             sourceLabel?: undefined;
+            measurementMode?: undefined;
+            requireBrowserMeasurement?: undefined;
+            clampLines?: undefined;
+            mobileClampLines?: undefined;
+            desktopClampLines?: undefined;
+            mobileTextWidthPx?: undefined;
+            desktopTextWidthPx?: undefined;
+            renderId?: undefined;
             renderScreenshots?: undefined;
             requireScreenshots?: undefined;
             reviewClampLines?: undefined;
@@ -639,6 +773,71 @@ export declare function savePostDraftTool(input: {
     updatedAt: string;
     preview: string;
 };
+type LinkedInHookPreviewSurface = {
+    label: "mobile" | "desktop";
+    textWidthPx: number;
+    fontSizePx: number;
+    lineHeightPx: number;
+    clampLines: number;
+    charGuardrail: number;
+    renderedLines: string[];
+    visibleLines: string[];
+    visibleTextBlock: string;
+    visibleTextBlockCharCount: number;
+    withinCharGuardrail: boolean;
+    lineCountBeforeClamp: number;
+    blankLinesBeforeClamp: number;
+    truncated: boolean;
+    seeMoreWouldShow: boolean;
+    hiddenTextStartsWith?: string;
+    measurementBasis: "local_chrome_browser_layout" | "estimated_width_model";
+    measurementWarning?: string;
+    chromePath?: string;
+};
+export declare function calculateLinkedInHookPreviewTool(input: {
+    postText?: string;
+    draftId?: string;
+    sourceLabel?: string;
+    measurementMode?: "browser" | "estimated";
+    requireBrowserMeasurement?: boolean;
+    clampLines?: number;
+    mobileClampLines?: number;
+    desktopClampLines?: number;
+    mobileTextWidthPx?: number;
+    desktopTextWidthPx?: number;
+}): {
+    basis: string;
+    ruleConfidence: string;
+    cssContractVersion: string;
+    sourceLabel: string | undefined;
+    draftId: string | undefined;
+    ruleSummary: string;
+    rules: {
+        visibleUnit: string;
+        defaultClampLines: number;
+        fontSizePx: number;
+        lineHeightPx: number;
+        whiteSpace: string;
+        overflowWrap: string;
+        desktopCharGuardrail: number;
+        mobileCharGuardrail: number;
+        characterCountsAreGuardrailsOnly: boolean;
+        notOfficialLinkedInApi: boolean;
+        strongestEvidence: string;
+    };
+    mobile: LinkedInHookPreviewSurface;
+    desktop: LinkedInHookPreviewSurface;
+    diagnostics: {
+        charCount: number;
+        charCountIncludingNewlines: number;
+        firstLineChars: number;
+        firstTwoPhysicalLinesChars: number;
+        physicalLineCount: number;
+        contentLineCount: number;
+        longestNonblankLineChars: number;
+        blankLineCount: number;
+    };
+};
 export declare function renderLinkedInPostPreviewTool(input: {
     postText?: string;
     draftId?: string;

package/dist/tools/content-posts.js

@@ -5,6 +5,24 @@ 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",
@@ -107,6 +125,55 @@ 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.",
@@ -429,16 +496,54 @@ 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 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");
+    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))
@@ -453,18 +558,18 @@ export function renderLinkedInPostPreviewTool(input) {
         label: "mobile",
         text: postText,
         baseDir,
-        textWidthPx: 308,
-        viewportWidthPx: 390,
-        viewportHeightPx: 760,
+        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: 582,
-        viewportWidthPx: 744,
-        viewportHeightPx: 760,
+        textWidthPx: LINKEDIN_PREVIEW_SURFACES.desktop.textWidthPx,
+        viewportWidthPx: LINKEDIN_PREVIEW_SURFACES.desktop.viewportWidthPx,
+        viewportHeightPx: LINKEDIN_PREVIEW_SURFACES.desktop.viewportHeightPx,
         reviewClampLines,
     });
     const combinedHtmlRelativePath = `${baseDir}/preview.html`;
@@ -491,7 +596,7 @@ export function renderLinkedInPostPreviewTool(input) {
         basis: screenshotResult.status === "rendered"
             ? "local_chrome_headless_screenshot"
             : "linkedin_css_contract_html",
-        cssContractVersion: "linkedin-preview-rendering/v1",
+        cssContractVersion: LINKEDIN_PREVIEW_CONTRACT_VERSION,
         generatedAt: now,
         sourceLabel: title,
         mobile: surfaceRecord(mobile),
@@ -760,6 +865,199 @@ 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`;
@@ -768,8 +1066,8 @@ function buildPreviewSurface(input) {
         textWidthPx: input.textWidthPx,
         viewportWidthPx: input.viewportWidthPx,
         viewportHeightPx: input.viewportHeightPx,
-        fontSizePx: 14,
-        lineHeightPx: 21,
+        fontSizePx: LINKEDIN_PREVIEW_FONT_SIZE_PX,
+        lineHeightPx: LINKEDIN_PREVIEW_LINE_HEIGHT_PX,
         reviewClampLines: input.reviewClampLines,
         estimatedLines,
         estimatedVisibleTextBlock: estimatedLines