@opencoredev/social-sdk 0.2.1 → 0.4.0

package/dist/platforms/linkedin.js

@@ -1,10 +1,41 @@
 import { remainingBudget } from "../transport/budget.js";
+import { definedFields } from "../core/fields.js";
 import { defineAdapter } from "../core/adapter.js";
 import { SocialError } from "../core/errors.js";
 import { createHttp, HttpError } from "../transport/http.js";
-import { array, object, string, optionalString, optionalNumber } from "../transport/validation.js";
+import { array, isJsonObject, object, string, optionalString, optionalNumber, } from "../transport/validation.js";
 import { upload } from "../transport/upload.js";
-import { publicFields } from "../cloud/common.js";
+import { optionsObject, publicFields } from "../cloud/common.js";
+import { verifyLinkedInWebhook } from "../server/webhooks.js";
+import { directWebhooks } from "./webhook-adapter.js";
+/** Documents API file types (PDF, PPT, PPTX, DOC, DOCX), checked 2026-09-24 against version 202609. */
+const linkedInDocumentMimeTypes = [
+    "application/pdf",
+    "application/vnd.ms-powerpoint",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    "application/msword",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+];
+/** LinkedIn documents "100MB"; the decimal reading is the conservative local bound. */
+const linkedInDocumentMaxBytes = 100_000_000;
+const linkedInDocumentUrn = /^urn:li:document:[a-zA-Z0-9_-]+$/;
+/*
+ * Videos API, accessed 2026-09-24:
+ * https://learn.microsoft.com/en-us/linkedin/marketing/community-management/shares/videos-api?view=li-lms-2026-09
+ * Feed video is MP4, 75 KB to 500 MB and 3 seconds to 30 minutes. initializeUpload returns
+ * contiguous part instructions of up to 4,194,304 bytes; each part's ETag is passed to finalizeUpload.
+ * Posts API video content, accessed 2026-09-24:
+ * https://learn.microsoft.com/en-us/linkedin/marketing/community-management/shares/posts-api?view=li-lms-2026-09
+ */
+const linkedInVideoPartBytes = 4 * 1024 * 1024;
+const linkedInVideoMinBytes = 75_000;
+const linkedInVideoMaxBytes = 500 * 1024 * 1024;
+const linkedInVideoUrn = /^urn:li:video:[a-zA-Z0-9_-]+$/;
+const linkedInImageUrn = /^urn:li:image:[a-zA-Z0-9_-]+$/;
+/* LinkedIn documents no processing time or polling interval; these bounds are the SDK's own. */
+const linkedInVideoRetryDelayMs = 5_000;
+const linkedInVideoWaitDefaults = { intervalMs: 5_000, maxChecks: 12 };
+const linkedInVideoWaitLimits = { minIntervalMs: 1_000, maxIntervalMs: 60_000, maxChecks: 60 };
 export function linkedin(options) {
     if (!options.auth.accessToken.trim() ||
         !/^urn:li:(person|organization):[a-zA-Z0-9_-]+$/.test(options.auth.author) ||
@@ -33,20 +64,21 @@ export function linkedin(options) {
             return await http({
                 timeoutMs: remainingBudget(context),
                 url: new URL(`https://api.linkedin.com${path}`),
-                headers: {
-                    Authorization: `Bearer ${options.auth.accessToken}`,
-                    "Content-Type": "application/json",
-                    "Linkedin-Version": options.apiVersion,
-                    "X-Restli-Protocol-Version": "2.0.0",
-                    ...extraHeaders,
-                },
+                headers: path.startsWith("/v2/")
+                    ? { Authorization: `Bearer ${options.auth.accessToken}` }
+                    : {
+                        Authorization: `Bearer ${options.auth.accessToken}`,
+                        "Content-Type": "application/json",
+                        "Linkedin-Version": options.apiVersion,
+                        "X-Restli-Protocol-Version": "2.0.0",
+                        ...extraHeaders,
+                    },
                 method,
-                // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-                ...(body === undefined ? {} : { body: JSON.stringify(body) }),
-                // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-                ...(context.signal ? { signal: context.signal } : {}),
-                // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-                ...(selectedHeaders ? { responseHeaders: selectedHeaders } : {}),
+                ...definedFields({
+                    body: body === undefined ? undefined : JSON.stringify(body),
+                    signal: context.signal,
+                    responseHeaders: selectedHeaders,
+                }),
                 maxAttempts: method === "GET" ? Math.min(5, context.retryBudget.maxAttempts) : 1,
             });
         }
@@ -105,6 +137,119 @@ export function linkedin(options) {
             });
         return result;
     }
