@sprid/scout 0.1.0

package/src/sheet.js

@@ -0,0 +1,106 @@
+"use strict";
+
+// Frames, tiled into one readable sheet.
+//
+// A model cannot watch thirty seconds of video, and a teardown does not need it
+// to. What decides whether a reel is watched happens in its first seconds, so
+// the default offsets are dense at the start and thin out afterwards: the cover
+// frame, then the moments where a viewer either stays or leaves. The frames
+// themselves come from the player (see frames.js), not from a downloaded file.
+//
+// They are evidence, exactly like the slideshow images beside them: there so a
+// structure can be described and rebuilt, never republished.
+
+const fs = require("node:fs");
+const path = require("node:path");
+const util = require("node:util");
+const { execFile } = require("node:child_process");
+
+const run = util.promisify(execFile);
+
+/** Frame 0 is the cover; 1-3s is the skip window; the rest is shape. */
+const DEFAULT_OFFSETS = [0, 1, 2, 5, 10];
+
+class FfmpegMissingError extends Error {
+  constructor() {
+    super(
+      "ffmpeg is not installed, so frames cannot be taken from a video. Install it (brew install ffmpeg) " +
+        "or pull the video without a sheet."
+    );
+    this.name = "FfmpegMissingError";
+  }
+}
+
+async function ffmpegAvailable() {
+  try {
+    await run("ffmpeg", ["-version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * The same sheet, from frames that were captured rather than extracted: tiles
+ * left to right in the order given, a white gutter between them, and the
+ * timecodes returned as data because `drawtext` needs a freetype-enabled ffmpeg
+ * and ordinary Homebrew builds do not have one.
+ */
+async function sheetFromFrames(frames, outFile) {
+  if (frames.length === 0) return null;
+  if (!(await ffmpegAvailable())) throw new FfmpegMissingError();
+  const inputs = frames.flatMap(({ file }) => ["-i", file]);
+  const gutter = frames.map((_, i) => `[${i}:v]pad=iw+6:ih:6:0:color=white[v${i}]`).join(";");
+  const chain = frames.map((_, i) => `[v${i}]`).join("");
+  await run("ffmpeg", [
+    "-v", "error", ...inputs,
+    "-filter_complex", `${gutter};${chain}hstack=inputs=${frames.length}[out]`,
+    "-map", "[out]", "-y", outFile,
+  ]);
+  return { file: outFile, offsets: frames.map((f) => f.at) };
+}
+
+/**
+ * A wall: the same moment across many posts, four to a row.
+ *
+ * A sheet reads one post down time. A wall reads one instant across a niche,
+ * and it is where a pattern becomes visible - twelve covers side by side say
+ * more about what a category's opening frame does than twelve teardowns do.
+ *
+ * Rows are stacked rather than tiled in one pass, because `xstack` needs every
+ * input to agree on size and these come from different posts.
+ */
+async function wallFromFrames(frames, outFile, { cols = 4, cellWidth = 300 } = {}) {
+  if (frames.length === 0) return null;
+  if (!(await ffmpegAvailable())) throw new FfmpegMissingError();
+  const rows = Math.ceil(frames.length / cols);
+  const inputs = frames.flatMap(({ file }) => ["-i", file]);
+  const parts = [];
+  // One scale per cell so a stray resolution cannot break the stack, then a
+  // gutter, then the rows, then the column.
+  frames.forEach((_, i) => {
+    parts.push(`[${i}:v]scale=${cellWidth}:-2,pad=iw+6:ih+6:3:3:color=white[c${i}]`);
+  });
+  const rowLabels = [];
+  for (let r = 0; r < rows; r++) {
+    const cells = frames.slice(r * cols, (r + 1) * cols).map((_, i) => `[c${r * cols + i}]`);
+    if (cells.length === 0) continue;
+    const label = `[r${r}]`;
+    parts.push(cells.length === 1 ? `${cells[0]}null${label}` : `${cells.join("")}hstack=inputs=${cells.length}${label}`);
+    rowLabels.push(label);
+  }
+  // A short last row would refuse to stack against the full ones, so it is
+  // padded out to the same width instead of being dropped.
+  if (rowLabels.length > 1) {
+    const full = cols * (cellWidth + 6);
+    parts.push(`${rowLabels[rowLabels.length - 1]}pad=${full}:ih:0:0:color=white[rlast]`);
+    rowLabels[rowLabels.length - 1] = "[rlast]";
+    parts.push(`${rowLabels.join("")}vstack=inputs=${rowLabels.length}[out]`);
+  } else {
+    parts.push(`${rowLabels[0]}null[out]`);
+  }
+  await run("ffmpeg", ["-v", "error", ...inputs, "-filter_complex", parts.join(";"), "-map", "[out]", "-y", outFile]);
+  return { file: outFile, cells: frames.length, cols };
+}
+
+module.exports = { sheetFromFrames, wallFromFrames, ffmpegAvailable, DEFAULT_OFFSETS, FfmpegMissingError };

package/src/store.js

@@ -0,0 +1,130 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { RUNS_DIR, LIBRARY_FILE, ensureDirs } = require("./config");
+
+// Everything lives in plain JSON on the user's disk. Nothing leaves the
+// machine, and a run's accounts are written the moment they are measured, so a
+// run that dies half way still leaves behind everything it had read.
+
+function writeAtomic(file, value) {
+  ensureDirs();
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(value, null, 2));
+  fs.renameSync(tmp, file);
+}
+
+function readJson(file, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+function runFile(runId) {
+  return path.join(RUNS_DIR, `${runId}.json`);
+}
+
+function saveRun(run) {
+  writeAtomic(runFile(run.id), run);
+}
+
+function loadRun(runId) {
+  return readJson(runFile(runId), null);
+}
+
+function listRuns() {
+  ensureDirs();
+  const runs = [];
+  for (const entry of fs.readdirSync(RUNS_DIR)) {
+    if (!entry.endsWith(".json")) continue;
+    const run = readJson(path.join(RUNS_DIR, entry), null);
+    if (run) runs.push(run);
+  }
+  runs.sort((a, b) => (b.started_at ?? "").localeCompare(a.started_at ?? ""));
+  return runs;
+}
+
+// The library is the union of every account a discovery run has ever passed.
+// A later run measuring the same account overwrites the older reading, because
+// the newer numbers are the truer ones.
+
+function readLibrary() {
+  return readJson(LIBRARY_FILE, { accounts: {} });
+}
+
+function fileAccounts(runId, runName, accounts) {
+  const library = readLibrary();
+  const foundAt = new Date().toISOString();
+  for (const account of accounts) {
+    if (!account.username) continue;
+    library.accounts[account.username.toLowerCase()] = {
+      ...account,
+      run_id: runId,
+      run_name: runName,
+      found_at: foundAt,
+    };
+  }
+  writeAtomic(LIBRARY_FILE, library);
+  return Object.keys(library.accounts).length;
+}
+
+function getAccount(username) {
+  const key = String(username).replace(/^@+/, "").toLowerCase();
+  return readLibrary().accounts[key] ?? null;
+}
+
+const SORTS = {
+  found: (a, b) => (b.found_at ?? "").localeCompare(a.found_at ?? ""),
+  avg_views: (a, b) => windowedViews(b) - windowedViews(a),
+  followers: (a, b) => (b.followers ?? 0) - (a.followers ?? 0),
+  slideshow_ratio: (a, b) =>
+    (b.metrics?.slideshow_ratio ?? 0) - (a.metrics?.slideshow_ratio ?? 0),
+  view_follower_ratio: (a, b) =>
+    (b.metrics?.view_follower_ratio ?? 0) - (a.metrics?.view_follower_ratio ?? 0),
+  consistency_score: (a, b) =>
+    (b.metrics?.consistency_score ?? 0) - (a.metrics?.consistency_score ?? 0),
+  last_post_days_ago: (a, b) =>
+    (a.metrics?.last_post_days_ago ?? 1e9) - (b.metrics?.last_post_days_ago ?? 1e9),
+};
+
+/** The averaged-views field carries its window in its name, so find it by shape. */
+function windowedViews(account) {
+  const metrics = account.metrics ?? {};
+  const key = Object.keys(metrics).find((k) => k.startsWith("avg_views_last_"));
+  return key ? metrics[key] ?? 0 : 0;
+}
+
+function searchAccounts({ query, runId, sort = "found", limit = 25, offset = 0 }) {
+  let rows = Object.values(readLibrary().accounts);
+  if (runId) rows = rows.filter((row) => row.run_id === runId);
+  if (query) {
+    const needle = query.toLowerCase();
+    rows = rows.filter((row) => {
+      const hay = [
+        row.username,
+        row.display_name,
+        row.bio,
+        ...(row.metrics?.top_hashtags ?? []),
+      ]
+        .join(" ")
+        .toLowerCase();
+      return hay.includes(needle);
+    });
+  }
+  rows.sort(SORTS[sort] ?? SORTS.found);
+  return { total: rows.length, accounts: rows.slice(offset, offset + limit) };
+}
+
+module.exports = {
+  saveRun,
+  loadRun,
+  listRuns,
+  fileAccounts,
+  getAccount,
+  searchAccounts,
+  windowedViews,
+  SORT_ORDERS: Object.keys(SORTS),
+};

package/src/tiktok.js

@@ -0,0 +1,391 @@
+"use strict";
+
+const https = require("node:https");
+const { BROWSER_UA } = require("./config");
+
+// TikTok is read the way any person reads it: pages are loaded and scrolled,
+// and the JSON the page fetches for itself is read off the wire. Nothing here
+// calls a private API directly.
+
+const FEED_ENDPOINTS = ["/api/post/item_list/", "/api/user/post/"];
+const DETAIL_ENDPOINT = "/api/user/detail/";
+const ITEM_ENDPOINTS = ["/api/item/detail", "/aweme/detail"];
+
+const TOP = {
+  id: "top",
+  label: "Top",
+  url: (keyword) => `https://www.tiktok.com/search?q=${encodeURIComponent(keyword)}&type=0`,
+  items: (payload) => (payload.data ?? []).map((wrapper) => wrapper.item ?? {}),
+  followers: (item) => item.author?.followerCount ?? 0,
+  confirm: [
+    '[data-e2e="search-top-tab"]',
+    'a[href*="type=0"]',
+    '[role="tab"]:has-text("Top")',
+    'button:has-text("Top")',
+    'span:has-text("Top")',
+  ],
+};
+
+const PHOTO = {
+  id: "photo",
+  label: "Photo",
+  url: (keyword) => `https://www.tiktok.com/search/photo?q=${encodeURIComponent(keyword)}`,
+  items: (payload) => payload.item_list ?? [],
+  followers: (item) => item.authorStats?.followerCount ?? item.author?.followerCount ?? 0,
+};
+
+function round(value, digits = 0) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+
+function parseCount(text) {
+  if (!text) return 0;
+  const cleaned = text.trim().toUpperCase().replace(/,/g, "").replace(/\s/g, "");
+  const value = parseFloat(cleaned);
+  if (Number.isNaN(value)) return 0;
+  if (cleaned.endsWith("M")) return Math.trunc(value * 1e6);
+  if (cleaned.endsWith("K")) return Math.trunc(value * 1e3);
+  return Math.trunc(value);
+}
+
+function fetchHtml(url, timeoutMs = 15_000) {
+  return new Promise((resolve, reject) => {
+    const request = https.get(
+      url,
+      { headers: { "User-Agent": BROWSER_UA, "Accept-Language": "en-US,en;q=0.9" } },
+      (response) => {
+        const location = response.headers.location;
+        if (response.statusCode >= 300 && response.statusCode < 400 && location) {
+          response.resume();
+          fetchHtml(new URL(location, url).toString(), timeoutMs).then(resolve, reject);
+          return;
+        }
+        let body = "";
+        response.setEncoding("utf8");
+        response.on("data", (chunk) => (body += chunk));
+        response.on("end", () => resolve(body));
+      }
+    );
+    request.setTimeout(timeoutMs, () => request.destroy(new Error(`Timed out fetching ${url}`)));
+    request.on("error", reject);
+  });
+}
+
+/** The server-rendered blob carries the account totals the feed JSON rounds off. */
+function extractEmbeddedUser(html) {
+  const match = html.match(/id="__UNIVERSAL_DATA_FOR_REHYDRATION__"[^>]*>([\s\S]*?)<\/script>/);
+  if (!match) return {};
+  try {
+    const parsed = JSON.parse(match[1]);
+    const info = parsed.__DEFAULT_SCOPE__?.["webapp.user-detail"]?.userInfo ?? {};
+    const user = info.user ?? {};
+    const stats = { ...info.stats, ...info.statsV2 };
+    const count = (value) => {
+      const n = typeof value === "string" ? parseInt(value, 10) : value;
+      if (typeof n !== "number" || !Number.isFinite(n) || n < 0) return undefined;
+      return n;
+    };
+    const text = (value) => (typeof value === "string" ? value : undefined);
+    return {
+      nickname: text(user.nickname),
+      signature: text(user.signature),
+      verified: Boolean(user.verified),
+      followerCount: count(stats.followerCount),
+      // Two names for the like total, and on a payload with no statsV2 the
+      // first of them is the one that wraps.
+      heartCount: count(stats.heartCount) ?? count(stats.heart),
+      videoCount: count(stats.videoCount),
+    };
+  } catch {
+    return {};
+  }
+}
+
+async function loadAccountDetails(username) {
+  try {
+    return extractEmbeddedUser(await fetchHtml(`https://www.tiktok.com/@${username}`));
+  } catch {
+    return {};
+  }
+}
+
+function extractItem(raw) {
+  if (!raw) return null;
+  try {
+    const scope = JSON.parse(raw).__DEFAULT_SCOPE__;
+    if (!scope) return null;
+    const detail = scope["webapp.video-detail"] ?? scope["webapp.photo-detail"];
+    const item = detail?.itemInfo?.itemStruct;
+    return item && typeof item === "object" ? item : null;
+  } catch {
+    return null;
+  }
+}
+
+// ---- measurement -----------------------------------------------------------
+
+function ratioOf(samples) {
+  if (samples.length === 0) return { ratio: 0, ratioPct: 0 };
+  const slideshows = samples.filter((s) => s.img).length;
+  const ratio = slideshows / samples.length;
+  return { ratio, ratioPct: round(ratio * 100, 1) };
+}
+
+/**
+ * The window is a question about a stretch of time. An account that posted
+ * nothing inside it reports that fact, never a zero average.
+ */
+function windowStats(samples, avgViewsDays, anchorSeconds) {
+  const cutoff = anchorSeconds - avgViewsDays * 86400;
+  const recent = samples.filter((s) => s.t >= cutoff);
+  const totalViewsWindow = recent.reduce((sum, s) => sum + s.v, 0);
+  const noPostsInWindow = recent.length === 0;
+  const avgViews = noPostsInWindow ? null : totalViewsWindow / recent.length;
+  return { avgViews, totalViewsWindow, noPostsInWindow };
+}
+
+function decideVerdict({
+  followers,
+  ratio,
+  ratioPct,
+  avgViews,
+  totalViewsWindow,
+  noPostsInWindow,
+  filters,
+}) {
+  const failed = [];
+  if (filters.minFollowers > 0 && followers < filters.minFollowers) {
+    failed.push({ filter: "followers", measured: followers, threshold: filters.minFollowers });
+  }
+  if (ratio < filters.minRatio) {
+    failed.push({
+      filter: "slideshow_ratio",
+      measured: ratioPct,
+      threshold: round(filters.minRatio * 100, 1),
+    });
+  }
+  if (!noPostsInWindow && avgViews !== null) {
+    const avg = Math.trunc(avgViews);
+    if (filters.minAvgViews > 0 && avgViews < filters.minAvgViews) {
+      failed.push({ filter: "avg_views", measured: avg, threshold: filters.minAvgViews });
+    }
+    if (filters.minTotalViews > 0 && totalViewsWindow < filters.minTotalViews) {
+      failed.push({
+        filter: "total_views",
+        measured: totalViewsWindow,
+        threshold: filters.minTotalViews,
+      });
+    }
+  }
+  const windowFloorRequested = filters.minAvgViews > 0 || filters.minTotalViews > 0;
+  const windowBlocked = noPostsInWindow && windowFloorRequested;
+  const passed = failed.length === 0 && !windowBlocked;
+  const viewsPerFollower =
+    avgViews !== null && followers > 0 ? round(avgViews / followers, 2) : null;
+  return { passed, failed, noPostsInWindow, unmeasured: false, viewsPerFollower };
+}
+
+/** Re-judge a measured account against new filters, with no browsing at all. */
+function reevaluate(account, filters) {
+  const samples = account.samples ?? [];
+  const { ratio, ratioPct } = ratioOf(samples);
+  const w = windowStats(samples, filters.avgViewsDays, account.measuredAt);
+  const verdict = decideVerdict({
+    followers: account.followers ?? 0,
+    ratio,
+    ratioPct,
+    avgViews: w.avgViews,
+    totalViewsWindow: w.totalViewsWindow,
+    noPostsInWindow: w.noPostsInWindow,
+    filters,
+  });
+  return { verdict, ...w, ratioPct };
+}
+
+const NEAR_MISS_MARGIN = 0.1;
+
+/**
+ * Marks are arithmetic, never judgment. Whether one matters is the caller's
+ * call. The outlier bar is this run's own 90th percentile, so it means
+ * "unusual here" rather than "unusual in general".
+ */
+function flagOutliers(accounts) {
+  const ratios = accounts
+    .map((a) => a.verdict?.viewsPerFollower)
+    .filter((v) => typeof v === "number")
+    .sort((a, b) => a - b);
+  const threshold = ratios.length >= 10 ? ratios[Math.floor(0.9 * (ratios.length - 1))] : null;
+  for (const account of accounts) {
+    const v = account.verdict;
+    if (!v) continue;
+    v.highViewsPerFollower =
+      threshold !== null && v.viewsPerFollower !== null && v.viewsPerFollower >= threshold;
+    v.nearMiss =
+      !v.unmeasured &&
+      v.failed.length === 1 &&
+      v.failed[0].measured >= v.failed[0].threshold * (1 - NEAR_MISS_MARGIN);
+  }
+}
+
+function breakdownOf(accounts) {
+  const b = {
+    below_slideshow_ratio: 0,
+    below_avg_views: 0,
+    below_followers: 0,
+    below_total_views: 0,
+    no_posts_in_window: 0,
+    unmeasured: 0,
+  };
+  for (const account of accounts) {
+    const v = account.verdict;
+    if (!v || v.passed) continue;
+    if (v.unmeasured) {
+      b.unmeasured += 1;
+      continue;
+    }
+    for (const failure of v.failed) {
+      if (failure.filter === "slideshow_ratio") b.below_slideshow_ratio += 1;
+      else if (failure.filter === "avg_views") b.below_avg_views += 1;
+      else if (failure.filter === "followers") b.below_followers += 1;
+      else if (failure.filter === "total_views") b.below_total_views += 1;
+    }
+    if (v.failed.length === 0 && v.noPostsInWindow) b.no_posts_in_window += 1;
+  }
+  return b;
+}
+
+/**
+ * Turn a page of raw posts into the measurements the filters are judged on.
+ * Everything derived lives here so analysis and discovery agree by construction.
+ */
+function measurePosts({ posts, followers, avgViewsDays, details = {}, now = Date.now() / 1000 }) {
+  const timestamps = posts
+    .map((p) => p.createTime ?? 0)
+    .filter(Boolean)
+    .sort((a, b) => b - a);
+  if (timestamps.length === 0) return null;
+
+  const slideshows = posts.filter((p) => p.imagePost);
+  const { ratio, ratioPct } = ratioOf(
+    posts.map((p) => ({ img: Boolean(p.imagePost), t: p.createTime ?? 0, v: p.stats?.playCount ?? 0 }))
+  );
+  const samples = posts.map((p) => ({
+    t: p.createTime ?? 0,
+    v: p.stats?.playCount ?? 0,
+    img: Boolean(p.imagePost),
+  }));
+  const { avgViews, totalViewsWindow, noPostsInWindow } = windowStats(samples, avgViewsDays, now);
+
+  const totalViews = posts.reduce((sum, p) => sum + (p.stats?.playCount ?? 1), 0) || 1;
+  const totalComments = posts.reduce((sum, p) => sum + (p.stats?.commentCount ?? 0), 0);
+  const recent90 = posts.filter((p) => (p.createTime ?? 0) >= now - 90 * 86400);
+
+  let consistency = 0;
+  if (timestamps.length > 1) {
+    const gaps = timestamps.slice(0, -1).map((t, i) => (t - timestamps[i + 1]) / 86400);
+    const avgGap = gaps.reduce((a, b) => a + b, 0) / gaps.length;
+    const variance = gaps.reduce((sum, g) => sum + (g - avgGap) ** 2, 0) / gaps.length;
+    consistency = round(Math.max(0, 10 - Math.sqrt(variance)), 1);
+  }
+
+  const slideCounts = slideshows.map((p) => p.imagePost?.images?.length ?? 0);
+  const avgSlides = slideCounts.length
+    ? round(slideCounts.reduce((a, b) => a + b, 0) / slideCounts.length, 1)
+    : 0;
+
+  const hashtagFreq = new Map();
+  for (const post of posts) {
+    for (const tag of post.textExtra ?? []) {
+      if (tag.hashtagName) hashtagFreq.set(tag.hashtagName, (hashtagFreq.get(tag.hashtagName) ?? 0) + 1);
+    }
+  }
+  const topHashtags = [...hashtagFreq.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10)
+    .map(([tag]) => tag);
+
+  const cutoff = now - avgViewsDays * 86400;
+  const recentSlideshows = posts.filter((p) => (p.createTime ?? 0) >= cutoff && p.imagePost);
+  const captions = (recentSlideshows.length ? recentSlideshows : slideshows)
+    .slice(0, 15)
+    .map((p) => (p.desc ?? "").trim())
+    .filter(Boolean);
+
+  return {
+    ratio,
+    ratioPct,
+    avgViews,
+    totalViewsWindow,
+    noPostsInWindow,
+    samples,
+    captions,
+    metrics: {
+      total_posts_real: details.videoCount ?? posts.length,
+      scraped_posts: posts.length,
+      slideshow_count: slideshows.length,
+      slideshow_ratio: ratioPct,
+      // Null, not zero, when the window was empty: a reader must never mistake
+      // "did not post" for "was seen zero times".
+      [`avg_views_last_${avgViewsDays}d`]: noPostsInWindow ? null : Math.trunc(avgViews ?? 0),
+      [`total_views_last_${avgViewsDays}d`]: noPostsInWindow ? null : Math.trunc(totalViewsWindow),
+      comment_ratio: round((totalComments / totalViews) * 100, 3),
+      view_follower_ratio: avgViews !== null && followers > 0 ? round(avgViews / followers, 2) : null,
+      posts_per_week: round(recent90.length / (90 / 7), 2),
+      consistency_score: consistency,
+      last_post_days_ago: round((now - timestamps[0]) / 86400, 1),
+      avg_slides_per_slideshow: avgSlides,
+      top_hashtags: topHashtags,
+    },
+  };
+}
+
+function postSummary(post) {
+  const stats = post.stats ?? {};
+  const views = stats.playCount ?? 0;
+  const interactions =
+    (stats.diggCount ?? 0) +
+    (stats.commentCount ?? 0) +
+    (stats.shareCount ?? 0) +
+    (stats.collectCount ?? 0);
+  const username = post.author?.uniqueId ?? "";
+  const isSlideshow = Boolean(post.imagePost);
+  return {
+    id: post.id,
+    type: isSlideshow ? "slideshow" : "video",
+    url: `https://www.tiktok.com/@${username}/${isSlideshow ? "photo" : "video"}/${post.id}`,
+    description: (post.desc ?? "").slice(0, 300),
+    hashtags: (post.textExtra ?? []).map((t) => t.hashtagName).filter(Boolean),
+    views,
+    likes: stats.diggCount ?? 0,
+    comments: stats.commentCount ?? 0,
+    shares: stats.shareCount ?? 0,
+    favorites: stats.collectCount ?? 0,
+    engagement_rate: views ? round((interactions / views) * 100, 4) : 0,
+    slide_count: post.imagePost?.images?.length ?? 0,
+    published_at: post.createTime ? new Date(post.createTime * 1000).toISOString() : null,
+  };
+}
+
+module.exports = {
+  TOP,
+  PHOTO,
+  FEED_ENDPOINTS,
+  DETAIL_ENDPOINT,
+  ITEM_ENDPOINTS,
+  round,
+  parseCount,
+  fetchHtml,
+  extractEmbeddedUser,
+  extractItem,
+  loadAccountDetails,
+  ratioOf,
+  windowStats,
+  decideVerdict,
+  reevaluate,
+  flagOutliers,
+  breakdownOf,
+  measurePosts,
+  postSummary,
+  NEAR_MISS_MARGIN,
+};