thursday-agent 0.9.0 → 0.10.0

package/seed-skills/insta/instagram/scripts/media.mjs

@@ -0,0 +1,104 @@
+/**
+ * One post as these scripts report it, from the media record Instagram's own
+ * pages fetch (a profile's timeline, a search). `media` is sent into the browser
+ * session as source (lib inPage helpers), so it uses nothing from outside itself.
+ */
+export function media(o) {
+  const slides = o.carousel_media ?? [];
+  const first = slides[0] ?? o;
+  const w = first.original_width ?? null;
+  const h = first.original_height ?? null;
+  const named = [
+    ["1:1", 1],
+    ["4:5", 0.8],
+    ["3:4", 0.75],
+    ["2:3", 0.667],
+    ["9:16", 0.5625],
+    ["1.91:1", 1.91],
+    ["16:9", 1.778],
+  ];
+  const r = w && h ? w / h : null;
+  const ratio = r
+    ? (named.find(([, v]) => Math.abs(v - r) < 0.02)?.[0] ?? r.toFixed(2))
+    : null;
+  const caption = o.caption?.text ?? "";
+  const reel = o.media_type === 2;
+  const image = (m) =>
+    m.image_versions2?.candidates?.[0]?.url ?? m.display_uri ?? null;
+  return {
+    url: `https://www.instagram.com/${reel ? "reel" : "p"}/${o.code}/`,
+    type: o.media_type === 8 ? "carousel" : reel ? "reel" : "image",
+    at: o.taken_at ? o.taken_at * 1000 : null,
+    owner: o.user?.username ?? null,
+    pinned: (o.timeline_pinned_user_ids ?? []).length > 0,
+    likes: o.like_and_view_counts_disabled ? null : (o.like_count ?? null),
+    comments: o.comment_count ?? null,
+    views: o.play_count ?? o.ig_play_count ?? o.view_count ?? null,
+    slides: o.carousel_media_count ?? (slides.length || 1),
+    ratio,
+    size: w && h ? `${w}x${h}` : null,
+    hook: caption.split("\n")[0].slice(0, 140),
+    captionChars: caption.length,
+    hashtags: (caption.match(/#[\p{L}\p{N}_]+/gu) ?? []).length,
+    caption,
+    music: o.clips_metadata?.music_info?.music_asset_info?.title ?? null,
+    cover: image(first),
+    images: slides.length ? slides.map(image) : [image(o)],
+  };
+}
+
+const median = (xs) => {
+  const s = xs.filter((x) => x != null).sort((a, b) => a - b);
+  return s.length ? s[Math.floor((s.length - 1) / 2)] : null;
+};
+
+export const short = (n) =>
+  n == null
+    ? "-"
+    : n >= 1e6
+      ? `${(n / 1e6).toFixed(1)}M`
+      : n >= 1e3
+        ? `${(n / 1e3).toFixed(1)}k`
+        : String(n);
+
+const day = (ms) => (ms ? new Date(ms).toISOString().slice(0, 10) : "?");
+
+/** One line a post: what it is, how it did, and its first caption line. */
+export const postLine = (p, i) =>
+  `${String(i + 1).padStart(2)} ${day(p.at)} ${p.type}${p.type === "carousel" ? `×${p.slides}` : ""} ${p.ratio ?? "?"} ` +
+  `likes ${short(p.likes)} comments ${short(p.comments)}${p.views ? ` views ${short(p.views)}` : ""} tags ${p.hashtags} caption ${p.captionChars}` +
+  `${p.pinned ? " pinned" : ""}${p.owner ? ` @${p.owner}` : ""} ${p.url} | ${p.hook.replace(/\s+/g, " ").slice(0, 70)}`;
+
+/** How a set of posts is made, in a few lines: the pattern to copy. */
+export function patterns(posts) {
+  if (!posts.length) return ["no posts"];
+  const count = (f) => posts.filter(f).length;
+  const tally = (key) =>
+    Object.entries(
+      posts.reduce((all, p) => {
+        all[p[key]] = (all[p[key]] ?? 0) + 1;
+        return all;
+      }, {}),
+    )
+      .sort((a, b) => b[1] - a[1])
+      .map(([k, n]) => `${k} ${n}`)
+      .join(", ");
+  const dated = posts
+    .filter((p) => !p.pinned && p.at)
+    .map((p) => p.at)
+    .sort((a, b) => a - b);
+  const weeks = dated.length > 1 ? (dated.at(-1) - dated[0]) / 6048e5 : null;
+  const carousels = posts.filter((p) => p.type === "carousel");
+  const top = [...posts]
+    .filter((p) => p.likes != null)
+    .sort((a, b) => b.likes - a.likes)
+    .slice(0, 3)
+    .map((p) => posts.indexOf(p) + 1);
+  return [
+    `types: ${tally("type")}; ratios: ${tally("ratio")}`,
+    `slides per carousel: median ${median(carousels.map((p) => p.slides)) ?? "-"} (of ${carousels.length})`,
+    `caption: median ${median(posts.map((p) => p.captionChars))} chars, ${median(posts.map((p) => p.hashtags))} hashtags; ${count((p) => p.hashtags === 0)} with none`,
+    `likes: median ${short(median(posts.map((p) => p.likes)))}; best: ${top.map((n) => `#${n}`).join(" ")}`,
+    weeks ? `cadence: ${(dated.length / weeks).toFixed(1)} posts a week` : null,
+  ].filter(Boolean);
+}

package/seed-skills/insta/instagram/scripts/profile.mjs

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+/**
+ * How one account posts: its size, its latest posts (type, slides, ratio, how they
+ * did, caption shape), and the pattern across them — read from the data the
+ * profile page itself fetches, not from the screen.
+ *
+ *   node profile.mjs <handle | profile url> [--posts 12] [--out posts.json] [--sheet covers.png]
+ */
+import { writeFileSync } from "node:fs";
+import { fail, inPage, orFail, parseArgs } from "./lib.mjs";
+import { media, patterns, postLine, short } from "./media.mjs";
+import { makeSheet } from "./sheet.mjs";
+
+const opts = parseArgs();
+const handle = String(opts._[0] ?? "")
+  .replace(/^https?:\/\/(www\.)?instagram\.com\//, "")
+  .replace(/^@/, "")
+  .split(/[/?]/)[0];
+if (!handle)
+  fail(
+    "usage: node profile.mjs <handle> [--posts 12] [--out posts.json] [--sheet covers.png]",
+  );
+const want = Number(opts.posts ?? 12);
+
+const started = Date.now();
+const got = orFail(
+  await inPage(
+    async (page, { handle, want }, { media }) => {
+      const posts = [];
+      let profile = null;
+      let more = true;
+      const first = (text) => JSON.parse(text.split("\n")[0]);
+      const listen = async (res) => {
+        if (!/\/graphql/.test(res.url())) return;
+        let text;
+        try {
+          text = await res.text();
+        } catch {
+          return;
+        }
+        try {
+          if (
+            text.includes("xdt_api__v1__feed__user_timeline_graphql_connection")
+          ) {
+            const c =
+              first(text).data
+                ?.xdt_api__v1__feed__user_timeline_graphql_connection;
+            for (const e of c?.edges ?? []) posts.push(media(e.node));
+            more = Boolean(c?.page_info?.has_next_page);
+          } else if (!profile && text.includes('"follower_count"')) {
+            const u = first(text).data?.user;
+            if (u?.username?.toLowerCase() === handle.toLowerCase())
+              profile = {
+                handle: u.username,
+                name: u.full_name,
+                followers: u.follower_count,
+                following: u.following_count ?? null,
+                posts: u.media_count ?? null,
+                verified: u.is_verified,
+                private: u.is_private,
+                category: u.category ?? null,
+                bio: u.biography ?? "",
+                link: u.bio_links?.[0]?.url ?? u.external_url ?? null,
+              };
+          }
+        } catch {}
+      };
+      page.on("response", listen);
+      try {
+        await page.goto(`https://www.instagram.com/${handle}/`, {
+          waitUntil: "domcontentloaded",
+        });
+        for (let i = 0; i < 40 && !(profile && posts.length); i++)
+          await page.waitForTimeout(250);
+        for (
+          let tries = 0;
+          posts.length < want && more && tries < 12;
+          tries++
+        ) {
+          const had = posts.length;
+          await page.evaluate(() =>
+            window.scrollTo(0, document.body.scrollHeight),
+          );
+          for (let i = 0; i < 24 && posts.length === had; i++)
+            await page.waitForTimeout(250);
+          if (posts.length === had) break;
+        }
+      } finally {
+        page.off("response", listen);
+      }
+      const path = page.url().replace(/^https?:\/\/[^/]+/, "");
+      if (/\/accounts\/login|\/challenge\//.test(path))
+        return {
+          error: `Not signed in (${path}). Borrow the kept sign-in first.`,
+        };
+      if (!profile && !posts.length)
+        return {
+          error: `Nothing came back for @${handle}: no such account, a private one, or the page changed (it no longer fetches xdt_api__v1__feed__user_timeline_graphql_connection). Open it and look.`,
+        };
+      const seen = new Set();
+      return {
+        profile,
+        // Newest first, the pinned ones after: the grid puts old pinned posts on top
+        posts: posts
+          .filter((p) => !seen.has(p.url) && seen.add(p.url))
+          .sort((a, b) => a.pinned - b.pinned || b.at - a.at)
+          .slice(0, want),
+      };
+    },
+    { handle, want },
+    { media },
+  ),
+);
+
+const { profile, posts } = got;
+if (opts.out)
+  writeFileSync(opts.out, JSON.stringify({ profile, posts }, null, 1));
+if (profile)
+  console.log(
+    `@${profile.handle} (${profile.name}) — ${short(profile.followers)} followers, ${profile.posts ?? "?"} posts${profile.verified ? ", verified" : ""}${profile.category ? `, ${profile.category}` : ""}\n` +
+      `bio: ${profile.bio.replace(/\s+/g, " ").slice(0, 160)}`,
+  );
+posts.forEach((p, i) => {
+  console.log(postLine(p, i));
+});
+for (const line of patterns(posts)) console.log(`pattern: ${line}`);
+if (opts.sheet) {
+  const made = await makeSheet(
+    posts.map((p, i) => ({
+      src: p.cover,
+      label: `#${i + 1} ${p.type}${p.type === "carousel" ? `×${p.slides}` : ""} ${p.ratio ?? ""} likes ${short(p.likes)}`,
+    })),
+    opts.sheet,
+  );
+  console.log(`covers: ${made.out}`);
+}
+console.log(
+  `${posts.length} posts in ${((Date.now() - started) / 1000).toFixed(1)}s${opts.out ? ` → ${opts.out} (full captions, every slide's picture url)` : ""}`,
+);

package/seed-skills/insta/instagram/scripts/read.mjs

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+/**
+ * Reads one DM thread into a JSONL file, oldest first, by walking its message pane
+ * up from the newest message. Opening a thread marks it seen.
+ *
+ *   node read.mjs <thread id | thread url> --out <file.jsonl>
+ *     [--since 2026-09-01] [--max 200] [--tail 10]
+ *
+ * Stops at whichever comes first: --max messages, a message older than --since,
+ * the top of the thread, or two rounds that brought nothing new.
+ */
+import { writeFileSync } from "node:fs";
+import { fail, inPage, oneLine, orFail, parseArgs, stamp } from "./lib.mjs";
+import { SEL } from "./selectors.mjs";
+
+const opts = parseArgs();
+const target = opts._[0];
+if (!target || !opts.out)
+  fail(
+    "usage: node read.mjs <thread id | url> --out <file.jsonl> [--since YYYY-MM-DD] [--max 200] [--tail 10]",
+  );
+const id = String(target).match(/(\d{6,})/)?.[1];
+if (!id) fail(`Not a thread id or url: ${target}`);
+const url = `https://www.instagram.com/direct/t/${id}/`;
+const max = Number(opts.max ?? 200);
+const since = opts.since ? new Date(opts.since).getTime() : null;
+if (opts.since && Number.isNaN(since))
+  fail(`--since is not a date: ${opts.since}`);
+const tail = Number(opts.tail ?? 10);
+/** Each round is one browser call of a few screens; this caps a runaway thread. */
+const ROUNDS = 60;
+
+/**
+ * One round: a few screens of the pane, each read and then moved up by most of a
+ * screen. The pane unmounts rows that leave the screen, so it is walked, never
+ * jumped to the top: a jump skips everything in between.
+ */
+async function round(page, { SEL, url, first, steps }) {
+  const extract = (SEL) => {
+    if (/\/accounts\/login|\/challenge\//.test(location.pathname))
+      return { error: `Not signed in (${location.pathname}).` };
+    const pane = [...document.querySelectorAll("main *")].find(
+      (e) =>
+        e.clientHeight > 200 &&
+        !e.closest(SEL.inboxList) &&
+        /(auto|scroll)/.test(getComputedStyle(e).overflowY) &&
+        e.querySelector(SEL.messageRow),
+    );
+    if (!pane)
+      return {
+        error: document.querySelector("main")
+          ? "Selectors changed: no message pane (SEL.messageRow). Snapshot the thread once and fix selectors.mjs."
+          : "No thread on the page: something covers it (a dialog, a daily time-limit screen). Snapshot, close it, run again.",
+      };
+    pane.setAttribute("data-read-pane", "");
+    const fiberOf = (el) =>
+      el[Object.keys(el).find((k) => k.startsWith("__reactFiber"))];
+    const findProp = (el, name) => {
+      for (let f = fiberOf(el), d = 0; f && d < 40; f = f.return, d++) {
+        const p = f.memoizedProps;
+        if (p && typeof p === "object" && p[name] != null) return p[name];
+      }
+      return null;
+    };
+    const paneBox = pane.getBoundingClientRect();
+    const messages = [];
+    for (const row of pane.querySelectorAll(SEL.messageRow)) {
+      const body = row.querySelector(SEL.messageBody);
+      if (!body) continue; // a date line, a "seen" line
+      const ref = findProp(row, SEL.messageRefProp);
+      const deep =
+        body.querySelector("[dir=auto], img, video, a") ??
+        body.firstElementChild ??
+        body;
+      let outgoing = findProp(deep, SEL.outgoingProp);
+      if (typeof outgoing !== "boolean") {
+        // Heuristic: no flag on the row, so a bubble nearer the right edge is the account's own
+        const box = body.getBoundingClientRect();
+        outgoing = box.left - paneBox.left > paneBox.right - box.right;
+      }
+      messages.push({
+        id: ref?.id ?? null,
+        ts: ref?.timestamp_ms ? Number(ref.timestamp_ms) : null,
+        from: outgoing ? "me" : "them",
+        sender: ref?.sender_fbid ?? null,
+        text: body.innerText.trim(),
+        images: [...body.querySelectorAll("img")]
+          .filter((i) => i.getBoundingClientRect().width >= SEL.minImagePx)
+          .map((i) => i.currentSrc || i.src),
+        video: body.querySelector("video") !== null,
+        links: [
+          ...new Set(
+            [...body.querySelectorAll("a[href]")]
+              .map((a) => a.href)
+              .filter((h) => h.startsWith("http")),
+          ),
+        ],
+      });
+    }
+    // A column-reverse pane counts scrollTop from the bottom, as zero and below
+    const reversed = getComputedStyle(pane).flexDirection === "column-reverse";
+    const atTop = reversed
+      ? Math.abs(pane.scrollTop) + pane.clientHeight >= pane.scrollHeight - 2
+      : pane.scrollTop <= 1;
+    return { messages, atTop, height: pane.scrollHeight };
+  };
+
+  if (first) {
+    if (!page.url().startsWith(url)) {
+      await page.goto(url, { waitUntil: "domcontentloaded" });
+      await page
+        .waitForFunction(
+          (SEL) => document.querySelector(`main ${SEL.messageBody}`),
+          SEL,
+          { timeout: 20000 },
+        )
+        .catch(() => {});
+    }
+    await page.waitForTimeout(800);
+    const found = await page.evaluate(extract, SEL);
+    if (found.error) return found;
+    // Start from the newest message, wherever an earlier look left the pane
+    await page.evaluate(() => {
+      const pane = document.querySelector("[data-read-pane]");
+      pane.scrollTop =
+        getComputedStyle(pane).flexDirection === "column-reverse"
+          ? 0
+          : pane.scrollHeight;
+    });
+    await page.waitForTimeout(500);
+  }
+
+  const messages = [];
+  let moved = Number.POSITIVE_INFINITY;
+  for (let s = 0; s < steps; s++) {
+    const seen = await page.evaluate(extract, SEL);
+    if (seen.error) return seen;
+    messages.push(...seen.messages);
+    // At the top, or held in place while older rows load: wait for the pane to grow
+    if (seen.atTop || moved < 10) {
+      const grew = await page
+        .waitForFunction(
+          (height) =>
+            (document.querySelector("[data-read-pane]")?.scrollHeight ?? 0) >
+            height,
+          seen.height,
+          { timeout: 5000 },
+        )
+        .then(() => true)
+        .catch(() => false);
+      if (!grew && seen.atTop) return { messages, top: true };
+      await page.waitForTimeout(300);
+    }
+    moved = await page.evaluate(() => {
+      const pane = document.querySelector("[data-read-pane]");
+      const before = pane.scrollTop;
+      pane.scrollTop -= pane.clientHeight * 0.8;
+      return Math.abs(pane.scrollTop - before);
+    });
+    await page.waitForTimeout(350);
+  }
+  return { messages, top: false };
+}
+
+const started = Date.now();
+const byKey = new Map();
+let fallbackKeys = 0;
+let stop = `the round limit (${ROUNDS})`;
+let quiet = 0;
+for (let i = 0; i < ROUNDS; i++) {
+  const r = orFail(await inPage(round, { SEL, url, first: i === 0, steps: 5 }));
+  if (i === 0 && r.messages.length === 0)
+    fail(
+      "Selectors changed: the pane has rows but no message was read (SEL.messageBody). Fix selectors.mjs.",
+    );
+  let fresh = 0;
+  for (const m of r.messages) {
+    // Heuristic when the row carries no message id: side + time + text stand in for one
+    const key =
+      m.id ?? `${m.from}|${m.ts}|${m.text.slice(0, 120)}|${m.images[0] ?? ""}`;
+    const known = byKey.get(key);
+    if (known) {
+      // A picture that had not loaded on the first sighting may have by now
+      known.images = [...new Set([...known.images, ...m.images])];
+      known.links = [...new Set([...known.links, ...m.links])];
+      if (m.text.length > known.text.length) known.text = m.text;
+      continue;
+    }
+    if (!m.id) fallbackKeys++;
+    byKey.set(key, m);
+    fresh++;
+  }
+  quiet = fresh ? 0 : quiet + 1;
+  const oldest = Math.min(
+    ...[...byKey.values()].map((m) => m.ts ?? Number.POSITIVE_INFINITY),
+  );
+  if (byKey.size >= max) {
+    stop = `--max ${max}`;
+    break;
+  }
+  if (since && oldest < since) {
+    stop = `--since ${opts.since}`;
+    break;
+  }
+  if (r.top) {
+    stop = "the top of the thread";
+    break;
+  }
+  if (quiet >= 2) {
+    stop = "two rounds with nothing new";
+    break;
+  }
+}
+
+let messages = [...byKey.values()].sort((a, b) => (a.ts ?? 0) - (b.ts ?? 0));
+if (since) messages = messages.filter((m) => m.ts == null || m.ts >= since);
+messages = messages.slice(-max);
+writeFileSync(
+  opts.out,
+  messages
+    .map((m) => JSON.stringify({ ...m, at: m.ts ? stamp(m.ts) : null }))
+    .join("\n") + (messages.length ? "\n" : ""),
+);
+
+const count = (f) => messages.filter(f).length;
+console.log(
+  `${messages.length} messages (${count((m) => m.from === "me")} from me, ${count((m) => m.from === "them")} from them), ` +
+    `${messages.length ? `${stamp(messages[0].ts)} to ${stamp(messages.at(-1).ts)}` : "none"}; ` +
+    `${count((m) => m.images.length)} with pictures, ${count((m) => m.links.length)} with links. ` +
+    `Stopped at ${stop}. ${((Date.now() - started) / 1000).toFixed(1)}s → ${opts.out}`,
+);
+if (fallbackKeys)
+  console.log(
+    `${fallbackKeys} rows had no message id; they were told apart by side, time and text.`,
+  );
+for (const m of tail > 0 ? messages.slice(-tail) : [])
+  console.log(
+    `${stamp(m.ts)} ${m.from}: ${oneLine(m.text, 160) || "(no text)"}` +
+      `${m.images.length ? ` [${m.images.length} picture]` : ""}${m.links.length ? ` [${m.links[0]}]` : ""}`,
+  );

package/seed-skills/insta/instagram/scripts/render.mjs

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+/**
+ * Screenshots HTML slides to PNGs of exactly the given size, in a tab of its own
+ * beside whatever page the session has open. Every `[data-slide]` element in the
+ * file is one PNG; a file with none is one PNG of the whole viewport. The file's
+ * folder is served over http for the length of the run, so pictures beside it load.
+ *
+ *   node render.mjs <slides.html> --size 1080x1350 --out <dir> [--name slide]
+ */
+import { createReadStream, existsSync, mkdirSync, statSync } from "node:fs";
+import { createServer } from "node:http";
+import { basename, dirname, extname, resolve, sep } from "node:path";
+import { imageSize } from "./image-size.mjs";
+import { fail, inPage, orFail, parseArgs } from "./lib.mjs";
+
+const opts = parseArgs();
+const file = opts._[0] && resolve(opts._[0]);
+const [w, h] = String(opts.size ?? "")
+  .split("x")
+  .map(Number);
+if (!file || !opts.out || !w || !h)
+  fail(
+    "usage: node render.mjs <slides.html> --size 1080x1350 --out <dir> [--name slide]",
+  );
+if (!existsSync(file)) fail(`No such file: ${file}`);
+const out = resolve(opts.out);
+mkdirSync(out, { recursive: true });
+const name = opts.name ?? "slide";
+
+const TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".css": "text/css",
+  ".js": "text/javascript",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+};
+const root = dirname(file);
+// Port 0: the system picks a free one, so two jobs rendering at once never meet
+const server = createServer((req, res) => {
+  const path = resolve(
+    root,
+    `.${decodeURIComponent(new URL(req.url, "http://x").pathname)}`,
+  );
+  if (
+    !path.startsWith(root + sep) ||
+    !existsSync(path) ||
+    statSync(path).isDirectory()
+  ) {
+    res.writeHead(404).end();
+    return;
+  }
+  res.writeHead(200, {
+    "content-type":
+      TYPES[extname(path).toLowerCase()] ?? "application/octet-stream",
+  });
+  createReadStream(path).pipe(res);
+});
+await new Promise((ok) => server.listen(0, "127.0.0.1", ok));
+const url = `http://127.0.0.1:${server.address().port}/${encodeURIComponent(basename(file))}`;
+
+const done = orFail(
+  await inPage(
+    async (page, { url, w, h, out, name }) => {
+      const tab = await page.context().newPage();
+      try {
+        await tab.setViewportSize({ width: w, height: h });
+        await tab.goto(url, { waitUntil: "load" });
+        await tab.evaluate(async () => {
+          await document.fonts.ready;
+          await Promise.all(
+            [...document.images].map((i) => i.decode().catch(() => {})),
+          );
+        });
+        const broken = await tab.evaluate(() =>
+          [...document.images]
+            .filter((i) => !i.naturalWidth)
+            .map((i) => i.getAttribute("src")),
+        );
+        const slides = tab.locator("[data-slide]");
+        const n = await slides.count();
+        const files = [];
+        const pad = (i) => String(i + 1).padStart(2, "0");
+        if (n === 0) {
+          const path = `${out}/${name}-01.png`;
+          await tab.screenshot({ path, scale: "css" });
+          files.push(path);
+        }
+        for (let i = 0; i < n; i++) {
+          const path = `${out}/${name}-${pad(i)}.png`;
+          await slides.nth(i).screenshot({ path, scale: "css" });
+          files.push(path);
+        }
+        return { files, broken };
+      } finally {
+        await tab.close();
+      }
+    },
+    { url, w, h, out, name },
+  ),
+);
+server.close();
+
+let wrong = 0;
+for (const path of done.files) {
+  const size = imageSize(path);
+  const ok = size && size.w === w && size.h === h;
+  if (!ok) wrong++;
+  console.log(
+    `${path} ${size ? `${size.w}x${size.h}` : "?"}${ok ? "" : ` — not ${w}x${h}`}`,
+  );
+}
+if (done.broken.length)
+  console.log(`Pictures that did not load: ${done.broken.join(", ")}`);
+if (wrong)
+  fail(
+    `${wrong} slide(s) came out at the wrong size: give every [data-slide] exactly width ${w}px and height ${h}px, with nothing overflowing it.`,
+  );
+console.log(`${done.files.length} slide(s) at ${w}x${h} in ${out}`);