@firedrill-tools/linkedin 0.1.1

package/firedrill/tools/linkedin/lib/render.mjs

@@ -0,0 +1,95 @@
+// Renders stored rows as LinkedIn JSON objects.
+import { postUrnOf } from "./urn.mjs";
+
+export function liteProfile(person) {
+  const locale = `${person.locale.language}_${person.locale.country}`;
+  const localized = (value) => ({ localized: { [locale]: value }, preferredLocale: { country: person.locale.country, language: person.locale.language } });
+  return {
+    id: person.id,
+    localizedFirstName: person.firstName,
+    localizedLastName: person.lastName,
+    ...(person.headline === null ? {} : { localizedHeadline: person.headline }),
+    vanityName: person.vanityName,
+    firstName: localized(person.firstName),
+    lastName: localized(person.lastName),
+    ...(person.pictureUrl === null ? {} : { profilePicture: { displayImage: `urn:li:digitalmediaAsset:${person.id}-profile` } }),
+  };
+}
+
+export const fullName = (person) => `${person.firstName} ${person.lastName}`;
+
+export function renderPost(post) {
+  return {
+    id: postUrnOf(post),
+    author: post.author,
+    commentary: post.commentary,
+    visibility: post.visibility,
+    distribution: { feedDistribution: post.feedDistribution, targetEntities: [], thirdPartyDistributionChannels: [] },
+    lifecycleState: post.lifecycleState,
+    lifecycleStateInfo: { isEditedByAuthor: post.isEditedByAuthor },
+    isReshareDisabledByAuthor: post.isReshareDisabledByAuthor,
+    createdAt: post.createdAtMs,
+    lastModifiedAt: post.lastModifiedAtMs,
+    ...(post.publishedAtMs === null ? {} : { publishedAt: post.publishedAtMs }),
+    ...(post.article === null ? {} : {
+      content: { article: { source: post.article.source, title: post.article.title,
+        ...(post.article.description === null ? {} : { description: post.article.description }) } },
+    }),
+    ...(post.reshareParent === null ? {} : { reshareContext: { parent: post.reshareParent, root: post.reshareRoot ?? post.reshareParent } }),
+  };
+}
+
+const auditStamp = (actor, time, impersonator) => ({
+  actor, time, ...(impersonator === null || impersonator === undefined ? {} : { impersonator: `urn:li:person:${impersonator}` }),
+});
+
+export function renderReaction(reaction) {
+  return {
+    id: `urn:li:reaction:(${reaction.actor},${reaction.entity})`,
+    root: reaction.entity,
+    reactionType: reaction.reactionType,
+    created: auditStamp(reaction.actor, reaction.createdAtMs, reaction.impersonator),
+    lastModified: auditStamp(reaction.actor, reaction.lastModifiedAtMs, reaction.impersonator),
+  };
+}
+
+/** Comment object; `likes` are the reactions on it and `replies` its reply rows (top-level comments only). */
+export function renderComment(comment, likes, replies, viewerUrn) {
+  const urn = `urn:li:comment:(urn:li:activity:${comment.activityId},${comment.id})`;
+  const stamp = (time) => auditStamp(comment.actor, time, comment.agent);
+  return {
+    id: comment.id,
+    commentUrn: urn,
+    actor: comment.actor,
+    ...(comment.agent === null ? {} : { agent: `urn:li:person:${comment.agent}` }),
+    created: stamp(comment.createdAtMs),
+    lastModified: stamp(comment.lastModifiedAtMs),
+    message: {
+      text: comment.text,
+      attributes: comment.attributes.map((attribute) => ({
+        start: attribute.start,
+        length: attribute.length,
+        value: attribute.person !== null
+          ? { person: { person: `urn:li:person:${attribute.person}` } }
+          : { organization: { organization: `urn:li:organization:${attribute.organization}` } },
+      })),
+    },
+    object: `urn:li:activity:${comment.activityId}`,
+    ...(comment.parentCommentId === null ? {} : {
+      parentComment: `urn:li:comment:(urn:li:activity:${comment.activityId},${comment.parentCommentId})`,
+    }),
+    likesSummary: {
+      totalLikes: likes.length,
+      aggregatedTotalLikes: likes.length,
+      likedByCurrentUser: likes.some((like) => like.actor === viewerUrn),
+      selectedLikes: likes.slice(0, 10).map((like) => like.actor),
+    },
+    ...(comment.parentCommentId !== null ? {} : {
+      commentsSummary: {
+        totalFirstLevelComments: replies.length,
+        aggregatedTotalComments: replies.length,
+        selectedComments: replies.slice(0, 10).map((reply) => `urn:li:comment:(urn:li:activity:${reply.activityId},${reply.id})`),
+      },
+    }),
+  };
+}

