@struq/skill 0.2.2 → 0.4.0

package/skills/struq/scripts/images.mjs

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+// Struq imagery: download one beeldbank pack into the project.
+//
+//   node <skill-dir>/scripts/images.mjs <pack-slug>          run from the project root
+//   node <skill-dir>/scripts/images.mjs <pack-slug> --dir ./my-site
+//   node <skill-dir>/scripts/images.mjs --list                every pack, with what it shows
+//   node <skill-dir>/scripts/images.mjs --brief "<the brief>"  picks the pack and the fitting photos
+//   node <skill-dir>/scripts/images.mjs <pack-slug> --brief "<the brief>"
+//
+// With --brief (always pass it): the pack follows Struq's rule (scripts/packs.mjs) when no slug is
+// given, and photos whose alt names a subject the client does not do are left out, best fit first.
+//
+// What it does, in order:
+// 1. Reads the pack from https://struq.nl/api/media/packs/<slug> (public, no key, CC0 images).
+// 2. Downloads all 24 images to public/images/<slot>-<n>.webp and checks each one is a real image.
+// 3. Writes lib/struq-images.ts (src/lib/ when the project uses src/): every image with its alt,
+//    size and description, grouped by slot, plus the credit line. Components import from it.
+// 4. If struq.nl cannot be reached, or a file fails its check, it writes a graded fallback plate
+//    in the site palette for that slot instead, so no frame is ever empty, and says so.
+//
+// Node 18 or later, no dependencies. Safe to run again: valid files are kept.
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { appendLog } from "./log.mjs";
+import { fitImages, packForBrief, packReason } from "./packs.mjs";
+
+// STRUQ_API_BASE points a test run at another Struq environment (for example https://staging.struq.nl).
+// Real users never set it: the default is production.
+const BASE = (process.env.STRUQ_API_BASE || "https://struq.nl").replace(/\/+$/, "");
+const API = `${BASE}/api/media/packs`;
+/** The download URL, on the same base as the API (directPath), falling back to the absolute publicUrl. */
+const imageUrl = (img) => (img.directPath ? `${BASE}${img.directPath}` : img.publicUrl);
+const SLOTS = ["hero", "band", "card", "column", "detail", "backdrop"];
+const FALLBACK_COUNTS = { hero: 3, band: 2, card: 8, column: 4, detail: 4, backdrop: 3 };
+const FALLBACK_SIZE = {
+  hero: [2048, 1152],
+  band: [2352, 1008],
+  card: [2048, 1365],
+  column: [1600, 2000],
+  detail: [1600, 1600],
+  backdrop: [2048, 1152],
+};
+
+const args = process.argv.slice(2);
+const flag = (name) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : undefined;
+};
+const root = resolve(flag("--dir") ?? process.cwd());
+const brief = flag("--brief");
+const slug = args.find((a, i) => !a.startsWith("--") && args[i - 1] !== "--dir" && args[i - 1] !== "--brief") ?? (brief ? packForBrief(brief) : undefined);
+const why = brief && !args.find((a, i) => !a.startsWith("--") && args[i - 1] !== "--dir" && args[i - 1] !== "--brief") ? packReason(brief) : "named on the command line";
+
+async function getJson(url) {
+  const res = await fetch(url, { signal: AbortSignal.timeout(20000), headers: { accept: "application/json" } });
+  if (!res.ok) throw new Error(`${url} answered ${res.status}`);
+  return res.json();
+}
+
+function isImage(buf) {
+  if (!buf || buf.length < 8000) return false;
+  const ascii = (a, b) => buf.subarray(a, b).toString("latin1");
+  if (ascii(0, 4) === "RIFF" && ascii(8, 12) === "WEBP") return true;
+  if (buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff) return true;
+  if (buf[0] === 0x89 && ascii(1, 4) === "PNG") return true;
+  if (ascii(4, 12) === "ftypavif") return true;
+  return false;
+}
+
+function fileIsImage(path) {
+  try {
+    return statSync(path).size > 8000 && isImage(readFileSync(path));
+  } catch {
+    return false;
+  }
+}
+
+async function download(url, path) {
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const res = await fetch(url, { signal: AbortSignal.timeout(30000) });
+      if (!res.ok) continue;
+      const buf = Buffer.from(await res.arrayBuffer());
+      if (!isImage(buf)) continue;
+      writeFileSync(path, buf);
+      return true;
+    } catch {
+      // retry once, then fall back
+    }
+  }
+  return false;
+}
+
+function readPalette() {
+  const palette = { s0: "#f5efe6", s1: "#ede4d6", s2: "#e1d4bf", s3: "#cdbb9f", ink: "#1e1a15", accent: "#8a3b22" };
+  for (const file of ["app/globals.css", "src/app/globals.css", "src/styles/globals.css", "styles/globals.css"]) {
+    const path = join(root, file);
+    if (!existsSync(path)) continue;
+    const css = readFileSync(path, "utf8");
+    // Literal colours only (hex or oklch); a color-mix() step falls back to its neighbour.
+    const pick = (name) => css.match(new RegExp(`--${name}\\s*:\\s*(#[0-9a-fA-F]{3,8}|oklch\\([^)]*\\))`))?.[1];
+    palette.s0 = pick("surface-0") ?? palette.s0;
+    palette.s1 = pick("surface-1") ?? palette.s1;
+    palette.s2 = pick("surface-2") ?? (pick("surface-1") ? palette.s1 : palette.s2);
+    palette.s3 = pick("surface-3") ?? (pick("surface-0") ? palette.s0 : palette.s3);
+    palette.ink = pick("ink") ?? palette.ink;
+    palette.accent = pick("accent") ?? palette.accent;
+    break;
+  }
+  return palette;
+}
+
+// A graded plate in the site palette: two planes of light, a horizon hairline, film grain.
+// Not a photo, but never an empty box: it reads as a deliberate abstract image.
+function fallbackSvg(slot, n, [w, h], p) {
+  let seed = (slot.length * 977 + n * 131) % 2147483647;
+  const rnd = () => (seed = (seed * 16807) % 2147483647) / 2147483647;
+  const x1 = Math.round(w * (0.15 + rnd() * 0.4));
+  const x2 = Math.round(x1 + w * (0.25 + rnd() * 0.25));
+  const tilt = Math.round(w * (0.08 + rnd() * 0.12));
+  const horizon = Math.round(h * (0.55 + rnd() * 0.2));
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${w}" height="${h}" viewBox="0 0 ${w} ${h}">
+  <filter id="g"><feTurbulence type="fractalNoise" baseFrequency="0.9" numOctaves="2" stitchTiles="stitch"/><feColorMatrix values="0 0 0 0 0  0 0 0 0 0  0 0 0 0 0  0 0 0 0.22 0"/></filter>
+  <filter id="soft"><feGaussianBlur stdDeviation="${Math.round(w / 60)}"/></filter>
+  <rect width="${w}" height="${h}" fill="${p.s2}"/>
+  <polygon filter="url(#soft)" points="${x1},0 ${x2},0 ${x2 + tilt},${h} ${x1 + tilt},${h}" fill="${p.s0}" opacity="0.85"/>
+  <polygon filter="url(#soft)" points="${x2 + w * 0.05},0 ${x2 + w * 0.12},0 ${x2 + w * 0.12 + tilt},${h} ${x2 + w * 0.05 + tilt},${h}" fill="${p.s1}" opacity="0.7"/>
+  <rect y="${horizon}" width="${w}" height="${h - horizon}" fill="${p.s3}" opacity="0.55"/>
+  <rect y="${horizon}" width="${w}" height="2" fill="${p.ink}" opacity="0.35"/>
+  <rect width="${w}" height="${h}" filter="url(#g)"/>
+</svg>
+`;
+}
+
+function libDir() {
+  return existsSync(join(root, "src", "app")) ? join(root, "src", "lib") : join(root, "lib");
+}
+
+function writeModule(entries, packSlug, fallback, imageFit = "full") {
+  const dir = libDir();
+  mkdirSync(dir, { recursive: true });
+  const grouped = Object.fromEntries(SLOTS.map((s) => [s, entries.filter((e) => e.slot === s)]));
+  const body = SLOTS.map((s) => {
+    const rows = grouped[s]
+      .map((e) => {
+        const fields = [
+          `src: ${JSON.stringify(e.src)}`,
+          `alt: ${JSON.stringify(e.alt)}`,
+          `width: ${e.width}`,
+          `height: ${e.height}`,
+          `ratio: ${JSON.stringify(e.ratio)}`,
+          `description: ${JSON.stringify(e.description)}`,
+        ];
+        if (e.negativeSpace) fields.push(`negativeSpace: ${JSON.stringify(e.negativeSpace)}`);
+        if (e.unoptimized) fields.push("unoptimized: true");
+        return `    { ${fields.join(", ")} },`;
+      })
+      .join("\n");
+    return `  ${s}: [\n${rows}\n  ],`;
+  }).join("\n");
+  const source = `// Written by the Struq skill (scripts/images.mjs). Do not hand-edit the list: run the script again
+// to change pack. Pack: ${packSlug}${fallback ? " (FALLBACK PLATES: struq.nl was unreachable, run the script again when online)" : ""}.
+// Beeldbank images are CC0. Translate the alt texts when the site is not in Dutch.
+
+export type StruqImage = {
+  src: string;
+  alt: string;
+  width: number;
+  height: number;
+  /** "16:9", "21:9", "3:2", "4:5" or "1:1" */
+  ratio: string;
+  /** What the photo shows, in more words than the alt: read it to choose the right slot. */
+  description: string;
+  /** The photo's calm side ("left", "right", "top", "bottom", "center"): where copy reads over it. */
+  negativeSpace?: string;
+  /** Set on fallback plates (SVG), which next/image must not optimise. */
+  unoptimized?: boolean;
+};
+
+export type ImageSlot = ${SLOTS.map((s) => JSON.stringify(s)).join(" | ")};
+
+export const imagePack = ${JSON.stringify(packSlug)};
+
+/**
+ * "full": the pack shows this client's world. "partial": only the photos whose alt names something
+ * the brief is about are here. "none": no photo fits, so the first screen is typographic or the
+ * WebGL scene, and the approval stop asks the client for photos. Never fill a frame with an
+ * off-topic photo.
+ */
+export const imageFit: "full" | "partial" | "none" = ${JSON.stringify(imageFit)};
+
+/** The credit line for the footer: one quiet text-small link, never a badge. */
+export const imageCredit = { label: "Beeld: Struq", href: "https://struq.nl/beeldbank" };
+
+export const images: Record<ImageSlot, StruqImage[]> = {
+${body}
+};
+`;
+  const file = join(dir, "struq-images.ts");
+  writeFileSync(file, source);
+  return file;
+}
+
+async function list() {
+  const index = await getJson(API);
+  console.log(`${index.packCount} packs, ${index.totalImages} images, ${index.license}\n`);
+  for (const p of index.packs) console.log(`${p.slug.padEnd(10)} ${p.description}`);
+}
+
+async function main() {
+  if (args.includes("--list")) return list();
+  if (!slug) {
+    console.error('Usage: node images.mjs --brief "<the brief>" | <pack-slug> --brief "<the brief>"   [--dir <project>]   (or --list)');
+    process.exit(2);
+  }
+  if (!existsSync(join(root, "package.json"))) {
+    console.error(`No package.json in ${root}. Run this from the project root, or pass --dir.`);
+    process.exit(2);
+  }
+  const outDir = join(root, "public", "images");
+  mkdirSync(outDir, { recursive: true });
+  const palette = readPalette();
+
+  let pack = null;
+  let droppedImages = [];
+  let imageFit = "full";
+  try {
+    pack = await getJson(`${API}/${encodeURIComponent(slug)}`);
+    if (!Array.isArray(pack?.images) || pack.images.length === 0) throw new Error("pack has no images");
+  } catch (error) {
+    try {
+      const index = await getJson(API);
+      const known = index.packs.map((p) => p.slug);
+      if (!known.includes(slug)) {
+        console.error(`Unknown pack "${slug}". Packs: ${known.join(", ")}`);
+        process.exit(2);
+      }
+    } catch {
+      // the API itself is down: fall through to the plates
+    }
+    console.warn(`WARN struq.nl unreachable (${error.message}). Writing graded fallback plates instead.`);
+    pack = null;
+  }
+
+  const entries = [];
+  const manifest = [];
+  let real = 0;
+  let plates = 0;
+
+  if (pack) {
+    const counters = Object.fromEntries(SLOTS.map((s) => [s, 0]));
+    if (brief) {
+      const fit = fitImages(slug, brief, pack.images);
+      pack.images = fit.keep;
+      droppedImages = fit.dropped;
+      imageFit = fit.fit;
+    } else {
+      console.warn('WARN no --brief: every photo of the pack is used. Pass --brief so photos of subjects this client does not do are left out.');
+    }
+    const jobs = pack.images
+      .filter((img) => SLOTS.includes(img.slot))
+      .map((img) => {
+        const n = ++counters[img.slot];
+        return { img, n, name: `${img.slot}-${n}` };
+      });
+    let cursor = 0;
+    const worker = async () => {
+      while (cursor < jobs.length) {
+        const job = jobs[cursor++];
+        const target = join(outDir, `${job.name}.webp`);
+        const ok = fileIsImage(target) || (await download(imageUrl(job.img), target));
+        if (ok) {
+          real++;
+          entries.push({
+            slot: job.img.slot,
+            order: job.n,
+            src: `/images/${job.name}.webp`,
+            alt: job.img.alt ?? "",
+            width: job.img.width ?? FALLBACK_SIZE[job.img.slot][0],
+            height: job.img.height ?? FALLBACK_SIZE[job.img.slot][1],
+            ratio: job.img.aspectRatio ?? "",
+            description: job.img.description ?? "",
+            negativeSpace: job.img.negativeSpace ?? "",
+          });
+          manifest.push({ file: `public/images/${job.name}.webp`, id: job.img.id, slot: job.img.slot, source: imageUrl(job.img) });
+        } else {
+          plates++;
+          const size = [job.img.width ?? FALLBACK_SIZE[job.img.slot][0], job.img.height ?? FALLBACK_SIZE[job.img.slot][1]];
+          writeFileSync(join(outDir, `${job.name}.svg`), fallbackSvg(job.img.slot, job.n, size, palette));
+          entries.push({
+            slot: job.img.slot,
+            order: job.n,
+            src: `/images/${job.name}.svg`,
+            alt: job.img.alt ?? "",
+            width: size[0],
+            height: size[1],
+            ratio: job.img.aspectRatio ?? "",
+            description: `Fallback plate (download failed). Planned: ${job.img.description ?? ""}`,
+            unoptimized: true,
+          });
+          manifest.push({ file: `public/images/${job.name}.svg`, id: job.img.id, slot: job.img.slot, source: "fallback" });
+        }
+      }
+    };
+    await Promise.all([worker(), worker(), worker(), worker()]);
+  } else {
+    for (const slot of SLOTS) {
+      for (let n = 1; n <= FALLBACK_COUNTS[slot]; n++) {
+        plates++;
+        const size = FALLBACK_SIZE[slot];
+        writeFileSync(join(outDir, `${slot}-${n}.svg`), fallbackSvg(slot, n, size, palette));
+        entries.push({
+          slot,
+          order: n,
+          src: `/images/${slot}-${n}.svg`,
+          alt: "",
+          width: size[0],
+          height: size[1],
+          ratio: `${size[0]}:${size[1]}`,
+          description: "Fallback plate in the site palette (struq.nl was unreachable).",
+          unoptimized: true,
+        });
+        manifest.push({ file: `public/images/${slot}-${n}.svg`, id: null, slot, source: "fallback" });
+      }
+    }
+  }
+
+  entries.sort((a, b) => SLOTS.indexOf(a.slot) - SLOTS.indexOf(b.slot) || a.order - b.order);
+  writeFileSync(join(outDir, "struq-pack.json"), JSON.stringify({ pack: slug, images: manifest }, null, 2) + "\n");
+  const module = writeModule(entries, slug, !pack, imageFit);
+
+  console.log(`\nPack ${slug} (${why}): ${real} images downloaded and verified, ${plates} fallback plates.`);
+  if (droppedImages.length) console.log(`Left out ${droppedImages.length} photos that do not fit this client (${[...new Set(droppedImages.map((d) => d.reason))].join("; ")}).`);
+  console.log("Captions: write them from each photo's alt below. Never name a subject the photo does not show.");
+  if (imageFit === "none") {
+    console.log("NONE of this pack's photos fits the brief. Use no photos: a background block (aurora, silk, facets) carries the hero's type.");
+    console.log("Say so at the approval stop: \"Ik heb geen foto's van je <product>: stuur ze, dan komen ze in de hero.\"");
+  } else if (imageFit === "partial") {
+    console.log(`Only ${entries.length} photo(s) fit: use them where their alt fits (the material, the city, the street), and nowhere else.`);
+  }
+  console.log(`Module: ${module.replace(root, ".")}  (import { images, imageCredit } from "@/lib/struq-images")\n`);
+  for (const e of entries) {
+    console.log(`${`images.${e.slot}[${e.order - 1}]`.padEnd(18)} ${e.ratio.padEnd(5)} ${e.description.slice(0, 110)}`);
+  }
+  if (plates > 0) {
+    console.log(`\nWARN ${plates} slot(s) use fallback plates. Run this script again when struq.nl answers.`);
+  }
+  appendLog(root, "Step 4 Images", [
+    `images.mjs: pack ${slug} (${why}), ${real} images downloaded and verified, ${plates} fallback plates.`,
+    ...(droppedImages.length ? [`Left out ${droppedImages.length} photos that do not fit this client: ${[...new Set(droppedImages.map((d) => d.reason))].join("; ")}.`] : []),
+    ...(imageFit !== "full" ? [`Image fit: ${imageFit}${imageFit === "none" ? ", the opener is typographic or WebGL, and the approval stop asks for photos" : ""}.`] : []),
+    `Files in public/images, list in ${module.replace(root, ".")}${BASE !== "https://struq.nl" ? `, from ${BASE}` : ""}.`,
+  ]);
+  console.log(imageFit === "none" ? "\nOK no fitting photos: build the opener without them" : real > 0 ? "\nOK images ready" : "\nOK fallback plates ready (no frame is empty)");
+}
+
+main().catch((error) => {
+  console.error(`FAIL ${error.message}`);
+  process.exit(1);
+});

package/skills/struq/scripts/log.mjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+// Struq site log: STRUQ-LOG.md in the project root, one per site, append only, human first.
+// STRUQ.md is the plan and the contract; STRUQ-LOG.md is what happened, in order.
+//
+// From the shell, at every checklist step:
+//   node <skill-dir>/scripts/log.mjs "Step 5 Blocks" "hero-still, variant frame, in app/page.tsx." "Why: one calm photo for an architect."
+//   add --dir <project> to run from elsewhere
+//
+// From a script: import { appendLog } from "./log.mjs"; appendLog(root, "Step 5 Images", ["...", "..."]);
+//
+// Entry shape: a heading with the step name and the local time, then two to five short lines.
+// Earlier entries are never rewritten: the file is only ever opened for appending.
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const DASHES = /[\u2012\u2013\u2014\u2015]/g;
+
+function stamp(date = new Date()) {
+  const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${date.getDate()} ${months[date.getMonth()]} ${date.getFullYear()}, ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+
+function projectName(root) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+    if (pkg.name) return pkg.name;
+  } catch {
+    // no package.json yet: the folder name will do
+  }
+  return basename(root);
+}
+
+/** Append one entry to <root>/STRUQ-LOG.md, creating the file with its header the first time. */
+export function appendLog(root, step, lines) {
+  const file = join(root, "STRUQ-LOG.md");
+  const clean = (s) => String(s).replace(DASHES, ",").replace(/\s+/g, " ").trim();
+  const body = (Array.isArray(lines) ? lines : [lines]).map(clean).filter(Boolean).slice(0, 8);
+  let text = "";
+  if (!existsSync(file)) {
+    text += `# STRUQ-LOG.md: ${projectName(root)}\n\nThe build log of this site, oldest first. Append only: never edit or remove an entry. The plan and the contract are in STRUQ.md.\n`;
+  }
+  text += `\n## ${clean(step)} (${stamp()})\n${body.map((l) => `${l}\n`).join("")}`;
+  appendFileSync(file, text);
+  return file;
+}
+
+// CLI
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const args = process.argv.slice(2);
+  const i = args.indexOf("--dir");
+  const root = resolve(i >= 0 ? args[i + 1] : process.cwd());
+  const rest = i >= 0 ? args.filter((_, j) => j !== i && j !== i + 1) : args;
+  // MCP calls: node log.mjs mcp <struq_tool> [--note "<what it returned or what you took from it>"]
+  if (rest[0] === "mcp") {
+    const tool = rest[1];
+    const k = rest.indexOf("--note");
+    const STEP = { struq_richting: 2, struq_blokken: 2, struq_blok: 5, struq_controle: 8 };
+    if (!tool || !/^struq_/.test(tool)) {
+      console.error('Usage: node log.mjs mcp <struq_tool> [--note "<text>"]');
+      process.exit(2);
+    }
+    const file = appendLog(root, `Step ${STEP[tool] ?? 5} MCP ${tool}`, [k >= 0 ? rest[k + 1] : "Called."]);
+    console.log(`Logged ${tool} in ${file}`);
+    process.exit(0);
+  }
+  const [step, ...lines] = rest;
+  if (!step || !lines.length || !/^Step [0-9]+/.test(step)) {
+    console.error('Usage: node log.mjs "Step <N> <Name>" "<what>" ["<why>" ...]   [--dir <project>]. The step starts with Step and its checklist number.');
+    process.exit(2);
+  }
+  const file = appendLog(root, step, lines);
+  console.log(`Logged "${step}" in ${file}`);
+}

