@firedrill-tools/linkedin 0.1.1

package/test/client.mjs

@@ -0,0 +1,71 @@
+// HTTP helpers for the LinkedIn conformance target (Node built-ins only).
+import assert from "node:assert/strict";
+
+const BASE = process.env.FIREDRILL_HTTP_URL;
+const TOKEN = process.env.FIREDRILL_HTTP_TOKEN;
+assert.ok(BASE && TOKEN, "the HTTP binding is required (FIREDRILL_HTTP_URL / FIREDRILL_HTTP_TOKEN)");
+
+export const VERSION = "202608";
+
+/** Percent-encodes a URN or key value for a path segment (parentheses and commas included). */
+export const enc = (value) => encodeURIComponent(value).replace(/\(/g, "%28").replace(/\)/g, "%29");
+export const personUrn = (id) => `urn:li:person:${id}`;
+export const orgUrn = (id) => `urn:li:organization:${id}`;
+
+/**
+ * Calls a LinkedIn route. `expect` is a status or [status, code]. `/rest` paths send LinkedIn-Version unless `version: null`.
+ * Error bodies are checked against LinkedIn's envelope: `/rest` carries `code`, `/v2` does not.
+ */
+export async function call(method, path, expect = 200, { json, headers = {}, version = VERSION, restli } = {}) {
+  const [status, code] = Array.isArray(expect) ? expect : [expect];
+  const rest = path.startsWith("/rest/");
+  const init = { method, headers: { authorization: `Bearer ${TOKEN}`, "x-restli-protocol-version": "2.0.0", ...headers } };
+  if (rest && version !== null) init.headers["linkedin-version"] = version;
+  if (restli !== undefined) init.headers["x-restli-method"] = restli;
+  if (json !== undefined) {
+    init.headers["content-type"] = "application/json";
+    init.body = typeof json === "string" ? json : JSON.stringify(json);
+  }
+  const response = await fetch(`${BASE}${path}`, init);
+  const text = await response.text();
+  assert.equal(response.status, status, `${method} ${path} → ${response.status} ${text.slice(0, 600)}`);
+  let body;
+  if (status === 204 || status === 202 || (status === 201 && text === "")) assert.equal(text, "", `${method} ${path}: ${status} has no body`);
+  else body = JSON.parse(text);
+  if (status >= 400) {
+    assert.equal(body.status, status, `${method} ${path}: envelope status`);
+    assert.equal(typeof body.serviceErrorCode, "number");
+    assert.equal(typeof body.message, "string");
+    if (rest) {
+      assert.equal(typeof body.code, "string", `${method} ${path}: /rest envelope carries code`);
+      if (code !== undefined) assert.equal(body.code, code, `${method} ${path}: expected ${code}, got ${body.code} (${body.message})`);
+    } else {
+      assert.equal(body.code, undefined, `${method} ${path}: /v2 envelope has no code`);
+    }
+  }
+  if (status < 500 && response.status !== 404) assert.equal(response.headers.get("x-restli-protocol-version"), "2.0.0");
+  return { status: response.status, body, headers: response.headers };
+}
+
+export const get = (path, expect, options) => call("GET", path, expect, options);
+export const post = (path, json, expect = 201, options = {}) => call("POST", path, expect, { ...options, json });
+export const partial = (path, json, expect = 204, options = {}) => call("POST", path, expect, { restli: "PARTIAL_UPDATE", ...options, json });
+export const del = (path, expect = 204, options = {}) => call("DELETE", path, expect, options);
+
+/** Canonical operation call. `expect` is "ok", "denied", "invalid" or a declared error code. Returns the outcome. */
+export async function op(operationId, args = {}, expect = "ok") {
+  const response = await fetch(`${BASE}/v1/operations/linkedin/${operationId}`, {
+    method: "POST", headers: { authorization: `Bearer ${TOKEN}`, "content-type": "application/json" }, body: JSON.stringify({ arguments: args }),
+  });
+  const record = await response.json();
+  const outcome = record.outcome ?? {};
+  const got = outcome.status === "tool_error" ? String(outcome.error?.code ?? "").split(".").pop() : outcome.status;
+  assert.equal(got, expect, `${operationId} ${JSON.stringify(args).slice(0, 300)} → ${JSON.stringify(outcome).slice(0, 600)}`);
+  return outcome;
+}
+
+/** A text post body for POST /rest/posts. */
+export const textPost = (author, commentary, extra = {}) => ({
+  author, commentary, visibility: "PUBLIC", distribution: { feedDistribution: "MAIN_FEED", targetEntities: [], thirdPartyDistributionChannels: [] },
+  lifecycleState: "PUBLISHED", isReshareDisabledByAuthor: false, ...extra,
+});