package/firedrill/tools/linkedin/lib/routes.mjs

@@ -0,0 +1,219 @@
+// Route decoders: LinkedIn path keys, query parameters, headers and bodies into operation arguments.
+import { parseComplexKey } from "./urn.mjs";
+import { begin, copyFields, finish, isObject, jsonBody, pathValue, queryInt, queryValue } from "./wire.mjs";
+
+const SYNTAX = "Syntax exception in path variables";
+const set = (state, name, value) => {
+  if (value !== undefined) state.args[name] = value;
+};
+const defined = (object) => Object.fromEntries(Object.entries(object).filter(([, value]) => value !== undefined));
+const paging = (state) => {
+  set(state, "start", queryInt(state, "start"));
+  set(state, "count", queryInt(state, "count"));
+};
+
+/** Builds a decoder: `rest` routes carry the version/method checks; `fill(state, request)` adds route arguments. */
+export const route = (options, fill) => (request) => {
+  const state = begin(request, options);
+  fill(state, request);
+  return finish(state);
+};
+
+export const plain = () => ({ arguments: {} });
+
+export const getPerson = route({ rest: false }, (state, request) => {
+  const key = parseComplexKey(pathValue(request, "personKey"));
+  if (key === null || key.size !== 1 || !key.has("id")) state.wire.error = SYNTAX;
+  else state.args.personId = key.get("id");
+});
+
+export const createPost = route({ rest: true }, (state, request) => {
+  copyFields(state, jsonBody(state, request), ["author", "commentary", "visibility", "distribution", "lifecycleState", "isReshareDisabledByAuthor",
+    "content", "reshareContext"]);
+});
+
+export const createUgcPost = route({ rest: false }, (state, request) => {
+  const body = jsonBody(state, request);
+  if (body === null) return;
+  const args = state.args;
+  args.kind = "ugcPost";
+  args.distribution = { feedDistribution: "MAIN_FEED" };
+  if (body.author !== undefined) args.author = body.author;
+  if (body.lifecycleState !== undefined) args.lifecycleState = body.lifecycleState;
+  if (isObject(body.visibility)) set(state, "visibility", body.visibility["com.linkedin.ugc.MemberNetworkVisibility"]);
+  const share = isObject(body.specificContent) ? body.specificContent["com.linkedin.ugc.ShareContent"] : undefined;
+  if (!isObject(share)) return;
+  if (isObject(share.shareCommentary)) set(state, "commentary", share.shareCommentary.text);
+  const category = share.shareMediaCategory ?? "NONE";
+  if (category === "ARTICLE") {
+    const media = Array.isArray(share.media) && isObject(share.media[0]) ? share.media[0] : {};
+    const text = (value) => (isObject(value) ? value.text : undefined);
+    args.content = { article: defined({ source: media.originalUrl, title: text(media.title), description: text(media.description) }) };
+  } else if (category !== "NONE") {
+    args.content = { media: { category: String(category).slice(0, 64) } };
+  }
+});
+
+export const getPost = route({ rest: true }, (state, request) => {
+  state.args.postUrn = pathValue(request, "postUrn");
+  set(state, "viewContext", queryValue(state, "viewContext"));
+});
+
+export const findPosts = route({ rest: true }, (state) => {
+  if (queryValue(state, "q") !== "author") state.wire.error = "Invalid query parameters passed to request: q";
+  set(state, "author", queryValue(state, "author"));
+  set(state, "viewContext", queryValue(state, "viewContext"));
+  set(state, "sortBy", queryValue(state, "sortBy"));
+  paging(state);
+});
+
+const POST_PATCH = ["commentary", "lifecycleState", "contentCallToActionLabel", "contentLandingPage"];
+
+export const updatePost = route({ rest: true, requireMethod: true }, (state, request) => {
+  state.args.postUrn = pathValue(request, "postUrn");
+  const body = jsonBody(state, request);
+  if (body === null) return;
+  for (const key of Object.keys(body)) if (key !== "patch") state.wire.fieldError = key;
+  const patch = body.patch;
+  if (!isObject(patch)) {
+    state.wire.fieldError ??= "patch";
+    return;
+  }
+  for (const key of Object.keys(patch)) if (key !== "$set") state.wire.fieldError = `patch/${key}`;
+  const changes = patch.$set ?? {};
+  if (!isObject(changes)) {
+    state.wire.fieldError ??= "patch/$set";
+    return;
+  }
+  for (const key of Object.keys(changes)) {
+    if (POST_PATCH.includes(key)) state.args[key] = changes[key];
+    else state.wire.fieldError = `patch/$set/${key}`;
+  }
+});
+
+export const deletePost = (name, rest) => route({ rest }, (state, request) => {
+  state.args.postUrn = pathValue(request, name);
+});
+
+const target = (state, request) => {
+  state.args.target = pathValue(request, "target");
+};
+const commentKey = (state, request) => {
+  target(state, request);
+  state.args.commentId = pathValue(request, "commentId");
+};
+
+export const createComment = route({ rest: true }, (state, request) => {
+  target(state, request);
+  copyFields(state, jsonBody(state, request), ["actor", "object", "message", "parentComment", "content"]);
+});
+
+export const listComments = route({ rest: true }, (state, request) => {
+  target(state, request);
+  paging(state);
+});
+
+export const getComment = route({ rest: true }, commentKey);
+
+export const updateComment = route({ rest: true, requireMethod: true }, (state, request) => {
+  commentKey(state, request);
+  set(state, "actor", queryValue(state, "actor"));
+  const body = jsonBody(state, request);
+  if (body === null) return;
+  const changes = isObject(body.patch) && isObject(body.patch.message) ? body.patch.message.$set : undefined;
+  if (!isObject(changes) || Object.keys(body).length !== 1 || Object.keys(body.patch).length !== 1
+    || Object.keys(body.patch.message).length !== 1) {
+    state.wire.fieldError = "patch";
+    return;
+  }
+  for (const key of Object.keys(changes)) if (key !== "text" && key !== "attributes") state.wire.fieldError = `patch/message/$set/${key}`;
+  state.args.message = defined({ text: changes.text, attributes: changes.attributes });
+});
+
+export const deleteComment = route({ rest: true }, (state, request) => {
+  commentKey(state, request);
+  set(state, "actor", queryValue(state, "actor"));
+});
+
+export const createReaction = route({ rest: true }, (state, request) => {
+  set(state, "actor", queryValue(state, "actor"));
+  copyFields(state, jsonBody(state, request), ["root", "reactionType"]);
+});
+
+export const getReactions = route({ rest: true }, (state, request) => {
+  const key = parseComplexKey(pathValue(request, "reactionKey"));
+  if (key === null || !key.has("entity") || key.size > 2 || (key.size === 2 && !key.has("actor"))) {
+    state.wire.error = SYNTAX;
+    state.args.entity = "";
+    return;
+  }
+  state.args.entity = key.get("entity");
+  if (key.has("actor")) {
+    state.args.single = true;
+    state.args.actor = key.get("actor");
+    return;
+  }
+  if (queryValue(state, "q") !== "entity") state.wire.error = "Invalid query parameters passed to request: q";
+  const sort = queryValue(state, "sort");
+  if (sort !== undefined) {
+    const parsed = parseComplexKey(sort);
+    if (parsed === null || parsed.size !== 1 || !parsed.has("value")) state.wire.error = "Invalid query parameters passed to request: sort";
+    else state.args.sort = parsed.get("value");
+  }
+  paging(state);
+});
+
+export const deleteReaction = route({ rest: true }, (state, request) => {
+  const key = parseComplexKey(pathValue(request, "reactionKey"));
+  if (key === null || key.size !== 2 || !key.has("actor") || !key.has("entity")) {
+    state.wire.error = SYNTAX;
+    state.args.actor = "";
+    state.args.entity = "";
+    return;
+  }
+  state.args.actor = key.get("actor");
+  state.args.entity = key.get("entity");
+});
+
+export const getSocialMetadata = route({ rest: true }, (state, request) => {
+  state.args.entity = pathValue(request, "entity");
+});
+
+export const updateSocialMetadata = route({ rest: true }, (state, request) => {
+  state.args.entity = pathValue(request, "entity");
+  set(state, "actor", queryValue(state, "actor"));
+  const body = jsonBody(state, request);
+  if (body === null) return;
+  const changes = isObject(body.patch) ? body.patch.$set : undefined;
+  if (!isObject(changes) || Object.keys(body).length !== 1 || Object.keys(body.patch).length !== 1) {
+    state.wire.fieldError = "patch";
+    return;
+  }
+  for (const key of Object.keys(changes)) {
+    if (key === "commentsState") state.args.commentsState = changes.commentsState;
+    else state.wire.fieldError = `patch/$set/${key}`;
+  }
+});
+
+export const getOrganization = route({ rest: true }, (state, request) => {
+  state.args.organizationId = pathValue(request, "organizationId");
+});
+
+export const findOrganizations = route({ rest: true }, (state) => {
+  if (queryValue(state, "q") !== "vanityName") state.wire.error = "Invalid query parameters passed to request: q";
+  state.args.vanityName = queryValue(state, "vanityName") ?? "";
+});
+
+export const findAcls = route({ rest: true }, (state) => {
+  for (const name of ["q", "organization", "role", "state"]) set(state, name, queryValue(state, name));
+  paging(state);
+});
+
+export const getNetworkSize = route({ rest: true }, (state, request) => {
+  state.args.entity = pathValue(request, "entity");
+  set(state, "edgeType", queryValue(state, "edgeType"));
+});
+
+export const getConnectionSize = route({ rest: false }, (state, request) => {
+  state.args.entity = pathValue(request, "personUrn");
+});