+    /*
+     * Account identity sources (accessed 2026-09-24):
+     * - Member: OpenID Connect userinfo, GET https://api.linkedin.com/v2/userinfo, scopes `openid` and
+     *   `profile`. `sub` is the member ID used in `urn:li:person:{sub}`.
+     *   https://learn.microsoft.com/en-us/linkedin/consumer/integrations/self-serve/sign-in-with-linkedin-v2
+     *   https://learn.microsoft.com/en-us/linkedin/consumer/integrations/self-serve/share-on-linkedin
+     * - Organization: GET /rest/organizations/{id} ("Retrieve an Administered Organization"), scope
+     *   `rw_organization_admin`, 403 unless the member has the ADMINISTRATOR role.
+     *   https://learn.microsoft.com/en-us/linkedin/marketing/community-management/organizations/organization-lookup-api?view=li-lms-2026-09
+     * - Administered organizations: GET /rest/organizationAcls?q=roleAssignee, scope
+     *   `rw_organization_admin` or `r_organization_admin`.
+     *   https://learn.microsoft.com/en-us/linkedin/marketing/community-management/organizations/organization-access-control-by-role?view=li-lms-2026-09
+     */
+    async function accountRequest(path, context, scopes) {
+        try {
+            return await request(path, context);
+        }
+        catch (error) {
+            if (error instanceof SocialError && error.code === "missing_permission")
+                throw new SocialError({
+                    code: "missing_permission",
+                    operation: "accounts.read",
+                    message: `LinkedIn denied the account read. The token needs ${scopes}.`,
+                    upstreamStatus: error.upstreamStatus,
+                    retryDisposition: { kind: "never" },
+                });
+            throw error;
+        }
+    }
+    async function readAccount(context) {
+        const ref = {
+            kind: "connected-account",
+            version: 1,
+            backend: context.backendInstance,
+            platform: "linkedin",
+            accountId: options.auth.author,
+        };
+        if (options.auth.author.startsWith("urn:li:person:")) {
+            const user = object(await accountRequest("/v2/userinfo", context, "the openid and profile scopes (Sign In with LinkedIn using OpenID Connect)"));
+            const sub = optionalString(user["sub"]);
+            if (sub === undefined || `urn:li:person:${sub}` !== options.auth.author)
+                throw new SocialError({
+                    code: "unauthorized",
+                    operation: "accounts.read",
+                    message: "The authenticated LinkedIn member differs from the configured author URN.",
+                });
+            const fullName = optionalString(user["name"]) ??
+                [optionalString(user["given_name"]), optionalString(user["family_name"])]
+                    .filter((part) => part !== undefined && part !== "")
+                    .join(" ");
+            return { ref, displayName: fullName || options.auth.author, status: "connected" };
+        }
+        const organizationId = options.auth.author.slice("urn:li:organization:".length);
+        const organization = object(await accountRequest(`/rest/organizations/${encodeURIComponent(organizationId)}`, context, "rw_organization_admin and an approved ADMINISTRATOR role for the organization"));
+        const returnedId = optionalNumber(organization["id"]);
+        if (returnedId === undefined || String(returnedId) !== organizationId)
+            throw new SocialError({
+                code: "unauthorized",
+                operation: "accounts.read",
+                message: "LinkedIn returned a different organization than the configured author URN.",
+            });
+        const vanityName = optionalString(organization["vanityName"]);
+        return Object.assign({
+            ref,
+            displayName: optionalString(organization["localizedName"]) || options.auth.author,
+            status: "connected",
+        }, vanityName === undefined ? {} : { handle: vanityName });
+    }
+    async function listAdministeredOrganizations(input, context) {
+        const start = input.cursor === undefined ? 0 : Number(input.cursor);
+        const count = input.limit ?? 25;
+        if (input.cursor === "" ||
+            !Number.isSafeInteger(start) ||
+            start < 0 ||
+            !Number.isSafeInteger(count) ||
+            count < 1 ||
+            count > 100)
+            throw new SocialError({
+                code: "invalid_input",
+                operation: "accounts.read",
+                message: "LinkedIn requires a nonnegative offset and page size from 1 to 100.",
+            });
+        const memberUrn = options.auth.author;
+        if (!memberUrn.startsWith("urn:li:person:"))
+            throw new SocialError({
+                code: "unauthorized",
+                operation: "accounts.read",
+                message: "LinkedIn administered organization lookup requires a member account authorization.",
+            });
+        const result = object(await accountRequest(`/rest/organizationAcls?q=roleAssignee&roleAssignee=${encodeURIComponent(memberUrn)}&role=ADMINISTRATOR&state=APPROVED&start=${start}&count=${count}`, context, "rw_organization_admin or r_organization_admin"));
+        const rows = array(result["elements"]).map(object);
+        const items = [];
+        for (const row of rows) {
+            // LinkedIn documents both `organization` and `organizationTarget` for this field.
+            const organization = optionalString(row["organization"]) ?? optionalString(row["organizationTarget"]);
+            if (organization === undefined ||
+                !/^urn:li:organization:[0-9]+$/.test(organization) ||
+                row["role"] !== "ADMINISTRATOR" ||
+                row["state"] !== "APPROVED")
+                continue;
+            items.push({
+                organization: `urn:li:organization:${organization.slice("urn:li:organization:".length)}`,
+                role: "ADMINISTRATOR",
+                state: "APPROVED",
+            });
+        }
+        const paging = result["paging"] === undefined ? {} : object(result["paging"]);
+        const total = optionalNumber(paging["total"]);
+        const hasNext = array(paging["links"] ?? []).some((link) => object(link)["rel"] === "next");
+        return Object.assign({ items }, rows.length > 0 && (hasNext || (total !== undefined && start + rows.length < total))
+            ? { nextCursor: String(start + rows.length) }
+            : {});
+    }
     async function uploadImage(media, account, context) {
         authorize(account, context);
         const source = media.source;
@@ -131,16 +276,12 @@ export function linkedin(options) {
             url: string(initialized["uploadUrl"]),
             source: {
                 mimeType: media.mimeType,
-                // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-                ...(size === undefined ? {} : { size }),
+                ...definedFields({ size }),
                 open: source.kind === "blob" ? () => source.blob.stream() : source.open,
             },
             allowHost: (host) => host === "www.linkedin.com",
             maxBytes: 20 * 1024 * 1024,
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-            ...(options.fetch ? { fetch: options.fetch } : {}),
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-            ...(context.signal ? { signal: context.signal } : {}),
+            ...definedFields({ fetch: options.fetch, signal: context.signal }),
         });
         return {
             kind: "media",
@@ -151,7 +292,389 @@ export function linkedin(options) {
             mediaId,
         };
     }