package/test/conformance.mjs

@@ -0,0 +1,20 @@
+// LinkedIn Tool conformance target: a scripted Tool test, not a model-driven agent. Node built-ins only.
+// Calls the LinkedIn-shaped routes (Bearer token, LinkedIn-Version header) and canonical operations at FIREDRILL_HTTP_URL.
+// Each drill instruction names one flow ("Run the <flow> flow ..."); every flow throws on any unexpected status, header or body.
+import assert from "node:assert/strict";
+import { FLOWS as COMMENTS } from "./flows/comments.mjs";
+import { FLOWS as FAULTS } from "./flows/faults.mjs";
+import { FLOWS as IDENTITY } from "./flows/identity.mjs";
+import { FLOWS as ORGS } from "./flows/orgs.mjs";
+import { FLOWS as POSTS } from "./flows/posts.mjs";
+import { FLOWS as REACTIONS } from "./flows/reactions.mjs";
+import { FLOWS as WIRE } from "./flows/wire.mjs";
+
+let task = "";
+for await (const chunk of process.stdin) task += chunk;
+const instruction = String(JSON.parse(task).instruction ?? "");
+const flow = /Run the ([a-z-]+) flow/.exec(instruction)?.[1];
+const FLOWS = { ...IDENTITY, ...POSTS, ...COMMENTS, ...REACTIONS, ...ORGS, ...WIRE, ...FAULTS };
+assert.ok(flow !== undefined && Object.hasOwn(FLOWS, flow), `unknown flow in instruction: ${instruction}`);
+await FLOWS[flow]();
+console.log(JSON.stringify({ flow, status: "passed" }));

package/test/fixtures.mjs