package/firedrill/tools/linkedin/lib/social.mjs

@@ -0,0 +1,25 @@
+// Reaction and comment summaries shared by social metadata and the home feed.
+import { reactionsOn, threadComments } from "./cascade.mjs";
+import { activityUrn, commentUrn } from "./urn.mjs";
+
+const TYPES = ["LIKE", "PRAISE", "APPRECIATION", "EMPATHY", "INTEREST", "ENTERTAINMENT"];
+
+export function reactionSummaries(reactions) {
+  const counts = new Map();
+  for (const reaction of reactions) counts.set(reaction.reactionType, (counts.get(reaction.reactionType) ?? 0) + 1);
+  const summaries = {};
+  for (const type of TYPES) if (counts.has(type)) summaries[type] = { reactionType: type, count: counts.get(type) };
+  return summaries;
+}
+
+/** Summaries of a post (comment null) or of one comment (its replies and reactions). */
+export function summarize(context, post, comment) {
+  const rows = threadComments(context, post.activityId);
+  if (comment !== null) {
+    const replies = rows.filter((row) => row.parentCommentId === comment.id).length;
+    const reactions = reactionsOn(context, commentUrn(comment.activityId, comment.id));
+    return { commentSummary: { count: replies, topLevelCount: replies }, reactions };
+  }
+  const topLevel = rows.filter((row) => row.parentCommentId === null).length;
+  return { commentSummary: { count: rows.length, topLevelCount: topLevel }, reactions: reactionsOn(context, activityUrn(post.activityId)) };
+}