-    /* oxlint-disable anti-slop/no-unknown-parameters, anti-slop/no-unsafe-dictionary-type, anti-slop/no-known-value-widening, anti-slop/no-conditional-empty-object-spread, anti-slop/no-runtime-typeof, anti-slop/require-readable-spacing -- These helpers normalize documented LinkedIn response facets at the transport boundary. */
+    function videoPartError(error, part) {
+        if (error.kind === "cancelled")
+            return new SocialError({
+                code: "cancelled",
+                operation: "media.upload",
+                message: `LinkedIn video part ${part} upload was cancelled. No post was created.`,
+            });
+        if (error.kind === "timeout")
+            return new SocialError({
+                code: "timeout",
+                operation: "media.upload",
+                message: `LinkedIn video part ${part} upload exceeded its elapsed budget. No post was created.`,
+                retryDisposition: { kind: "never" },
+            });
+        if (error.status === 429)
+            return new SocialError({
+                code: "rate_limited",
+                operation: "media.upload",
+                message: `LinkedIn rate limited video part ${part}. No post was created.`,
+                upstreamStatus: error.status,
+                retryDisposition: error.retryAfterMs === undefined
+                    ? { kind: "never" }
+                    : { kind: "after-delay", delayMs: error.retryAfterMs },
+            });
+        return new SocialError({
+            code: "media_error",
+            operation: "media.upload",
+            message: error.status === 401
+                ? `LinkedIn rejected video part ${part} because its upload URL expired. Start a new upload.`
+                : `LinkedIn did not accept video part ${part}. Start a new upload; no post was created.`,
+            upstreamStatus: error.status,
+            retryDisposition: { kind: "never" },
+        });
+    }
+    /** Reads one video's public status fields with a single GET after checking the grant and owner. */
+    async function readVideoStatus(ref, context) {
+        authorize(ref, context);
+        if (!linkedInVideoUrn.test(ref.mediaId))
+            throw new SocialError({
+                code: "invalid_input",
+                operation: "media.read",
+                message: "Use the urn:li:video reference returned by media.upload.",
+            });
+        const video = object(await request(`/rest/videos/${encodeURIComponent(ref.mediaId)}`, context));
+        if (video["owner"] !== ref.accountId)
+            throw new SocialError({
+                code: "unauthorized",
+                operation: "media.read",
+                message: "LinkedIn video belongs to another author.",
+            });
+        if (video["id"] !== undefined && video["id"] !== ref.mediaId)
+            throw new SocialError({
+                code: "media_error",
+                operation: "media.read",
+                message: "LinkedIn returned the status of a different video.",
+            });
+        return publicFields(video, ["id", "owner", "status", "processingFailureReason", "duration"]);
+    }
+    function videoWaitCancelled() {
+        return new SocialError({
+            code: "cancelled",
+            operation: "media.read",
+            message: "Waiting for the LinkedIn video was cancelled. No post was created.",
+        });
+    }
+    /** Remaining elapsed budget in milliseconds, or 0 once it is exhausted. */
+    function budgetLeft(context) {
+        try {
+            return remainingBudget(context);
+        }
+        catch {
+            return 0;
+        }
+    }
+    /** Sleeps between explicit waitForVideo reads and rejects as soon as the context aborts. */
+    function videoWaitDelay(milliseconds, context) {
+        if (context.signal?.aborted)
+            return Promise.reject(videoWaitCancelled());
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                clearTimeout(timer);
+                reject(videoWaitCancelled());
+            };
+            const timer = setTimeout(() => {
+                context.signal?.removeEventListener("abort", onAbort);
+                resolve();
+            }, milliseconds);
+            context.signal?.addEventListener("abort", onAbort, { once: true });
+        });
+    }
+    /** Initializes, uploads every part and finalizes one video. It never waits for processing. */
+    async function uploadVideo(media, account, context) {
+        authorize(account, context);
+        const source = media.source;
+        if (media.mimeType !== "video/mp4" || source.kind !== "blob")
+            throw new SocialError({
+                code: "invalid_input",
+                operation: "media.upload",
+                message: "Provide one MP4 video as a Blob with mimeType video/mp4.",
+            });
+        if (media.thumbnail !== undefined)
+            throw new SocialError({
+                code: "invalid_input",
+                operation: "media.upload",
+                message: "LinkedIn video thumbnails are not implemented by this adapter.",
+            });
+        const blob = source.blob;
+        if ((media.byteSize !== undefined && media.byteSize !== blob.size) ||
+            blob.size < linkedInVideoMinBytes ||
+            blob.size > linkedInVideoMaxBytes)
+            throw new SocialError({
+                code: "invalid_input",
+                operation: "media.upload",
+                message: "LinkedIn feed video must be 75 KB to 500 MB, and byteSize must match the Blob size.",
+            });
+        if (media.durationSeconds !== undefined &&
+            (!Number.isFinite(media.durationSeconds) ||
+                media.durationSeconds < 3 ||
+                media.durationSeconds > 1800))
+            throw new SocialError({
+                code: "invalid_input",
+                operation: "media.upload",
+                message: "LinkedIn feed video must be 3 seconds to 30 minutes long.",
+            });
+        try {
+            const initialized = object(object(await request("/rest/videos?action=initializeUpload", context, {
+                initializeUploadRequest: {
+                    owner: account.accountId,
+                    fileSizeBytes: blob.size,
+                    uploadCaptions: false,
+                    uploadThumbnail: false,
+                },
+            }))["value"]);
+            const mediaId = string(initialized["video"]);
+            // LinkedIn documents an empty upload token for some sessions, so only its type is checked.
+            const uploadToken = optionalString(initialized["uploadToken"]);
+            const parts = array(initialized["uploadInstructions"]).map((value) => {
+                const part = object(value);
+                return {
+                    url: string(part["uploadUrl"]),
+                    firstByte: optionalNumber(part["firstByte"]),
+                    lastByte: optionalNumber(part["lastByte"]),
+                };
+            });
+            let nextByte = 0;
+            const plan = [];
+            for (const part of parts) {
+                const { firstByte, lastByte } = part;
+                if (firstByte !== nextByte ||
+                    lastByte === undefined ||
+                    !Number.isSafeInteger(lastByte) ||
+                    lastByte < firstByte ||
+                    lastByte - firstByte + 1 > linkedInVideoPartBytes)
+                    break;
+                plan.push({ url: part.url, firstByte, lastByte });
+                nextByte = lastByte + 1;
+            }
+            if (!linkedInVideoUrn.test(mediaId) ||
+                uploadToken === undefined ||
+                plan.length === 0 ||
+                plan.length !== parts.length ||
+                nextByte !== blob.size)
+                throw new SocialError({
+                    code: "media_error",
+                    operation: "media.upload",
+                    message: "LinkedIn returned an invalid video identifier or an upload plan that does not cover the file. No bytes were sent.",
+                    retryDisposition: { kind: "never" },
+                });
+            const uploadedPartIds = [];
+            for (const [index, part] of plan.entries()) {
+                const body = blob.slice(part.firstByte, part.lastByte + 1);
+                let result;
+                try {
+                    // fetch sends the Blob slice directly; the declared size lets upload() check every byte.
+                    result = await upload({
+                        url: part.url,
+                        source: {
+                            mimeType: "application/octet-stream",
+                            size: body.size,
+                            body,
+                            open: () => body.stream(),
+                        },
+                        allowHost: (host) => host === "www.linkedin.com",
+                        maxBytes: linkedInVideoPartBytes,
+                        timeoutMs: remainingBudget(context),
+                        ...definedFields({ fetch: options.fetch, signal: context.signal }),
+                    });
+                }
+                catch (error) {
+                    if (error instanceof HttpError)
+                        throw videoPartError(error, index + 1);
+                    throw error;
+                }
+                // finalizeUpload takes the ETag value without the HTTP quoting.
+                const etag = result.etag?.trim().replace(/^"(.*)"$/, "$1");
+                if (!etag)
+                    throw new SocialError({
+                        code: "media_error",
+                        operation: "media.upload",
+                        message: `LinkedIn accepted video part ${index + 1} without an ETag. Start a new upload.`,
+                        retryDisposition: { kind: "never" },
+                    });
+                uploadedPartIds.push(etag);
+            }
+            await request("/rest/videos?action=finalizeUpload", context, {
+                finalizeUploadRequest: { video: mediaId, uploadToken, uploadedPartIds },
+            });
+            return {
+                kind: "media",
+                version: 1,
+                backend: account.backend,
+                platform: "linkedin",
+                accountId: account.accountId,
+                mediaId,
+            };
+        }
+        catch (error) {
+            // Malformed upload responses fail before any post request, so no post exists.
+            if (error instanceof HttpError)
+                throw new SocialError({
+                    code: "media_error",
+                    operation: "media.upload",
+                    message: "LinkedIn returned a malformed video upload response. No post was created.",
+                    retryDisposition: { kind: "never" },
+                });
+            throw error;
+        }
+    }
+    async function uploadDocument(media, account, context) {
+        authorize(account, context);
+        const source = media.source;
+        const size = source.kind === "blob" ? source.blob.size : media.byteSize;
+        const mimeType = media.mimeType ?? "";
+        if (media.kind !== "document" ||
+            !linkedInDocumentMimeTypes.includes(mimeType) ||
+            (source.kind !== "blob" && source.kind !== "stream"))
+            throw new SocialError({
+                code: "invalid_input",
+                operation: "media.upload",
+                message: "Provide PDF, PPT, PPTX, DOC or DOCX bytes as a Blob or replayable stream.",
+            });
+        if ((source.kind === "blob" && media.byteSize !== undefined && media.byteSize !== size) ||
+            (size !== undefined &&
+                (!Number.isSafeInteger(size) || size <= 0 || size > linkedInDocumentMaxBytes)))
+            throw new SocialError({
+                code: "invalid_input",
+                operation: "media.upload",
+                message: "LinkedIn documents must be non-empty and at most 100 MB, and byteSize must match the Blob size.",
+            });
+        const initialized = object(object(await request("/rest/documents?action=initializeUpload", context, {
+            initializeUploadRequest: { owner: account.accountId },
+        }))["value"]);
+        const mediaId = string(initialized["document"]);
+        if (!linkedInDocumentUrn.test(mediaId))
+            throw new SocialError({
+                code: "media_error",
+                operation: "media.upload",
+                message: "LinkedIn returned an invalid document identifier.",
+            });
+        let transferred;
+        try {
+            ({ bytes: transferred } = await upload({
+                url: string(initialized["uploadUrl"]),
+                source: {
+                    mimeType,
+                    ...definedFields({ size }),
+                    open: source.kind === "blob" ? () => source.blob.stream() : source.open,
+                },
+                allowHost: (host) => host === "www.linkedin.com",
+                maxBytes: linkedInDocumentMaxBytes,
+                timeoutMs: remainingBudget(context),
+                ...definedFields({ fetch: options.fetch, signal: context.signal }),
+            }));
+        }
+        catch (error) {
+            if (!(error instanceof HttpError))
+                throw error;
+            throw new SocialError({
+                code: error.kind === "timeout"
+                    ? "timeout"
+                    : error.kind === "cancelled"
+                        ? "cancelled"
+                        : error.kind === "invalid-input"
+                            ? "invalid_input"
+                            : "media_error",
+                operation: "media.upload",
+                message: `LinkedIn document upload for ${mediaId} did not complete: ${error.message}`,
+                upstreamStatus: error.status,
+                retryDisposition: { kind: "never" },
+            });
+        }
+        // A stream without byteSize can end empty; LinkedIn cannot publish an empty document.
+        if (transferred === 0)
+            throw new SocialError({
+                code: "invalid_input",
+                operation: "media.upload",
+                message: `LinkedIn document upload for ${mediaId} sent no bytes. Provide a non-empty document.`,
+                retryDisposition: { kind: "never" },
+            });
+        return {
+            kind: "media",
+            version: 1,
+            backend: account.backend,
+            platform: "linkedin",
+            accountId: account.accountId,
+            mediaId,
+        };
+    }
+    async function readDocument(ref, context, operation) {
+        authorize(ref, context);
+        if (!linkedInDocumentUrn.test(ref.mediaId))
+            throw new SocialError({
+                code: "invalid_input",
+                operation,
+                message: "Use the urn:li:document reference returned by media.upload.",
+            });
+        const document = object(await request(`/rest/documents/${encodeURIComponent(ref.mediaId)}`, context));
+        if (document["owner"] !== ref.accountId ||
+            (document["id"] !== undefined && document["id"] !== ref.mediaId))
+            throw new SocialError({
+                code: "unauthorized",
+                operation,
+                message: "LinkedIn document belongs to another author.",
+            });
+        return document;
+    }
+    /** The Posts API requires a title for documents; take it from caption, then filename. */
+    const documentTitle = (media) => media.caption?.trim() || media.filename?.trim() || "";
+    const documentIssues = (target) => {
+        const media = target.content.media ?? [];
+        if (!media.some((item) => item.kind === "document"))
+            return [];
+        const issues = [];
+        if (media.length !== 1)
+            issues.push([
+                "linkedin.document_count",
+                "A LinkedIn document post carries exactly one document and no other media.",
+            ]);
+        for (const item of media) {
+            if (item.kind !== "document")
+                continue;
+            if (item.source.kind !== "media-ref")
+                issues.push([
+                    "linkedin.document",
+                    "Upload the document first with media.upload, then publish its account-bound reference.",
+                ]);
+            else if (item.source.ref.backend !== target.account.backend ||
+                item.source.ref.accountId !== target.account.accountId ||
+                item.source.ref.platform !== "linkedin" ||
+                !linkedInDocumentUrn.test(item.source.ref.mediaId))
+                issues.push([
+                    "linkedin.media_owner",
+                    "Document reference belongs to another author/backend or has an invalid URN.",
+                ]);
+            if (!documentTitle(item))
+                issues.push([
+                    "linkedin.document_title",
+                    "LinkedIn requires a document title. Set caption or filename on the attachment.",
+                ]);
+            if (item.altText !== undefined)
+                issues.push([
+                    "linkedin.document_alt_text",
+                    "LinkedIn documents have no verified alt text mapping. Remove altText.",
+                ]);
+        }
+        return issues;
+    };
+    async function documentContent(media, context) {
+        if (media.source.kind !== "media-ref")
+            throw new SocialError({
+                code: "invalid_input",
+                operation: "posts.publish",
+                message: "Upload the document first with media.upload.",
+            });
+        const document = await readDocument(media.source.ref, context, "posts.publish");
+        if (document["status"] !== "AVAILABLE")
+            throw new SocialError({
+                code: "media_error",
+                operation: "posts.publish",
+                message: "Document is not AVAILABLE. Check its status with the native documentStatus helper, then publish again with a new idempotency key.",
+            });
+        return { media: { id: media.source.ref.mediaId, title: documentTitle(media) } };
+    }
     const organizationOnly = (account, context, operation) => {
         authorize(account, context);
         if (!account.accountId.startsWith("urn:li:organization:"))
@@ -213,8 +736,8 @@ export function linkedin(options) {
             const number = optionalNumber(item);
             if (number !== undefined)
                 output[key] = number;
-            else if (item !== null && typeof item === "object" && !Array.isArray(item)) {
-                const nestedObject = object(item);
+            else if (isJsonObject(item)) {
+                const nestedObject = item;
                 const nested = ["pageViews", "uniquePageViews", "clicks", "count"]
                     .map((name) => optionalNumber(nestedObject[name]))
                     .find((candidate) => candidate !== undefined);
@@ -254,12 +777,10 @@ export function linkedin(options) {
                 output.push({
                     dimension,
                     value: label,
-                    ...(optionalNumber(counts["organicFollowerCount"]) === undefined
-                        ? {}
-                        : { organicFollowerCount: optionalNumber(counts["organicFollowerCount"]) }),
-                    ...(optionalNumber(counts["paidFollowerCount"]) === undefined
-                        ? {}
-                        : { paidFollowerCount: optionalNumber(counts["paidFollowerCount"]) }),
+                    ...definedFields({
+                        organicFollowerCount: optionalNumber(counts["organicFollowerCount"]),
+                        paidFollowerCount: optionalNumber(counts["paidFollowerCount"]),
+                    }),
                 });
             }
         }
@@ -275,26 +796,18 @@ export function linkedin(options) {
         if ((granularity !== "DAY" && granularity !== "WEEK" && granularity !== "MONTH") ||
             (start === undefined && end === undefined))
             return undefined;
-        return {
-            granularity,
-            ...(start === undefined ? {} : { start }),
-            ...(end === undefined ? {} : { end }),
-        };
+        return { granularity, ...definedFields({ start, end }) };
     };
     const parseFollowerStatistics = (result, requestedGranularity) => array(result["elements"]).map((value) => {
         const row = object(value);
         const gains = row["followerGains"] === undefined ? {} : object(row["followerGains"]);
         return {
             organization: string(row["organizationalEntity"]),
-            ...(parseInterval(row, requestedGranularity) === undefined
-                ? {}
-                : { interval: parseInterval(row, requestedGranularity) }),
-            ...(optionalNumber(gains["organicFollowerGain"]) === undefined
-                ? {}
-                : { organicFollowerGain: optionalNumber(gains["organicFollowerGain"]) }),
-            ...(optionalNumber(gains["paidFollowerGain"]) === undefined
-                ? {}
-                : { paidFollowerGain: optionalNumber(gains["paidFollowerGain"]) }),
+            ...definedFields({
+                interval: parseInterval(row, requestedGranularity),
+                organicFollowerGain: optionalNumber(gains["organicFollowerGain"]),
+                paidFollowerGain: optionalNumber(gains["paidFollowerGain"]),
+            }),
             breakdowns: followerBreakdowns(row),
         };
     });
@@ -334,9 +847,7 @@ export function linkedin(options) {
         const total = row["totalPageStatistics"] === undefined ? {} : object(row["totalPageStatistics"]);
         return {
             organization: string(row["organization"]),
-            ...(parseInterval(row, requestedGranularity) === undefined
-                ? {}
-                : { interval: parseInterval(row, requestedGranularity) }),
+            ...definedFields({ interval: parseInterval(row, requestedGranularity) }),
             views: numberMap(total["views"]),
             clicks: numberMap(total["clicks"]),
             breakdowns: pageBreakdowns(row),
@@ -346,13 +857,10 @@ export function linkedin(options) {
         const row = object(value);
         return {
             organization: string(row["organizationalEntity"]),
-            ...(parseInterval(row, requestedGranularity) === undefined
-                ? {}
-                : { interval: parseInterval(row, requestedGranularity) }),
+            ...definedFields({ interval: parseInterval(row, requestedGranularity) }),
             metrics: numberMap(row["totalShareStatistics"]),
         };
     });
-    /* oxlint-enable anti-slop/no-unknown-parameters, anti-slop/no-unsafe-dictionary-type, anti-slop/no-known-value-widening, anti-slop/no-conditional-empty-object-spread, anti-slop/no-runtime-typeof */
     return defineAdapter({
         id: "linkedin",
         capabilities: {
@@ -365,13 +873,25 @@ export function linkedin(options) {
                     platform: "linkedin",
                     operation: "posts.publish",
                     availability: "available",
-                    formats: ["text", "image"],
+                    formats: [
+                        "text",
+                        "image",
+                        "carousel",
+                        "video",
+                        "document",
+                    ],
                     requiredScopes: [
                         options.auth.author.startsWith("urn:li:organization:")
                             ? "w_organization_social"
                             : "w_member_social",
                     ],
-                    notes: "Explicit author URN and public visibility. Organization role and app product approval required. Registered images must be AVAILABLE before creating a post.",
+                    notes: "Explicit author URN and public visibility. Organization role and app product approval required. One registered image, 2 to 20 images, one MP4 video, or one document per post; every asset must be AVAILABLE before creating a post.",
+                },
+                {
+                    platform: "linkedin",
+                    operation: "posts.schedule",
+                    availability: "unsupported-by-platform",
+                    notes: "The Posts API accepts only lifecycleState PUBLISHED on creation and has no publish-time field.",
                 },
                 {
                     platform: "linkedin",
@@ -384,22 +904,52 @@ export function linkedin(options) {
                     ],
                     notes: "Member read access is restricted. Publication permission does not grant read permission.",
                 },
+                {
+                    platform: "linkedin",
+                    operation: "accounts.read",
+                    availability: "available",
+                    requiredScopes: options.auth.author.startsWith("urn:li:organization:")
+                        ? ["rw_organization_admin"]
+                        : ["openid", "profile"],
+                    notes: options.auth.author.startsWith("urn:li:organization:")
+                        ? "Returns the configured organization only. Reads /rest/organizations/{id}, which LinkedIn restricts to members with an approved ADMINISTRATOR role."
+                        : "Returns the configured member only. Reads the OpenID Connect userinfo endpoint and checks that sub matches the author URN. Requires the Sign In with LinkedIn using OpenID Connect product.",
+                },
                 {
                     platform: "linkedin",
                     operation: "posts.multi-image",
-                    availability: "not-implemented-by-adapter",
+                    availability: "available",
                     formats: ["carousel"],
+                    requiredScopes: [
+                        options.auth.author.startsWith("urn:li:organization:")
+                            ? "w_organization_social"
+                            : "w_member_social",
+                    ],
+                    notes: "Publishes 2 to 20 registered images through posts.publish as organic MultiImage content. Every image must be owned by the author and AVAILABLE. Sponsored multi-image posts are not supported.",
                 },
                 {
                     platform: "linkedin",
                     operation: "posts.video",
-                    availability: "not-implemented-by-adapter",
+                    availability: "available",
                     formats: ["video"],
+                    requiredScopes: [
+                        options.auth.author.startsWith("urn:li:organization:")
+                            ? "w_organization_social"
+                            : "w_member_social",
+                    ],
+                    notes: "Upload one MP4 Blob (75 KB to 500 MB, 3 seconds to 30 minutes) with media.upload, then publish the video URN once it is AVAILABLE. Check processing with native videoStatus (one read) or the opt-in native waitForVideo (bounded reads within the operation budget). Publishing reads the status once and never waits; a processing video fails with no post created. The attachment caption becomes the optional video title.",
                 },
                 {
                     platform: "linkedin",
                     operation: "posts.document",
-                    availability: "not-implemented-by-adapter",
+                    availability: "available",
+                    formats: ["document"],
+                    requiredScopes: [
+                        options.auth.author.startsWith("urn:li:organization:")
+                            ? "w_organization_social"
+                            : "w_member_social",
+                    ],
+                    notes: "One PDF, PPT, PPTX, DOC or DOCX file up to 100 MB and 300 pages, uploaded through the Documents API. LinkedIn enforces the page limit during processing. Requires a title and AVAILABLE status.",
                 },
                 { platform: "linkedin", operation: "polls.create", availability: "available" },
                 { platform: "linkedin", operation: "reactions.write", availability: "available" },
@@ -411,6 +961,17 @@ export function linkedin(options) {
                     operation: "posts.removeFromPlatform",
                     availability: "available",
                 },
+                {
+                    platform: "linkedin",
+                    operation: "comments.delete",
+                    availability: "available",
+                    requiredScopes: [
+                        options.auth.author.startsWith("urn:li:organization:")
+                            ? "w_organization_social"
+                            : "w_member_social",
+                    ],
+                    notes: "Native deleteComment needs the post URN and the complete commentUrn. LinkedIn does not document which comments an actor may delete; expect only the configured author's own comments to succeed.",
+                },
                 {
                     platform: "linkedin",
                     operation: "analytics.organization.read",
@@ -425,11 +986,39 @@ export function linkedin(options) {
                     operation: "articles.create",
                     availability: "approval-dependent",
                 },
+                {
+                    platform: "linkedin",
+                    operation: "profile.update",
+                    availability: "approval-dependent",
+                    notes: "Member profile writes use the Profile Edit API, which LinkedIn restricts to approved developers. This adapter does not implement it.",
+                },
                 {
                     platform: "linkedin",
                     operation: "messages.write",
                     availability: "unsupported-by-platform",
                 },
+                {
+                    platform: "linkedin",
+                    operation: "webhooks.verify",
+                    availability: "approval-dependent",
+                    requiredScopes: ["rw_organization_admin"],
+                    notes: "LinkedIn enables webhooks only for apps with an approved webhook use case. Organization social action notifications also need the Community Management API and an organization administrator. Verifies X-LI-Signature (HMAC-SHA256 over hmacsha256= plus the raw body) with the app client secret; answer the GET validation with answerLinkedInWebhookChallenge.",
+                },
+                {
+                    platform: "linkedin",
+                    operation: "notifications.read",
+                    availability: options.auth.author.startsWith("urn:li:organization:")
+                        ? "available"
+                        : "account-ineligible",
+                    requiredScopes: ["rw_organization_admin"],
+                    notes: "Organization social-action notifications from the last 60 days, pulled with offset paging. Requires the Community Management API product and organization administrator access. LinkedIn has no member notification API.",
+                },
+                {
+                    platform: "linkedin",
+                    operation: "notifications.seen",
+                    availability: "unsupported-by-platform",
+                    notes: "LinkedIn does not expose a seen or read state for notifications.",
+                },
                 {
                     platform: "linkedin",
                     operation: "analytics.account.read",
@@ -463,7 +1052,7 @@ export function linkedin(options) {
                     platform: "linkedin",
                     operation: "media.upload",
                     availability: "available",
-                    formats: ["image"],
+                    formats: ["image", "video", "document"],
                 },
                 ...["comments.read", "comments.write", "analytics.read"].map((operation) => ({
                     platform: "linkedin",
@@ -476,7 +1065,22 @@ export function linkedin(options) {
                 })),
             ],
         },
-        media: { upload: uploadImage },
+        accounts: {
+            async list(_input, context) {
+                return { items: [await readAccount(context)] };
+            },
+            async get(ref, context) {
+                authorize(ref, context);
+                return readAccount(context);
+            },
+        },
+        media: {
+            upload: (media, account, context) => media.kind === "video"
+                ? uploadVideo(media, account, context)
+                : media.kind === "document"
+                    ? uploadDocument(media, account, context)
+                    : uploadImage(media, account, context),
+        },
         posts: {
             prepareTarget(target) {
                 const issues = [];
@@ -488,39 +1092,54 @@ export function linkedin(options) {
                     fail("linkedin.text", "LinkedIn commentary exceeds 3,000 characters.");
                 if (target.schedule || target.replyTo || target.content.link)
                     fail("linkedin.operation", "Scheduling, reply posts and structured links are not supported by this publishing slice.");
-                if (target.options !== undefined) {
-                    const settings = object(target.options);
-                    if (Object.keys(settings).some((key) => key !== "visibility") ||
-                        (settings["visibility"] !== undefined && settings["visibility"] !== "public"))
-                        fail("linkedin.options", "This slice supports public visibility only; other native options require explicit implementation.");
-                }
+                const settings = optionsObject(target);
+                if (Object.keys(settings).some((key) => key !== "visibility") ||
+                    (settings["visibility"] !== undefined && settings["visibility"] !== "public"))
+                    fail("linkedin.options", "This slice supports public visibility only; other native options require explicit implementation.");
                 const media = target.content.media ?? [];
-                if (media.length > 1)
-                    fail("linkedin.media_count", "This slice accepts one registered image per post.");
+                for (const [code, message] of documentIssues(target))
+                    fail(code, message);
+                // A MultiImage post takes 2 to 20 images; alt text is at most 4,086 characters.
+                // A video post carries exactly one video and cannot be mixed with images.
+                if (media.length > 20)
+                    fail("linkedin.media_count", "LinkedIn accepts one image, one video, or a multi-image post of 2 to 20 images.");
+                if (media.length > 1 && media.some((item) => item.kind === "video"))
+                    fail("linkedin.media_count", "A LinkedIn video post carries exactly one video and cannot be combined with other media.");
                 for (const item of media) {
-                    if (item.kind !== "image" || item.source.kind !== "media-ref")
-                        fail("linkedin.media", "Upload an image first with media.upload, then publish its account-bound reference.");
+                    if (media.length > 1 && (item.altText?.length ?? 0) > 4086)
+                        fail("linkedin.alt_text", "LinkedIn multi-image alt text exceeds 4,086 characters.");
+                    if (item.kind === "document")
+                        continue;
+                    if ((item.kind !== "image" && item.kind !== "video") || item.source.kind !== "media-ref")
+                        fail("linkedin.media", "Upload an image or video first with media.upload, then publish its account-bound reference.");
                     else if (item.source.ref.backend !== target.account.backend ||
                         item.source.ref.accountId !== target.account.accountId ||
                         item.source.ref.platform !== "linkedin" ||
-                        !/^urn:li:image:[a-zA-Z0-9_-]+$/.test(item.source.ref.mediaId))
-                        fail("linkedin.media_owner", "Image reference belongs to another author/backend or has an invalid URN.");
+                        !(item.kind === "video" ? linkedInVideoUrn : linkedInImageUrn).test(item.source.ref.mediaId))
+                        fail("linkedin.media_owner", "Media reference belongs to another author/backend or has an invalid URN for its kind.");
+                    else if (item.kind === "video" && item.altText !== undefined)
+                        fail("linkedin.video_alt_text", "LinkedIn video posts do not accept alt text.");
                 }
                 return issues;
             },
             async publishTarget(target, context) {
                 authorize(target.account, context);
-                const media = target.content.media?.[0];
-                let content;
-                if (media?.source.kind === "media-ref") {
-                    authorize(media.source.ref, context);
+                const media = target.content.media ?? [];
+                const entries = [];
+                for (const item of media) {
+                    // Documents are read and validated by documentContent below.
+                    if (item.kind === "document" || item.source.kind !== "media-ref")
+                        continue;
+                    authorize(item.source.ref, context);
+                    const video = item.kind === "video";
                     let image;
                     try {
-                        // SAFETY: object() validates the upstream response as a JSON object.
-                        image = object(await request(`/rest/images/${encodeURIComponent(media.source.ref.mediaId)}`, context));
+                        image = object(await request(`/rest/${video ? "videos" : "images"}/${encodeURIComponent(item.source.ref.mediaId)}`, context));
                     }
                     catch (error) {
-                        if (!(error instanceof SocialError) ||
+                        // Only image reads keep the member-token 403 exception. A video must prove AVAILABLE.
+                        if (video ||
+                            !(error instanceof SocialError) ||
                             error.code !== "missing_permission" ||
                             !options.auth.author.startsWith("urn:li:person:"))
                             throw error;
@@ -529,22 +1148,61 @@ export function linkedin(options) {
                         throw new SocialError({
                             code: "unauthorized",
                             operation: "posts.publish",
-                            message: "LinkedIn image belongs to a different author.",
+                            message: `LinkedIn ${video ? "video" : "image"} belongs to a different author.`,
                         });
-                    if (image?.["status"] !== undefined && image["status"] !== "AVAILABLE")
+                    if (image?.["id"] !== undefined && image["id"] !== item.source.ref.mediaId)
                         throw new SocialError({
                             code: "media_error",
                             operation: "posts.publish",
-                            message: "Image is not AVAILABLE. Check its status explicitly before publishing.",
+                            message: `LinkedIn returned a different ${video ? "video" : "image"} than the one attached. No post was created.`,
                         });
-                    content = {
-                        media: {
-                            id: media.source.ref.mediaId,
-                            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-                            ...(media.altText ? { altText: media.altText } : {}),
-                        },
-                    };
+                    if (video && image?.["status"] === "PROCESSING_FAILED")
+                        throw new SocialError({
+                            code: "media_error",
+                            operation: "posts.publish",
+                            message: "LinkedIn could not process this video. Upload it again; no post was created.",
+                            retryDisposition: { kind: "never" },
+                        });
+                    if (video &&
+                        (image?.["status"] === "PROCESSING" || image?.["status"] === "WAITING_UPLOAD"))
+                        // No post exists yet, so publishing again later is safe. The SDK does not retry.
+                        throw new SocialError({
+                            code: "media_error",
+                            operation: "posts.publish",
+                            message: "Video is still processing; no post was created. Wait with native waitForVideo or check videoStatus, then publish again with a new idempotency key.",
+                            retryDisposition: { kind: "after-delay", delayMs: linkedInVideoRetryDelayMs },
+                        });
+                    if (video
+                        ? image?.["status"] !== "AVAILABLE"
+                        : image?.["status"] !== undefined && image["status"] !== "AVAILABLE")
+                        throw new SocialError({
+                            code: "media_error",
+                            operation: "posts.publish",
+                            message: video
+                                ? "Video is not AVAILABLE. Check it with native videoStatus before publishing."
+                                : "Image is not AVAILABLE. Check its status explicitly before publishing.",
+                        });
+                    // Posts API media.title is optional for video and required only for documents.
+                    const title = video ? item.caption?.trim() : undefined;
+                    entries.push({
+                        id: item.source.ref.mediaId,
+                        ...definedFields({
+                            title: title || undefined,
+                            altText: video ? undefined : item.altText || undefined,
+                        }),
+                    });
                 }
+                // MultiImage content takes 2 to 20 image URNs. Source (accessed 2026-09-24):
+                // https://learn.microsoft.com/en-us/linkedin/marketing/community-management/shares/multiimage-post-api?view=li-lms-2026-09
+                // A single image or video uses content.media; a document post carries only its document.
+                const document = media.find((item) => item.kind === "document");
+                let content;
+                if (document)
+                    content = await documentContent(document, context);
+                else if (entries.length > 1)
+                    content = { multiImage: { images: entries } };
+                else if (entries[0] !== undefined)
+                    content = { media: entries[0] };
                 const result = object(await request("/rest/posts", context, {
                     author: target.account.accountId,
                     commentary: escapeCommentary(target.content.text ?? ""),
@@ -556,8 +1214,7 @@ export function linkedin(options) {
                     },
                     lifecycleState: "PUBLISHED",
                     isReshareDisabledByAuthor: false,
-                    // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-                    ...(content ? { content } : {}),
+                    ...definedFields({ content }),
                 }, ["x-restli-id"]));
                 const id = optionalString(object(result["headers"])["x-restli-id"]);
                 const base = {
@@ -631,13 +1288,10 @@ export function linkedin(options) {
                 const paging = result["paging"] === undefined ? {} : object(result["paging"]);
                 const total = optionalNumber(paging["total"]);
                 const hasNext = array(paging["links"] ?? []).some((link) => object(link)["rel"] === "next");
-                return {
-                    items,
-                    // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-                    ...(items.length > 0 && (hasNext || (total !== undefined && start + items.length < total))
-                        ? { nextCursor: String(start + items.length) }
-                        : {}),
-                };
+                const nextCursor = items.length > 0 && (hasNext || (total !== undefined && start + items.length < total))
+                    ? String(start + items.length)
+                    : undefined;
+                return { items, ...definedFields({ nextCursor }) };
             },
             async removeFromPlatform(ref, context) {
                 authorize(ref, context);
@@ -672,8 +1326,7 @@ export function linkedin(options) {
                 const next = total !== undefined && start + items.length < total
                     ? String(start + items.length)
                     : undefined;
-                // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-                return { items, ...(next === undefined ? {} : { nextCursor: next }) };
+                return { items, ...definedFields({ nextCursor: next }) };
             },
             async reply(ref, content, context) {
                 if (!content.text.trim() || content.text.length > 1250)
@@ -723,6 +1376,61 @@ export function linkedin(options) {
                 return { ...ref, commentId };
             },
         },
+        notifications: {
+            async list(account, input, context) {
+                authorize(account, context);
+                if (!account.accountId.startsWith("urn:li:organization:"))
+                    throw new SocialError({
+                        code: "unsupported_capability",
+                        operation: "notifications.read",
+                        message: "LinkedIn notifications are available for organization accounts only, not member accounts.",
+                    });
+                const start = input.cursor === undefined ? 0 : Number(input.cursor);
+                const count = input.limit ?? 25;
+                if (!Number.isSafeInteger(start) ||
+                    start < 0 ||
+                    input.cursor === "" ||
+                    !Number.isSafeInteger(count) ||
+                    count < 1 ||
+                    count > 100)
+                    throw new SocialError({
+                        code: "invalid_input",
+                        operation: "notifications.read",
+                        message: "LinkedIn requires a nonnegative offset and page size from 1 to 100.",
+                    });
+                const actions = "LIKE,COMMENT,SHARE,SHARE_MENTION,ADMIN_COMMENT,COMMENT_EDIT,COMMENT_DELETE";
+                const result = object(await request(`/rest/organizationalEntityNotifications?q=criteria&actions=List(${actions})&organizationalEntity=${encodeURIComponent(account.accountId)}&start=${start}&count=${count}`, context));
+                const rows = array(result["elements"]).map(object);
+                if (rows.some((row) => row["organizationalEntity"] !== account.accountId))
+                    throw new SocialError({
+                        code: "unauthorized",
+                        operation: "notifications.read",
+                        message: "LinkedIn returned a notification for another organization.",
+                    });
+                const items = rows.map((row) => publicFields(row, [
+                    "notificationId",
+                    "organizationalEntity",
+                    "action",
+                    "sourcePost",
+                    "generatedActivity",
+                    "lastModifiedAt",
+                ]));
+                const paging = result["paging"] === undefined ? {} : object(result["paging"]);
+                const total = optionalNumber(paging["total"]);
+                const hasNext = array(paging["links"] ?? []).some((link) => object(link)["rel"] === "next");
+                return Object.assign({ items }, items.length > 0 && (hasNext || (total !== undefined && start + items.length < total))
+                    ? { nextCursor: String(start + items.length) }
+                    : {});
+            },
+            async markSeen(account, _input, context) {
+                authorize(account, context);
+                throw new SocialError({
+                    code: "unsupported_capability",
+                    operation: "notifications.seen",
+                    message: "LinkedIn does not expose a seen state for organization notifications.",
+                });
+            },
+        },
         analytics: {
             async getAccountMetrics(account, context) {
                 authorize(account, context);
@@ -779,7 +1487,18 @@ export function linkedin(options) {
                 return metrics;
             },
         },
+        webhooks: directWebhooks("linkedin", (input) => verifyLinkedInWebhook({ ...input, secret: options.webhookSecret ?? "" }), now),
         native: {
+            async listAdministeredOrganizations({ account, cursor, limit, context }) {
+                authorize(account, context);
+                if (!account.accountId.startsWith("urn:li:person:"))
+                    throw new SocialError({
+                        code: "unauthorized",
+                        operation: "accounts.read",
+                        message: "LinkedIn administered organization lookup requires a member account reference.",
+                    });
+                return listAdministeredOrganizations(Object.assign({}, cursor === undefined ? {} : { cursor }, limit === undefined ? {} : { limit }), context);
+            },
             async imageStatus(ref, context) {
                 authorize(ref, context);
                 const image = object(await request(`/rest/images/${encodeURIComponent(ref.mediaId)}`, context));
@@ -791,12 +1510,51 @@ export function linkedin(options) {
                     });
                 return publicFields(image, ["id", "owner", "status"]);
             },
+            videoStatus: readVideoStatus,
+            async waitForVideo(ref, context, waitOptions = {}) {
+                const intervalMs = waitOptions.intervalMs ?? linkedInVideoWaitDefaults.intervalMs;
+                const maxChecks = waitOptions.maxChecks ?? linkedInVideoWaitDefaults.maxChecks;
+                if (!Number.isInteger(intervalMs) ||
+                    intervalMs < linkedInVideoWaitLimits.minIntervalMs ||
+                    intervalMs > linkedInVideoWaitLimits.maxIntervalMs ||
+                    !Number.isInteger(maxChecks) ||
+                    maxChecks < 1 ||
+                    maxChecks > linkedInVideoWaitLimits.maxChecks)
+                    throw new SocialError({
+                        code: "invalid_input",
+                        operation: "media.read",
+                        message: "waitForVideo takes an integer intervalMs from 1,000 to 60,000 and maxChecks from 1 to 60.",
+                    });
+                let status = await readVideoStatus(ref, context);
+                for (let check = 1; check < maxChecks; check++) {
+                    if (status["status"] !== "PROCESSING" && status["status"] !== "WAITING_UPLOAD")
+                        break;
+                    // Leave room for the next read; return the pending status instead of timing out.
+                    if (context.signal?.aborted)
+                        throw videoWaitCancelled();
+                    if (intervalMs >= budgetLeft(context))
+                        break;
+                    await videoWaitDelay(intervalMs, context);
+                    // A late timer can wake after the deadline; keep the last status instead of timing out.
+                    if (budgetLeft(context) <= 0)
+                        break;
+                    status = await readVideoStatus(ref, context);
+                }
+                return status;
+            },
+            async documentStatus(ref, context) {
+                return publicFields(await readDocument(ref, context, "media.read"), [
+                    "id",
+                    "owner",
+                    "status",
+                ]);
+            },
             async registerVideo({ account, context }) {
                 authorize(account, context);
                 throw new SocialError({
                     code: "unsupported_capability",
                     operation: "posts.video",
-                    message: "LinkedIn video publishing is not implemented by this adapter.",
+                    message: "registerVideo is deprecated. Upload the video with media.upload and check it with videoStatus.",
                 });
             },
             async createPoll({ account, text, options: pollOptions, duration = "THREE_DAYS", context }) {
@@ -820,8 +1578,7 @@ export function linkedin(options) {
                     },
                 }, ["x-restli-id"]));
                 const id = optionalString(object(result["headers"])["x-restli-id"]);
-                // SAFETY: result is validated as a JSON object and id is a JSON string.
-                return (id === undefined ? result : { ...result, id });
+                return id === undefined ? result : { ...result, id };
             },
             async react({ account, postId, reaction, context }) {
                 authorize(account, context);
@@ -845,18 +1602,32 @@ export function linkedin(options) {
                     reshareContext: { parent: postId },
                 }, ["x-restli-id"]));
                 const id = optionalString(object(result["headers"])["x-restli-id"]);
-                // SAFETY: result is validated as a JSON object and id is a JSON string.
-                return (id === undefined ? result : { ...result, id });
+                return id === undefined ? result : { ...result, id };
             },
             async updatePost({ account, postId, body, context }) {
                 authorize(account, context);
-                // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- validated boundary or fixture contract.
-                return (await request(`/rest/posts/${encodeURIComponent(postId)}`, context, { patch: { $set: body } }, ["x-restli-id"], "POST", { "X-RestLi-Method": "PARTIAL_UPDATE" }));
+                return object(await request(`/rest/posts/${encodeURIComponent(postId)}`, context, { patch: { $set: body } }, ["x-restli-id"], "POST", { "X-RestLi-Method": "PARTIAL_UPDATE" }));
             },
             async deletePost({ account, postId, context }) {
                 authorize(account, context);
                 await request(`/rest/posts/${encodeURIComponent(postId)}`, context, undefined, undefined, "DELETE");
             },
+            async deleteComment({ account, postId, commentId, context }) {
+                // Source: https://learn.microsoft.com/en-us/linkedin/marketing/community-management/shares/comments-api#delete-a-comment
+                // (li-lms-2026-09, page updated 2026-04-28, accessed 2026-09-24).
+                authorize(account, context);
+                const match = /^urn:li:comment:\(urn:li:(?:activity|share|ugcPost):\d+,(\d+)\)$/.exec(commentId);
+                if (!/^urn:li:(share|ugcPost):\d+$/.test(postId) || !match)
+                    throw new SocialError({
+                        code: "invalid_input",
+                        operation: "comments.delete",
+                        message: "Provide the share or ugcPost URN and the complete commentUrn returned by comment reads.",
+                    });
+                const actor = options.auth.author.startsWith("urn:li:organization:")
+                    ? `?actor=${encodeURIComponent(options.auth.author)}`
+                    : "";
+                await request(`/rest/socialActions/${encodeURIComponent(postId)}/comments/${match[1]}${actor}`, context, undefined, undefined, "DELETE");
+            },
             async organizationAnalytics({ account, context }) {
                 authorize(account, context);
                 if (!account.accountId.startsWith("urn:li:organization:"))
@@ -865,8 +1636,7 @@ export function linkedin(options) {
                         operation: "analytics.organization.read",
                         message: "Organization analytics requires an organization author.",
                     });
-                // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- validated boundary or fixture contract.
-                return (await request(`/rest/organizationalEntityShareStatistics?q=organizationalEntity&organizationalEntity=${encodeURIComponent(account.accountId)}`, context));
+                return object(await request(`/rest/organizationalEntityShareStatistics?q=organizationalEntity&organizationalEntity=${encodeURIComponent(account.accountId)}`, context));
             },
             async getOrganizationFollowerStatistics({ account, interval, context }) {
                 organizationOnly(account, context, "analytics.followers.read");