@@ -0,0 +1,182 @@
+// Generated from the starter data (do not edit by hand): seeded ids used by the conformance flows.
+export const PEOPLE = {"maya":"mOk4f0rPx1","sam":"sWh1tf1eld","priya":"pR4manQ7xz","luis":"lC4rv4lho0","zoe":"zLuk4s1ew1","daniel":"dMens4hK2p","aiko":"aT4nak4Rr8","grace":"gOduy4Lm3n","jordan":"jR3yesVv0q","elena":"ePetr0v4Qs","tomas":"tIb4n3zX0p","noor":"nH4dd4dPq2"};
+export const ORGS = {"northwind":81234567,"brightline":81234568,"lakeview":81234569};
+export const POSTS = {
+ "mayaDeleted": {
+  "id": "7495479617126400001",
+  "urn": "urn:li:share:7495479617126400001",
+  "activity": "urn:li:activity:7495479617126400002",
+  "activityId": "7495479617126400002"
+ },
+ "sam": {
+  "id": "7496566780723200003",
+  "urn": "urn:li:share:7496566780723200003",
+  "activity": "urn:li:activity:7496566780723200004",
+  "activityId": "7496566780723200004"
+ },
+ "mayaReshare": {
+  "id": "7498378720051200005",
+  "urn": "urn:li:share:7498378720051200005",
+  "activity": "urn:li:activity:7498378720051200006",
+  "activityId": "7498378720051200006"
+ },
+ "mayaUgc": {
+  "id": "7500190659379200007",
+  "urn": "urn:li:ugcPost:7500190659379200007",
+  "activity": "urn:li:activity:7500190659379200008",
+  "activityId": "7500190659379200008"
+ },
+ "mayaLong": {
+  "id": "7501277822976000009",
+  "urn": "urn:li:share:7501277822976000009",
+  "activity": "urn:li:activity:7501277822976000010",
+  "activityId": "7501277822976000010"
+ },
+ "mayaClosed": {
+  "id": "7502002598707200011",
+  "urn": "urn:li:share:7502002598707200011",
+  "activity": "urn:li:activity:7502002598707200012",
+  "activityId": "7502002598707200012"
+ },
+ "brightline": {
+  "id": "7502364986572800013",
+  "urn": "urn:li:share:7502364986572800013",
+  "activity": "urn:li:activity:7502364986572800014",
+  "activityId": "7502364986572800014"
+ },
+ "mayaEdited": {
+  "id": "7502727374438400015",
+  "urn": "urn:li:share:7502727374438400015",
+  "activity": "urn:li:activity:7502727374438400016",
+  "activityId": "7502727374438400016"
+ },
+ "northwindArticle": {
+  "id": "7503089762304000017",
+  "urn": "urn:li:share:7503089762304000017",
+  "activity": "urn:li:activity:7503089762304000018",
+  "activityId": "7503089762304000018"
+ },
+ "mayaLoggedIn": {
+  "id": "7503452150169600019",
+  "urn": "urn:li:share:7503452150169600019",
+  "activity": "urn:li:activity:7503452150169600020",
+  "activityId": "7503452150169600020"
+ },
+ "mayaConnections": {
+  "id": "7503814538035200021",
+  "urn": "urn:li:share:7503814538035200021",
+  "activity": "urn:li:activity:7503814538035200022",
+  "activityId": "7503814538035200022"
+ },
+ "mayaMention": {
+  "id": "7504176925900800023",
+  "urn": "urn:li:share:7504176925900800023",
+  "activity": "urn:li:activity:7504176925900800024",
+  "activityId": "7504176925900800024"
+ },
+ "jordan": {
+  "id": "7504176925900800025",
+  "urn": "urn:li:share:7504176925900800025",
+  "activity": "urn:li:activity:7504176925900800026",
+  "activityId": "7504176925900800026"
+ },
+ "mayaHashtags": {
+  "id": "7504539313766400027",
+  "urn": "urn:li:share:7504539313766400027",
+  "activity": "urn:li:activity:7504539313766400028",
+  "activityId": "7504539313766400028"
+ },
+ "zoe": {
+  "id": "7504720507699200029",
+  "urn": "urn:li:share:7504720507699200029",
+  "activity": "urn:li:activity:7504720507699200030",
+  "activityId": "7504720507699200030"
+ },
+ "mayaArticle": {
+  "id": "7504901701632000031",
+  "urn": "urn:li:share:7504901701632000031",
+  "activity": "urn:li:activity:7504901701632000032",
+  "activityId": "7504901701632000032"
+ },
+ "northwindPriya": {
+  "id": "7505082895564800033",
+  "urn": "urn:li:share:7505082895564800033",
+  "activity": "urn:li:activity:7505082895564800034",
+  "activityId": "7505082895564800034"
+ },
+ "mayaPlain": {
+  "id": "7505264089497600035",
+  "urn": "urn:li:share:7505264089497600035",
+  "activity": "urn:li:activity:7505264089497600036",
+  "activityId": "7505264089497600036"
+ },
+ "mayaDraft": {
+  "id": "7505581178880000037",
+  "urn": "urn:li:share:7505581178880000037",
+  "activity": "urn:li:activity:7505581178880000038",
+  "activityId": "7505581178880000038"
+ }
+};
+export const COMMENTS = {
+ "samOnArticle": {
+  "id": "7504937940418560039",
+  "activityId": "7504901701632000032",
+  "urn": "urn:li:comment:(urn:li:activity:7504901701632000032,7504937940418560039)"
+ },
+ "priyaOnArticle": {
+  "id": "7504974179205120040",
+  "activityId": "7504901701632000032",
+  "urn": "urn:li:comment:(urn:li:activity:7504901701632000032,7504974179205120040)"
+ },
+ "mayaReplySam": {
+  "id": "7505010417991680041",
+  "activityId": "7504901701632000032",
+  "urn": "urn:li:comment:(urn:li:activity:7504901701632000032,7505010417991680041)"
+ },
+ "northwindReplyPriya": {
+  "id": "7505046656778240042",
+  "activityId": "7504901701632000032",
+  "urn": "urn:li:comment:(urn:li:activity:7504901701632000032,7505046656778240042)"
+ },
+ "zoeOnArticle": {
+  "id": "7505082895564800043",
+  "activityId": "7504901701632000032",
+  "urn": "urn:li:comment:(urn:li:activity:7504901701632000032,7505082895564800043)"
+ },
+ "danielOnReport": {
+  "id": "7503270956236800044",
+  "activityId": "7503089762304000018",
+  "urn": "urn:li:comment:(urn:li:activity:7503089762304000018,7503270956236800044)"
+ },
+ "aikoOnReport": {
+  "id": "7503452150169600045",
+  "activityId": "7503089762304000018",
+  "urn": "urn:li:comment:(urn:li:activity:7503089762304000018,7503452150169600045)"
+ },
+ "mayaOnSam": {
+  "id": "7496929168588800046",
+  "activityId": "7496566780723200004",
+  "urn": "urn:li:comment:(urn:li:activity:7496566780723200004,7496929168588800046)"
+ },
+ "noorOnSam": {
+  "id": "7497110362521600047",
+  "activityId": "7496566780723200004",
+  "urn": "urn:li:comment:(urn:li:activity:7496566780723200004,7497110362521600047)"
+ },
+ "graceOnBrightline": {
+  "id": "7502546180505600048",
+  "activityId": "7502364986572800014",
+  "urn": "urn:li:comment:(urn:li:activity:7502364986572800014,7502546180505600048)"
+ },
+ "mayaOnZoe": {
+  "id": "7504756746485760049",
+  "activityId": "7504720507699200030",
+  "urn": "urn:li:comment:(urn:li:activity:7504720507699200030,7504756746485760049)"
+ },
+ "elenaOnZoe": {
+  "id": "7504829224058880050",
+  "activityId": "7504720507699200030",
+  "urn": "urn:li:comment:(urn:li:activity:7504720507699200030,7504829224058880050)"
+ }
+};
+export const COUNTS = {"posts":19,"comments":12,"reactions":14};