package/firedrill/tools/linkedin/lib/store.mjs

@@ -0,0 +1,54 @@
+// Bounded state access: prefix scans that fail instead of truncating, virtual time and LinkedIn-style ids.
+import { fail } from "./errors.mjs";
+
+const BATCH = 1000;
+const DEFAULT_MAX = 5000;
+
+export function maxScanRows(context) {
+  const limits = context.state.get("meta", "limits");
+  const value = limits?.maxScanRows;
+  return Number.isInteger(value) && value >= 1 && value <= 10000 ? value : DEFAULT_MAX;
+}
+
+function overBound(context, max) {
+  fail(context, "INTERNAL_SERVER_ERROR", `state exceeds the supported bound of ${max} rows`);
+}
+
+/** All rows of a namespace whose row id starts with `prefix` (empty prefix = whole namespace), in row-id order. */
+export function scanPrefix(context, namespace, prefix = "") {
+  const max = maxScanRows(context);
+  const rows = [];
+  let after = prefix === "" ? undefined : prefix;
+  for (;;) {
+    const batch = context.state.scan(namespace, after === undefined ? { limit: BATCH } : { afterRowId: after, limit: BATCH });
+    const records = Array.isArray(batch) ? batch : (batch?.records ?? []);
+    for (const record of records) {
+      if (prefix !== "" && !record.rowId.startsWith(prefix)) return rows;
+      rows.push(record);
+      if (rows.length > max) overBound(context, max);
+    }
+    if (records.length < BATCH) return rows;
+    after = records[records.length - 1].rowId;
+  }
+}
+
+export const scanValues = (context, namespace, prefix = "") => scanPrefix(context, namespace, prefix).map((record) => record.value);
+
+export const nowMs = (context) => Math.floor(context.clock.nowUs() / 1000);
+
+/** Next LinkedIn-style id: creation time in the high bits, a per-world sequence in the low 22 bits. */
+export function nextId(context) {
+  const counters = context.state.get("meta", "counters") ?? { seq: 0 };
+  const seq = (Number.isInteger(counters.seq) ? counters.seq : 0) + 1;
+  context.state.put("meta", "counters", { seq });
+  const id = (BigInt(Math.max(0, nowMs(context))) << 22n) | BigInt(seq & 0x3fffff);
+  return id.toString();
+}
+
+/** Writes only when the stored value would change (replays do not spend the mutation budget). */
+export function putIfChanged(context, namespace, rowId, value) {
+  const current = context.state.get(namespace, rowId);
+  if (current !== null && JSON.stringify(current) === JSON.stringify(value)) return false;
+  context.state.put(namespace, rowId, value);
+  return true;
+}