package/skills/struq/scripts/packs.mjs

@@ -0,0 +1,156 @@
+// Struq beeldbank: which pack fits a brief, and which photos inside a pack fit this client.
+//
+// The pack rule mirrors Struq's MCP (public canon logic), in order:
+//   1. A sector word in the brief picks that sector's pack, matched as whole words (neighbouring
+//      words are also tried joined, so "e-bike" matches "ebike"). Most matches wins; table order
+//      breaks a tie.
+//   2. No sector word, but the brief launches or sells a product: vitrine (product photography),
+//      and the hero scene carries the product.
+//   3. Anything else: halide, because a wrong photograph is worse than an abstract one.
+// Vehicle and mobility words are not freight words: transit is for logistics, never for a bike.
+// The vocabulary is the MCP's Dutch list plus the English words a brief may use.
+//
+// Inside a pack, fitImages drops the photos whose alt names a subject this client does not do
+// (a fish restaurant gets no flour and dough from the bakery half of proof) and puts the photos
+// whose alt shares words with the brief first in each slot.
+
+export function normalize(text) {
+  return String(text)
+    .toLowerCase()
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .replace(/[^a-z0-9]+/g, " ")
+    .trim();
+}
+
+export const PACK_SIGNALS = [
+  ["proof", ["restaurant", "restaurants", "visrestaurant", "bistro", "brasserie", "eetcafe", "horeca", "keuken", "chef", "kok", "koken", "kookt", "bakkerij", "bakker", "patisserie", "lunchroom", "koffiebar", "bakery", "cafe", "wine", "wijnbar", "pizzeria", "catering", "kitchen", "dining"]],
+  ["datum", ["architect", "architecten", "architectenbureau", "architectuur", "architectuurbureau", "woningbouw", "fabriekspand", "fabriekspanden", "stedenbouw", "vastgoed", "makelaar", "makelaardij", "projectontwikkelaar", "architects", "architecture", "realestate", "property"]],
+  ["mortar", ["bouw", "bouwbedrijf", "aannemer", "aannemersbedrijf", "renovatie", "verbouwing", "timmerman", "dakdekker", "loodgieter", "installateur", "installatiebedrijf", "elektricien", "construction", "contractor", "builder", "plumber", "renovation"]],
+  ["portico", ["hotel", "hotels", "resort", "vakantie", "vakantiehuis", "vakantiepark", "gastenverblijf", "reisbureau", "reizen", "travel", "holiday", "villa"]],
+  ["transit", ["logistiek", "logistieke", "vracht", "vrachtvervoer", "distributie", "distributiecentrum", "transport", "transportbedrijf", "transporteur", "expeditie", "magazijn", "container", "containers", "depot", "pallets", "logistics", "freight", "warehouse", "haulage", "shipping"]],
+  ["cadence", ["sport", "sportschool", "sportclub", "gym", "fitness", "crossfit", "boksen", "atletiek", "hardlopen", "wielrennen", "running", "boxing", "athletics"]],
+  ["vessel", ["yoga", "yogastudio", "pilates", "fysio", "fysiotherapie", "fysiotherapeut", "wellness", "sauna", "massage", "physio", "spa"]],
+  ["sable", ["kapper", "kapsalon", "barbier", "barbershop", "beauty", "schoonheidssalon", "nagelstudio", "salon", "hairdresser", "barber"]],
+  ["bolt", ["mode", "kleding", "kledingmerk", "boetiek", "textiel", "stoffen", "maatpak", "naaiatelier", "fashion", "clothing", "textile", "tailor"]],
+  ["linen", ["therapie", "therapeut", "coach", "coaching", "psycholoog", "praktijk", "zorg", "tandarts", "huisarts", "kliniek", "therapy", "therapist", "care", "clinic"]],
+  ["ledger", ["advocaat", "advocaten", "advocatenkantoor", "notaris", "accountant", "boekhouder", "consultancy", "juridisch", "verzekering", "financieel", "lawyer", "law", "accounting", "finance", "consulting"]],
+  ["forge", ["smid", "smederij", "metaal", "metaalbewerking", "lassen", "ambacht", "meubelmaker", "werkplaats", "blacksmith", "metalwork", "furniture", "workshop"]],
+  ["vitrine", ["webshop", "winkel", "etalage", "retail", "ecommerce", "sieraden", "keramiek", "cosmetica", "shop", "store", "jewellery", "jewelry", "ceramics", "cosmetics"]],
+  ["loam", ["boerderij", "kwekerij", "tuinderij", "landbouw", "akkerbouw", "oogst", "teler", "telers", "bloemen", "farm", "grower", "agriculture"]],
+  ["primer", ["school", "basisschool", "kinderopvang", "onderwijs", "creche", "bso", "childcare", "kindergarten"]],
+  ["quire", ["portfolio", "ontwerper", "designer", "illustrator", "fotograaf", "grafisch", "ontwerpstudio", "creatief", "photographer", "studio", "agency"]],
+  ["circuit", ["hardware", "elektronica", "sensor", "sensoren", "robotica", "iot", "electronics", "robotics"]],
+  ["assembly", ["festival", "festivals", "muziekfestival", "evenement", "evenementen", "congres", "conferentie", "theater", "podium", "poppodium", "concert", "concerten", "event", "events", "conference", "venue"]],
+  ["brume", ["natuur", "landschap", "kust", "zee", "strand", "wandelen", "nature", "landscape", "coast", "hiking"]],
+  ["halide", ["software", "saas", "softwarebedrijf", "app", "platform"]],
+];
+
+export const PRODUCT_LAUNCH_WORDS = ["lancering", "lanceren", "lanceert", "gelanceerd", "productlancering", "launch", "launches", "launching", "introductie", "product", "producten", "products"];
+
+/** The pack a brief's own sector words point at, or null. */
+export function packSignalForBrief(brief) {
+  const words = normalize(brief).split(" ").filter(Boolean);
+  const tokens = new Set(words);
+  for (let i = 0; i < words.length - 1; i++) tokens.add(`${words[i]}${words[i + 1]}`);
+  let best = null;
+  for (const [pack, signals] of PACK_SIGNALS) {
+    const score = signals.filter((s) => tokens.has(s)).length;
+    if (score > 0 && (!best || score > best.score)) best = { pack, score };
+  }
+  return best?.pack ?? null;
+}
+
+/** The pack for a brief, with the stated fallbacks. */
+export function packForBrief(brief) {
+  const matched = packSignalForBrief(brief);
+  if (matched) return matched;
+  const words = new Set(normalize(brief).split(" ").filter(Boolean));
+  return PRODUCT_LAUNCH_WORDS.some((w) => words.has(w)) ? "vitrine" : "halide";
+}
+
+/** Why a pack was picked, in one line for the log. */
+export function packReason(brief) {
+  const matched = packSignalForBrief(brief);
+  if (matched) return `sector words in the brief point at ${matched}`;
+  const words = new Set(normalize(brief).split(" ").filter(Boolean));
+  return PRODUCT_LAUNCH_WORDS.some((w) => words.has(w))
+    ? "no sector word, a product launch: vitrine, and the hero scene carries the product"
+    : "no sector word: halide, a wrong photograph is worse than an abstract one";
+}
+
+// Per pack: photos whose alt names one of `terms` only fit a brief that says one of `unless`.
+export const IMAGE_RULES = {
+  proof: [
+    {
+      subject: "bakery",
+      terms: ["meel", "meelafdrukken", "meelstof", "bestoven", "deeg", "deegbol", "brood", "broden", "desem", "desembroden", "zuurdesem", "zuurdesembrood", "bakker", "kruim", "korst", "bakproces", "bloem"],
+      unless: ["bakkerij", "bakker", "brood", "patisserie", "bakery", "bread", "lunchroom", "desem", "zuurdesem", "deeg", "meel", "pizzeria", "pizza"],
+    },
+  ],
+  vitrine: [
+    { subject: "cosmetics", terms: ["flessen", "flacons", "fles", "parfum", "cosmetica"], unless: ["cosmetica", "cosmetics", "parfum", "skincare", "huidverzorging", "fles", "flessen", "glas", "drank", "drink", "olie"] },
+  ],
+  transit: [
+    { subject: "freight", terms: ["containers", "zeecontainers", "container", "laadperron", "pallets", "heftruck", "depot"], unless: PACK_SIGNALS.find(([p]) => p === "transit")[1] },
+  ],
+};
+
+const words = (text) => new Set(normalize(text).split(" ").filter((w) => w.length >= 4));
+
+// Words that say nothing about a subject, in a brief or an alt.
+const STOP = new Set([
+  "voor", "naar", "door", "deze", "onze", "jouw", "maar", "ook", "wordt", "worden", "zijn", "heeft", "hebben", "alle", "meer", "veel", "waar", "wat", "welke", "tussen", "onder", "boven", "over", "zonder", "rond", "langs",
+  "with", "from", "that", "this", "your", "into", "about", "over", "under", "their", "every",
+  "lancering", "launch", "nieuwe", "nieuw", "website", "pagina", "site", "page", "landing", "landingspagina", "merk", "brand", "bedrijf", "company",
+  "elektrische", "elektrisch", "electric", "groot", "grote", "klein", "kleine", "mooi", "mooie", "spectaculair", "spectacular",
+]);
+/** The words of a text that name a subject: four letters or more, no filler. */
+export const contentWords = (text) => new Set([...words(text)].filter((w) => !STOP.has(w)));
+
+/** True when a photo's alt names something the brief is about (compounds count: stadsstraat holds stad). */
+export function altFitsBrief(alt, brief) {
+  const b = [...contentWords(brief)];
+  return [...contentWords(alt ?? "")].some((w) => b.some((x) => w === x || (x.length >= 4 && w.includes(x))));
+}
+
+/**
+ * Keep the photos that fit this client, best fit first per slot.
+ * images: [{ slot, alt, description, ... }]. Returns { keep, dropped, fit } in slot order.
+ *
+ * When the brief's own sector words point at this pack, its photos show the client's world and
+ * only off-subject ones are left out (fit "full"). When they do not (a product launch handed
+ * vitrine, a pack named by hand), a photo is kept only if its alt names something the brief is
+ * about: the material, the city, the street. Otherwise none: an off-topic photo is worse than no
+ * photo (fit "partial" or "none").
+ */
+export function fitImages(pack, brief, images) {
+  const b = words(brief);
+  const strict = packSignalForBrief(brief) !== pack;
+  const rules = IMAGE_RULES[pack] ?? [];
+  const keep = [];
+  const dropped = [];
+  for (const img of images) {
+    const altWords = words(img.alt ?? "");
+    // Dutch compounds carry the subject inside them (meelsporen, broodkorst), so a term counts
+    // when an alt word contains it; the brief's own words still have to match whole.
+    const names = (t) => [...altWords].some((w) => w.includes(t));
+    const offSubject = rules.find((r) => r.terms.some(names) && !r.unless.some((u) => b.has(u)));
+    if (offSubject) dropped.push({ ...img, reason: `shows ${offSubject.subject}, which the brief does not name` });
+    else if (strict && !altFitsBrief(img.alt, brief)) dropped.push({ ...img, reason: "shows nothing this brief is about" });
+    else keep.push(img);
+  }
+  const fit = !strict ? "full" : keep.length ? "partial" : "none";
+  const score = (img) => {
+    const w = words(`${img.alt ?? ""} ${img.description ?? ""}`);
+    let n = 0;
+    for (const x of b) if (w.has(x)) n++;
+    return n;
+  };
+  const order = [];
+  const slots = [...new Set(keep.map((i) => i.slot))];
+  for (const slot of slots) {
+    order.push(...keep.filter((i) => i.slot === slot).map((img, i) => ({ img, i, s: score(img) })).sort((x, y) => y.s - x.s || x.i - y.i).map((x) => x.img));
+  }
+  return { keep: order, dropped, fit };
+}