package/test/flows/comments.mjs

@@ -0,0 +1,116 @@
+// Comment flows: create, reply, list, get, edit and delete, with validation and ownership errors.
+import assert from "node:assert/strict";
+import { del, enc, get, op, orgUrn, partial, personUrn, post } from "../client.mjs";
+import { COMMENTS, ORGS, PEOPLE, POSTS } from "../fixtures.mjs";
+
+const maya = personUrn(PEOPLE.maya);
+const base = (target) => `/rest/socialActions/${enc(target)}/comments`;
+const art = POSTS.mayaArticle;
+
+async function create() {
+  const text = "Thanks Zoë Łukasiewicz for the review";
+  const mention = { start: text.indexOf("Zoë"), length: 15, value: { person: { person: personUrn(PEOPLE.zoe) } } };
+  const top = await post(base(art.urn), { actor: maya, object: art.activity, message: { text, attributes: [mention] } });
+  assert.equal(top.headers.get("x-restli-id"), top.body.id);
+  assert.equal(top.body.commentUrn, `urn:li:comment:(${art.activity},${top.body.id})`);
+  assert.deepEqual(top.body.message.attributes, [mention]);
+  assert.equal(top.body.object, art.activity);
+  const reply = await post(base(COMMENTS.samOnArticle.urn), { actor: maya, object: art.activity, message: { text: "Replying again" } });
+  assert.equal(reply.body.parentComment, COMMENTS.samOnArticle.urn);
+  assert.equal(reply.body.commentsSummary, undefined);
+  await post(base(art.urn), { actor: maya, message: { text: "A reply by field" }, parentComment: COMMENTS.priyaOnArticle.urn });
+  const page = await post(base(POSTS.northwindArticle.urn), { actor: orgUrn(ORGS.northwind), message: { text: "Thanks for reading" } });
+  assert.equal(page.body.agent, maya);
+  assert.equal(page.body.created.impersonator, maya);
+  const bad = (target, body, expect) => post(base(target), body, expect);
+  const msg = (text) => ({ actor: maya, message: { text } });
+  await bad(COMMENTS.mayaReplySam.urn, msg("reply to a reply"), [422, "UNPROCESSABLE_ENTITY"]);
+  await bad(art.urn, { ...msg("x"), message: { text: "x", attributes: [{ start: 0, length: 5, value: { person: { person: maya } } }] } },
+    [400, "INVALID_VALUE_FOR_FIELD"]);
+  await bad(art.urn, { ...msg("x"), object: POSTS.sam.activity }, [400, "INVALID_VALUE_FOR_FIELD"]);
+  await bad(art.urn, msg("c".repeat(1251)), [400, "FIELD_LENGTH_TOO_LONG"]);
+  await bad(art.urn, msg("  "), [400, "INVALID_VALUE_BLANK_FIELD"]);
+  await bad(art.urn, { actor: maya }, [400, "MISSING_FIELD"]);
+  await bad(art.urn, { message: { text: "x" } }, [400, "MISSING_FIELD"]);
+  await bad(art.urn, { ...msg("x"), content: [{ entity: { image: "urn:li:image:1" } }] }, [403, "ACCESS_DENIED"]);
+  await bad(POSTS.mayaClosed.urn, msg("closed"), [422, "UNPROCESSABLE_ENTITY"]);
+  await bad(POSTS.mayaDraft.urn, msg("draft"), [422, "UNPROCESSABLE_ENTITY"]);
+  await bad(art.urn, { actor: personUrn(PEOPLE.sam), message: { text: "x" } }, [403, "ACCESS_DENIED"]);
+  await bad("urn:li:share:12345", msg("x"), [404, "NOT_FOUND"]);
+  await bad(art.urn, { ...msg("x"), parentComment: `urn:li:comment:(${art.activity},12345)` }, [404, "NOT_FOUND"]);
+  await bad(POSTS.jordan.urn, msg("hidden"), [403, "ACCESS_DENIED"]);
+  await bad("urn:li:share:x", msg("x"), [400, "BAD_REQUEST"]);
+  await op("comments.create", { target: maya, ...msg("x") }, "INVALID_URN_TYPE");
+  await op("comments.create", { target: "urn:li:share:", ...msg("x") }, "INVALID_URN_ID");
+  return { top: top.body, page: page.body };
+}
+
+async function listAndGet() {
+  const first = (await get(`${base(art.urn)}?count=2`)).body;
+  assert.equal(first.paging.total, 4);
+  assert.deepEqual(first.elements.map((c) => c.id), [COMMENTS.samOnArticle.id, COMMENTS.priyaOnArticle.id]);
+  assert.equal(first.elements[0].commentsSummary.totalFirstLevelComments, 2);
+  assert.equal(first.elements[0].likesSummary.likedByCurrentUser, true);
+  assert.equal(first.paging.links[0].rel, "next");
+  const second = (await get(`${base(art.urn)}?count=2&start=2`)).body;
+  assert.equal(second.elements.length, 2);
+  assert.equal(second.elements[0].id, COMMENTS.zoeOnArticle.id);
+  assert.equal((await get(base(COMMENTS.samOnArticle.urn))).body.paging.total, 2);
+  assert.deepEqual((await get(base(POSTS.mayaPlain.urn))).body.elements, []);
+  assert.equal((await get(base(art.activity))).body.paging.total, 4);
+  await get(`${base(art.urn)}?count=101`, [400, "INVALID_VALUE_FOR_FIELD"]);
+  await get(base("urn:li:share:12345"), [404, "NOT_FOUND"]);
+  await get(base(POSTS.jordan.urn), [403, "ACCESS_DENIED"]);
+  await op("comments.list", { target: maya }, "INVALID_URN_TYPE");
+  await op("comments.list", { target: "urn:li:activity:x" }, "INVALID_URN_ID");
+  const zoe = (await get(`${base(art.urn)}/${COMMENTS.zoeOnArticle.id}`)).body;
+  assert.deepEqual(zoe.message.attributes, [{ start: 16, length: 11, value: { person: { person: maya } } }]);
+  await get(`${base(POSTS.sam.urn)}/${COMMENTS.zoeOnArticle.id}`, [404, "NOT_FOUND"]);
+  await get(`${base(POSTS.jordan.urn)}/1`, [403, "ACCESS_DENIED"]);
+  await op("comments.get", { target: art.urn, commentId: "abc" }, "INVALID_URN_ID");
+  await op("comments.get", { target: maya, commentId: "1" }, "INVALID_URN_TYPE");
+}
+
+async function editAndDelete({ top, page }) {
+  const edited = await partial(`${base(art.urn)}/${top.id}`, { patch: { message: { $set: { text: "Edited thanks" } } } }, 200);
+  assert.equal(edited.body.message.text, "Edited thanks");
+  assert.deepEqual(edited.body.message.attributes, []);
+  assert.equal(edited.headers.get("x-resourceidentity-urn"), top.commentUrn);
+  const url = `${base(POSTS.northwindArticle.urn)}/${page.id}?actor=${enc(orgUrn(ORGS.northwind))}`;
+  assert.equal((await partial(url, { patch: { message: { $set: { text: "Thanks for reading!" } } } }, 200)).body.actor, orgUrn(ORGS.northwind));
+  const edit = (id, body, expect) => partial(`${base(art.urn)}/${id}`, body, expect);
+  const set = (text) => ({ patch: { message: { $set: { text } } } });
+  await edit(COMMENTS.priyaOnArticle.id, set("not mine"), [403, "ACCESS_DENIED"]);
+  await edit("12345", set("missing"), [404, "NOT_FOUND"]);
+  await edit(top.id, set(" "), [400, "INVALID_VALUE_BLANK_FIELD"]);
+  await edit(top.id, set("e".repeat(1251)), [400, "FIELD_LENGTH_TOO_LONG"]);
+  await edit(top.id, { patch: { foo: 1 } }, [400, "INVALID_VALUE_FOR_FIELD"]);
+  await op("comments.update", { target: art.urn, commentId: top.id }, "MISSING_FIELD");
+  await op("comments.update", { target: maya, commentId: top.id, message: { text: "x" } }, "INVALID_URN_TYPE");
+  await op("comments.update", { target: art.urn, commentId: "x1", message: { text: "x" } }, "INVALID_URN_ID");
+
+  const removed = await op("comments.delete", { target: art.urn, commentId: COMMENTS.samOnArticle.id });
+  assert.deepEqual(removed.value, { commentUrn: COMMENTS.samOnArticle.urn, deleted: true, deletedReplies: 2 });
+  await del(`${base(art.urn)}/${top.id}`);
+  await get(`${base(art.urn)}/${top.id}`, [404, "NOT_FOUND"]);
+  await del(`${base(POSTS.sam.urn)}/${COMMENTS.noorOnSam.id}`, [403, "ACCESS_DENIED"]);
+  await del(`${base(art.urn)}/12345`, [404, "NOT_FOUND"]);
+  await op("comments.delete", { target: maya, commentId: "1" }, "INVALID_URN_TYPE");
+  await op("comments.delete", { target: art.urn, commentId: "" }, "INVALID_URN_ID");
+}
+
+async function comments() {
+  const created = await create();
+  await listAndGet();
+  await editAndDelete(created);
+}
+
+async function commentsConnection() {
+  await del(`${base(POSTS.sam.urn)}/${COMMENTS.mayaOnSam.id}`);
+  await partial(`${base(POSTS.sam.urn)}/${COMMENTS.noorOnSam.id}`, { patch: { message: { $set: { text: "edited by Sam" } } } }, [403, "ACCESS_DENIED"]);
+  await del(`${base(POSTS.brightline.urn)}/${COMMENTS.graceOnBrightline.id}?actor=${enc(orgUrn(ORGS.brightline))}`);
+  await partial(`${base(POSTS.zoe.urn)}/${COMMENTS.mayaOnZoe.id}`, { patch: { message: { $set: { text: "x" } } } }, [403, "ACCESS_DENIED"]);
+  assert.equal((await get(base(POSTS.sam.urn))).body.paging.total, 1);
+}
+
+export const FLOWS = { comments, "comments-connection": commentsConnection };