package/firedrill/tools/linkedin/lib/text.mjs

@@ -0,0 +1,55 @@
+// Little text format helpers and UTF-8 byte accounting (no Buffer in behavior modules).
+
+const WORD = /[\p{L}\p{N}_]/u;
+const MAX_TAG = 100;
+
+/**
+ * Converts `#word` hashtags into LinkedIn's `{hashtag|\#|word}` template in one linear pass. A `#` preceded by a word
+ * character or a backslash (already templated text) is left alone, as are hashtags longer than 100 characters.
+ */
+export function templateHashtags(text) {
+  const chars = Array.from(text);
+  let out = "";
+  let i = 0;
+  while (i < chars.length) {
+    const ch = chars[i];
+    const prev = i > 0 ? chars[i - 1] : "";
+    if (ch === "#" && prev !== "\\" && !(prev !== "" && WORD.test(prev))) {
+      let j = i + 1;
+      while (j < chars.length && j - i - 1 <= MAX_TAG && WORD.test(chars[j])) j += 1;
+      const length = j - i - 1;
+      if (length >= 1 && length <= MAX_TAG) {
+        out += `{hashtag|\\#|${chars.slice(i + 1, j).join("")}}`;
+        i = j;
+        continue;
+      }
+    }
+    out += ch;
+    i += 1;
+  }
+  return out;
+}
+
+/** UTF-8 byte length of a string, computed from code points (lone surrogates count as the 3-byte replacement). */
+export function utf8Length(text) {
+  let bytes = 0;
+  for (let i = 0; i < text.length; i += 1) {
+    const code = text.charCodeAt(i);
+    if (code < 0x80) bytes += 1;
+    else if (code < 0x800) bytes += 2;
+    else if (code >= 0xd800 && code <= 0xdbff && i + 1 < text.length) {
+      const next = text.charCodeAt(i + 1);
+      if (next >= 0xdc00 && next <= 0xdfff) {
+        bytes += 4;
+        i += 1;
+      } else bytes += 3;
+    } else bytes += 3;
+  }
+  return bytes;
+}
+
+/** Encoded JSON size in UTF-8 bytes. */
+export const jsonBytes = (value) => utf8Length(JSON.stringify(value));
+
+/** Case-insensitive fold used by connection search (locale-independent). */
+export const fold = (text) => text.toLowerCase();