package/test/flows/every.mjs

@@ -0,0 +1,38 @@
+// Calls every operation once through the canonical endpoint with arguments that are valid for Maya's seeded network.
+import { op, orgUrn, personUrn } from "../client.mjs";
+import { COMMENTS, ORGS, PEOPLE, POSTS } from "../fixtures.mjs";
+
+export function everyCall() {
+  const maya = personUrn(PEOPLE.maya);
+  return [
+    ["profile.userinfo", {}],
+    ["profile.me", {}],
+    ["people.get", { personId: PEOPLE.sam }],
+    ["posts.create", { author: maya, commentary: "probe", visibility: "PUBLIC", distribution: { feedDistribution: "MAIN_FEED" }, lifecycleState: "PUBLISHED" }],
+    ["posts.get", { postUrn: POSTS.mayaPlain.urn }],
+    ["posts.list_by_author", { author: maya }],
+    ["posts.update", { postUrn: POSTS.mayaPlain.urn, commentary: "probe edit" }],
+    ["posts.delete", { postUrn: POSTS.mayaPlain.urn }],
+    ["feed.list", {}],
+    ["comments.create", { target: POSTS.mayaPlain.urn, actor: maya, message: { text: "probe" } }],
+    ["comments.list", { target: POSTS.mayaArticle.urn }],
+    ["comments.get", { target: POSTS.mayaArticle.urn, commentId: COMMENTS.samOnArticle.id }],
+    ["comments.update", { target: POSTS.zoe.urn, commentId: COMMENTS.mayaOnZoe.id, message: { text: "probe" } }],
+    ["comments.delete", { target: POSTS.zoe.urn, commentId: COMMENTS.mayaOnZoe.id }],
+    ["reactions.create", { actor: maya, root: POSTS.mayaPlain.urn, reactionType: "LIKE" }],
+    ["reactions.list", { entity: POSTS.mayaArticle.activity }],
+    ["reactions.delete", { actor: maya, entity: POSTS.zoe.activity }],
+    ["social_metadata.get", { entity: POSTS.mayaArticle.urn }],
+    ["social_metadata.set_comments_state", { entity: POSTS.mayaPlain.urn, actor: maya, commentsState: "CLOSED" }],
+    ["organizations.get", { organizationId: String(ORGS.northwind) }],
+    ["organizations.find_by_vanity_name", { vanityName: "northwind-analytics" }],
+    ["organization_acls.list", { q: "roleAssignee" }],
+    ["network_sizes.get", { entity: orgUrn(ORGS.northwind), edgeType: "COMPANY_FOLLOWED_BY_MEMBER" }],
+    ["connections.list", {}],
+  ];
+}
+
+/** Every operation must answer `expect` ("denied" or a declared error code). */
+export async function everyOperation(expect) {
+  for (const [operationId, args] of everyCall()) await op(operationId, args, expect);
+}

package/test/flows/faults.mjs

@@ -0,0 +1,56 @@
+// Fault scenarios and the scan-bound scenario.
+import assert from "node:assert/strict";
+import { del, enc, get, op, partial, personUrn, post, textPost } from "../client.mjs";
+import { COMMENTS, PEOPLE, POSTS } from "../fixtures.mjs";
+
+const maya = personUrn(PEOPLE.maya);
+const social = (target) => `/rest/socialActions/${enc(target)}/comments`;
+const reactionKey = (entity) => `/rest/reactions/${enc(`(actor:${maya},entity:${entity})`)}`;
+
+async function commentThrottled() {
+  const refused = (await post(social(POSTS.mayaPlain.urn), { actor: maya, message: { text: "First!" } }, [429, "TOO_MANY_REQUESTS"])).body;
+  assert.match(refused.message, /Comment create throttled/);
+  assert.equal((await get(social(POSTS.mayaPlain.urn))).body.paging.total, 0);
+}
+
+async function postLostResponse() {
+  const find = `/rest/posts?q=author&author=${enc(maya)}&count=100`;
+  assert.equal((await get(find)).body.paging.total, 11);
+  await post("/rest/posts", textPost(maya, "Quarterly roadmap is live"), [500, "INTERNAL_SERVER_ERROR"]);
+  const after = (await get(find)).body;
+  assert.equal(after.paging.total, 12, "the post was committed even though the caller saw 500");
+  assert.ok(after.elements.some((p) => p.commentary === "Quarterly roadmap is live"));
+  await post("/rest/posts", textPost(maya, "Quarterly roadmap is live"), [500, "INTERNAL_SERVER_ERROR"]);
+  const duplicates = (await get(find)).body.elements.filter((p) => p.commentary === "Quarterly roadmap is live");
+  assert.equal(duplicates.length, 2, "a blind retry publishes a duplicate");
+}
+
+async function reactionsOutage() {
+  await post(`/rest/reactions?actor=${enc(maya)}`, { root: POSTS.mayaPlain.urn, reactionType: "LIKE" }, [503, "SERVICE_UNAVAILABLE"]);
+  await del(reactionKey(POSTS.zoe.activity), [503, "SERVICE_UNAVAILABLE"]);
+  assert.equal((await get(reactionKey(POSTS.zoe.activity))).body.reactionType, "EMPATHY");
+}
+
+async function tightLimits() {
+  const bound = [500, "INTERNAL_SERVER_ERROR"];
+  const checkBound = (response) => assert.equal(response.body.message, "state exceeds the supported bound of 1 rows");
+  checkBound(await get(`/rest/posts?q=author&author=${enc(maya)}`, bound));
+  await del(`/rest/posts/${enc(POSTS.mayaArticle.urn)}`, bound);
+  await op("feed.list", {}, "INTERNAL_SERVER_ERROR");
+  await get(social(POSTS.mayaArticle.urn), bound);
+  await get(`${social(POSTS.mayaArticle.urn)}/${COMMENTS.samOnArticle.id}`, bound);
+  await partial(`${social(POSTS.zoe.urn)}/${COMMENTS.mayaOnZoe.id}`, { patch: { message: { $set: { text: "edited" } } } }, bound);
+  await del(`${social(POSTS.zoe.urn)}/${COMMENTS.mayaOnZoe.id}`, bound);
+  await get(`/rest/reactions/${enc(`(entity:${POSTS.mayaArticle.activity})`)}?q=entity`, bound);
+  await get(`/rest/socialMetadata/${enc(POSTS.mayaArticle.urn)}`, bound);
+  await post(`/rest/socialMetadata/${enc(POSTS.mayaArticle.urn)}?actor=${enc(maya)}`, { patch: { $set: { commentsState: "CLOSED" } } }, bound);
+  await get("/rest/organizationAcls?q=roleAssignee", bound);
+  await get(`/v2/connections/${enc(maya)}`, 500);
+  await op("connections.list", {}, "INTERNAL_SERVER_ERROR");
+  assert.equal((await get(`/rest/posts/${enc(POSTS.mayaArticle.urn)}`)).body.id, POSTS.mayaArticle.urn);
+  assert.equal((await get(`${social(POSTS.zoe.urn)}/${COMMENTS.elenaOnZoe.id}`, bound)).status, 500);
+}
+
+export const FLOWS = {
+  "comment-throttled": commentThrottled, "post-lost-response": postLostResponse, "reactions-outage": reactionsOutage, "tight-limits": tightLimits,
+};