package/firedrill/tools/linkedin/lib/urn.mjs

@@ -0,0 +1,93 @@
+// Linear, non-backtracking parsers for the URNs and Rest.li complex keys this Tool accepts from callers.
+
+const MAX_URN = 200;
+const PERSON_ID = /^[A-Za-z0-9_-]{10}$/;
+const DIGITS = /^[0-9]{1,19}$/;
+const ORG_DIGITS = /^[1-9][0-9]{0,11}$/;
+
+/**
+ * Parses a URN. Returns `{ type, id, urn }` (comment URNs add `activityId` and `commentId`) or null when the text is not
+ * a well-formed URN of a type this Tool knows.
+ */
+export function parseUrn(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > MAX_URN) return null;
+  if (!value.startsWith("urn:li:")) return null;
+  const rest = value.slice(7);
+  const colon = rest.indexOf(":");
+  if (colon <= 0) return null;
+  const type = rest.slice(0, colon);
+  const id = rest.slice(colon + 1);
+  switch (type) {
+    case "person":
+      return PERSON_ID.test(id) ? { type, id, urn: value } : null;
+    case "organization":
+      return ORG_DIGITS.test(id) ? { type, id, urn: value } : null;
+    case "share":
+    case "ugcPost":
+    case "activity":
+      return DIGITS.test(id) ? { type, id, urn: value } : null;
+    case "comment": {
+      if (!id.startsWith("(urn:li:activity:") || !id.endsWith(")")) return null;
+      const inner = id.slice(17, -1);
+      const comma = inner.indexOf(",");
+      if (comma <= 0) return null;
+      const activityId = inner.slice(0, comma);
+      const commentId = inner.slice(comma + 1);
+      if (!DIGITS.test(activityId) || !DIGITS.test(commentId)) return null;
+      return { type, id: commentId, activityId, commentId, urn: value };
+    }
+    default:
+      return null;
+  }
+}
+
+/** Looks like an URN (prefix present) even when the id part is malformed: decides INVALID_URN_ID vs INVALID_URN_TYPE. */
+export function urnType(value) {
+  if (typeof value !== "string" || !value.startsWith("urn:li:") || value.length > MAX_URN) return null;
+  const rest = value.slice(7);
+  const colon = rest.indexOf(":");
+  return colon > 0 ? rest.slice(0, colon) : null;
+}
+
+export const personUrn = (personId) => `urn:li:person:${personId}`;
+export const organizationUrn = (organizationId) => `urn:li:organization:${organizationId}`;
+export const activityUrn = (activityId) => `urn:li:activity:${activityId}`;
+export const postUrnOf = (post) => `urn:li:${post.kind}:${post.id}`;
+export const commentUrn = (activityId, commentId) => `urn:li:comment:(urn:li:activity:${activityId},${commentId})`;
+export const reactionId = (actor, entity) => `urn:li:reaction:(${actor},${entity})`;
+
+/**
+ * Parses a Rest.li complex key `(name:value,name:value)`, splitting only on top-level commas so nested comment URNs survive.
+ * Returns a Map of name → value, or null when the text is not a well-formed key. Names are lowercase letters only.
+ */
+export function parseComplexKey(text) {
+  if (typeof text !== "string" || text.length < 3 || text.length > 512) return null;
+  if (text[0] !== "(" || text[text.length - 1] !== ")") return null;
+  const body = text.slice(1, -1);
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < body.length; i += 1) {
+    const ch = body[i];
+    if (ch === "(") depth += 1;
+    else if (ch === ")") {
+      depth -= 1;
+      if (depth < 0) return null;
+    } else if (ch === "," && depth === 0) {
+      parts.push(body.slice(start, i));
+      start = i + 1;
+    }
+  }
+  if (depth !== 0) return null;
+  parts.push(body.slice(start));
+  if (parts.length > 4) return null;
+  const map = new Map();
+  for (const part of parts) {
+    const colon = part.indexOf(":");
+    if (colon <= 0) return null;
+    const name = part.slice(0, colon);
+    if (!/^[a-z]{1,20}$/i.test(name) || map.has(name)) return null;
+    map.set(name, part.slice(colon + 1));
+  }
+  return map;
+}