package/test/flows/identity.mjs

@@ -0,0 +1,70 @@
+// Identity, token and grant flows.
+import assert from "node:assert/strict";
+import { enc, get, op, personUrn } from "../client.mjs";
+import { COMMENTS, PEOPLE, POSTS } from "../fixtures.mjs";
+import { everyOperation } from "./every.mjs";
+
+async function identity() {
+  const info = (await get("/v2/userinfo")).body;
+  assert.deepEqual(info, {
+    sub: PEOPLE.maya, name: "Maya Okafor", given_name: "Maya", family_name: "Okafor", picture: `https://media.example.com/profiles/${PEOPLE.maya}.jpg`,
+    locale: "en-US", email: "maya.okafor@example.com", email_verified: true,
+  });
+  const me = (await get("/v2/me")).body;
+  assert.equal(me.id, PEOPLE.maya);
+  assert.equal(me.localizedHeadline, "Head of Data Platform at Northwind Analytics");
+  assert.deepEqual(me.firstName, { localized: { en_US: "Maya" }, preferredLocale: { country: "US", language: "en" } });
+  const zoe = (await get(`/v2/people/${enc(`(id:${PEOPLE.zoe})`)}`)).body;
+  assert.equal(zoe.localizedLastName, "Łukasiewicz");
+  assert.equal(zoe.localizedHeadline, undefined);
+  assert.deepEqual(Object.keys(zoe.firstName.localized), ["pl_PL"]);
+  await get(`/v2/people/${enc(`(name:${PEOPLE.zoe})`)}`, 400);
+  await get(`/v2/people/${enc("(id:zzzzzzzzzz)")}`, 404);
+  await op("people.get", { personId: "bad id" }, "BAD_REQUEST");
+}
+
+async function freshInstall() {
+  const feed = (await op("feed.list", {})).value;
+  assert.equal(feed.viewer.personUrn, personUrn(PEOPLE.maya));
+  assert.equal(feed.serverTime, "2026-09-15T14:00:00.000Z");
+  assert.ok(feed.elements.some((item) => item.post.id === POSTS.mayaArticle.urn));
+  assert.equal((await op("profile.me", {})).value.id, PEOPLE.maya);
+}
+
+async function invalidToken() {
+  await everyOperation("INVALID_ACCESS_TOKEN");
+}
+
+async function denied() {
+  await everyOperation("denied");
+}
+
+async function openidOnly() {
+  await get("/v2/userinfo", 403);
+  await get("/v2/me", 403);
+  await everyOperation("ACCESS_DENIED");
+}
+
+async function limitedScopes() {
+  const info = (await get("/v2/userinfo")).body;
+  assert.equal(info.email, undefined);
+  assert.equal(info.email_verified, undefined);
+  await get(`/rest/posts?q=author&author=${enc(personUrn(PEOPLE.maya))}`, [403, "ACCESS_DENIED"]);
+  await op("feed.list", {}, "ACCESS_DENIED");
+  await op("connections.list", {}, "ACCESS_DENIED");
+  const created = await op("posts.create", {
+    author: personUrn(PEOPLE.maya), commentary: "Posting works with w_member_social alone.", visibility: "PUBLIC",
+    distribution: { feedDistribution: "MAIN_FEED" }, lifecycleState: "PUBLISHED",
+  });
+  assert.match(created.value.id, /^urn:li:share:[0-9]+$/);
+  await op("posts.create", {
+    author: "urn:li:organization:81234567", commentary: "Needs w_organization_social.", visibility: "PUBLIC",
+    distribution: { feedDistribution: "MAIN_FEED" }, lifecycleState: "PUBLISHED",
+  }, "ACCESS_DENIED");
+  await op("comments.list", { target: POSTS.mayaArticle.urn }, "ACCESS_DENIED");
+  void COMMENTS;
+}
+
+export const FLOWS = {
+  identity, "fresh-install": freshInstall, "invalid-token": invalidToken, denied, "openid-only": openidOnly, "limited-scopes": limitedScopes,
+};