package/firedrill/tools/linkedin/lib/wire.mjs

@@ -0,0 +1,125 @@
+// Pure HTTP helpers: request inspection that never throws, and LinkedIn success/error responses.
+// Problems a decoder finds travel to the handler as `wire.error` (→ BAD_REQUEST) or `wire.fieldError` (→ INVALID_VALUE_FOR_FIELD),
+// so every refusal is answered in LinkedIn's envelope.
+import { ERRORS } from "./errors.mjs";
+
+const MAX_DEPTH = 512;
+const MAX_REPEAT = 20;
+const BANNED = new Set(["__proto__", "constructor", "prototype"]);
+const PROTOCOL = { "x-restli-protocol-version": "2.0.0" };
+
+export const isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const last = (values) => (Array.isArray(values) && values.length > 0 ? values[values.length - 1] : undefined);
+const clip = (value) => (typeof value === "string" ? value.slice(0, 64) : null);
+
+/** Iterative depth and reserved-key check for a JSON body. */
+export function shapeProblem(value) {
+  const stack = [[value, 1]];
+  while (stack.length > 0) {
+    const [node, depth] = stack.pop();
+    if (depth > MAX_DEPTH) return "Request body is nested too deeply";
+    if (node === null || typeof node !== "object") continue;
+    if (!Array.isArray(node)) for (const key of Object.keys(node)) if (BANNED.has(key)) return `Unpermitted fields present in REQUEST_BODY: [/${key}]`;
+    for (const child of Array.isArray(node) ? node : Object.values(node)) if (child !== null && typeof child === "object") stack.push([child, depth + 1]);
+  }
+  return null;
+}
+
+/** Starts a request decode: the `wire` block plus query-level checks shared by every route. */
+export function begin(request, { rest, requireMethod = false }) {
+  const headers = isObject(request.headers) ? request.headers : {};
+  const query = isObject(request.query) ? request.query : {};
+  const wire = {
+    route: String(request.routeId ?? "").slice(0, 64), rest, linkedinVersion: clip(last(headers["linkedin-version"])),
+    restliMethod: clip(last(headers["x-restli-method"])), requireMethod, error: null, fieldError: null,
+  };
+  for (const name of Object.keys(query)) {
+    const values = query[name];
+    if (Array.isArray(values) && values.length > MAX_REPEAT) wire.error = "Invalid query parameters passed to request";
+    if (name === "ids") wire.error = "Batch get is not supported: Invalid query parameters passed to request";
+  }
+  return { wire, args: {}, query };
+}
+
+/** Reads one query value; U+FFFD (mangled percent-encoding) marks the request invalid. */
+export function queryValue(state, name) {
+  const value = last(state.query[name]);
+  if (value === undefined) return undefined;
+  if (typeof value !== "string" || value.includes("�")) {
+    state.wire.error = "Invalid query parameters passed to request";
+    return undefined;
+  }
+  return value;
+}
+
+/** Decimal integer query value (`start`, `count`). */
+export function queryInt(state, name) {
+  const value = queryValue(state, name);
+  if (value === undefined) return undefined;
+  if (!/^[0-9]{1,7}$/.test(value)) {
+    state.wire.error = `Invalid query parameters passed to request: ${name}`;
+    return undefined;
+  }
+  return Number(value);
+}
+
+/** The JSON object body, or null after recording a refusal (absent bodies read as an empty object). */
+export function jsonBody(state, request) {
+  const body = request.body;
+  if (!isObject(body) || body.kind === "none") return {};
+  if (body.kind !== "json" || !isObject(body.value)) {
+    state.wire.error = "Request body must be a JSON object";
+    return null;
+  }
+  const problem = shapeProblem(body.value);
+  if (problem !== null) {
+    state.wire.error = problem;
+    return null;
+  }
+  return body.value;
+}
+
+/** Copies allowed body fields; any other field is refused like LinkedIn's unpermitted-field check. */
+export function copyFields(state, body, allowed) {
+  if (body === null) return;
+  for (const key of Object.keys(body)) {
+    if (allowed.includes(key)) state.args[key] = body[key];
+    else if (state.wire.error === null) state.wire.error = `Unpermitted fields present in REQUEST_BODY: [/${key}]`;
+  }
+}
+
+export const pathValue = (request, name) => (isObject(request.path) && typeof request.path[name] === "string" ? request.path[name] : "");
+
+export const finish = (state) => ({ arguments: { ...state.args, wire: state.wire } });
+
+function errorResponse({ invocation, outcome }, v2) {
+  const error = isObject(outcome?.error) ? outcome.error : {};
+  let code = String(error.code ?? "");
+  code = code.slice(code.lastIndexOf(".") + 1);
+  let message = typeof error.message === "string" && error.message !== "" ? error.message : "Request could not be processed";
+  if (outcome?.status === "invalid") {
+    code = "BAD_REQUEST";
+    const issue = Array.isArray(error.issues) && error.issues.length > 0 ? error.issues[0] : null;
+    const where = issue !== null && Array.isArray(issue.path) ? issue.path.join("/") : "";
+    message = issue === null ? "Invalid request" : `Invalid value for field ${where}: ${String(issue.message ?? "invalid value")}`;
+  } else if (outcome?.status === "denied") {
+    code = "ACCESS_DENIED";
+    message = "Not enough permissions to access this resource";
+  } else if (outcome?.status === "unsupported") {
+    code = "NOT_FOUND";
+  }
+  const [status, serviceErrorCode] = ERRORS.get(code) ?? [500, 0];
+  if (!ERRORS.has(code)) code = "INTERNAL_SERVER_ERROR";
+  void invocation;
+  const body = v2 ? { status, serviceErrorCode, message } : { status, serviceErrorCode, code, message };
+  return { headers: PROTOCOL, body: { kind: "json", value: body } };
+}
+
+/** Encoder factory: `shape(value)` → `{ headers?, body? }` for the success case; `v2` selects the envelope without `code`. */
+export function encoder(shape, v2 = false) {
+  return (result) => {
+    if (result.outcome?.status !== "ok") return errorResponse(result, v2);
+    const { headers = {}, body } = shape(result.outcome.value);
+    return { headers: { ...PROTOCOL, ...headers }, body: body === undefined ? { kind: "empty" } : { kind: "json", value: body } };
+  };
+}