caracms 0.1.0 → 0.2.0

package/skills/caracms-tina/tina-to-caracms.mjs

@@ -0,0 +1,1011 @@
+#!/usr/bin/env node
+/**
+ * Tina → caracms: the content conversion (the reference script of the caracms-tina skill).
+ *
+ * Copy this file into the site's own `scripts/`, adapt the table under "ADAPT HERE", and
+ * run it from the site's root against a **built** checkout of the Tina site's `main`:
+ *
+ *   node scripts/tina-to-caracms.mjs --from <a built Tina checkout> [--to .]
+ *        [--recipients <address>] [--scaffold-config [--force]]
+ *
+ * - `--from` must hold `content/` and `tina/__generated__/_schema.json` (Tina generates the
+ *   schema when the site builds: `pnpm build:local` there, or the site's own build).
+ * - `--to` is the caracms site's root (default: the current directory). It needs caracms
+ *   installed: the script borrows the package's image sniffer and S3 signer (bin/media.mjs).
+ * - `--recipients <address>`: every form's recipients in Site Settings become this one
+ *   address. For a branch environment whose test submissions mustn't reach the client.
+ *   The run at the switch leaves it out.
+ * - `--scaffold-config`: also write a starting `caracms.config.ts` from Tina's schema, with
+ *   Tina's labels and help, over `caracms init`'s starting config. It refuses any other
+ *   existing config unless `--force`. Do it once: after that the config and the block
+ *   components are the site's own, hand-maintained, and a normal run never touches them.
+ *
+ * WHAT IT OWNS: `content/`, nothing else. Each run deletes `content/` and writes it again
+ * from Tina's files, so the same input gives byte-identical output, and a run on newer
+ * Tina content leaves nothing of an older run behind. Files are laid out the way the
+ * editor saves them (two-space JSON, a media value on one line, rich text one block per
+ * line, a list of strings on one line), so `caracms validate` finds nothing to reformat.
+ * Beside `content/` it only ever adds to two things:
+ *   - `scripts/tina-media-sizes.json`, the images' `w`/`h` by bucket key (commit it). It's
+ *     read first; an image missing from it is fetched once (its Tina URL over HTTP, else
+ *     the bucket with the site's S3_* settings) and the file is rewritten, sorted;
+ *   - the media bucket, for a file link (`/files/<name>`): the object is copied to a
+ *     caracms file key, `uploads/<12 hex of SHA-256 of the source key>/<name>`, and the copy
+ *     is skipped when that key exists. Without S3_* settings the content is still written,
+ *     and the copies still to make are listed.
+ *
+ * How each Tina field kind maps: `field-kinds.md` beside this script (the skill's mapping
+ * table). Everything is driven by Tina's schema; nothing below is written per block.
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+// ── ADAPT HERE: the site's own choices (everything below this table is generic) ──────────
+
+/**
+ * @typedef {object} SiteTable
+ * @property {Record<string, string>} blockRenames
+ * @property {Record<string, unknown>} fieldDefaults
+ * @property {string[]} addressFields
+ * @property {string[]} headingFields
+ * @property {string[]} docTitleAlt
+ * @property {{ pattern: RegExp, sourceKey: (name: string) => string }} fileLinks
+ * @property {string} homeFile
+ */
+
+/** @type {SiteTable} */
+export const SITE = {
+	/** Tina template → caracms block key, where it differs from the camelCase → kebab-case rule (`textMedia` → `text-media`). The approved block table. */
+	blockRenames: {
+		// features: 'steps',
+	},
+	/**
+	 * Values Tina's files leave out but the site's mapper code reads as set (the trial's
+	 * TOGGLE_DEFAULT_ON, a per-block background default that isn't the first option).
+	 * By schema path: `blocks.<template>.<field>`, `<collection>.<field>`, `siteSettings.<field>`,
+	 * nested with dots. Filled into the content when blank, and the select's or toggle's
+	 * `default` in a scaffolded config.
+	 */
+	fieldDefaults: {
+		// 'blocks.textMedia.background': 'cream',
+		// 'jobs.live': true,
+	},
+	/** Strings that are an address with no words (`link({ addressOnly: true })`), by schema path. A string named `href` always is. */
+	addressFields: [
+		// 'siteSettings.socials.instagram',
+	],
+	/** Text fields, by name, whose text is a heading (`heading: true`: it may hold the page's h1). Scaffold only. */
+	headingFields: ['heading'],
+	/** Images with no `…Alt` sibling that take the document's title as their alt (a client's logo is its name), by schema path. Others are decorative. */
+	docTitleAlt: [
+		// 'clientLogos.logo',
+	],
+	/** A file link the Tina site serves itself (`/files/<name>`), and the bucket key it serves it from. */
+	fileLinks: { pattern: /^\/files\/([^/?#]+)$/, sourceKey: (name) => `uploads/${name}` },
+	/** Tina's home page file (it becomes `index`). */
+	homeFile: 'home',
+};
+
+// ── The template's conventions (the same in every site made from it) ────────────────────
+
+const SETTINGS = 'siteSettings';
+/** Site Settings' fields that are caracms's own keys, not site fields. */
+const OWN_SETTINGS = new Set(['formNotifications', 'adminAccess', 'adminBranding', 'defaultSeo', 'googleTag', 'submissionsLink']);
+const SIZES_FILE = 'scripts/tina-media-sizes.json';
+
+// ── Names ──────────────────────────────────────────────────────────────────────────────
+
+/** camelCase (or anything else) → kebab-case: `jumpLinks` → `jump-links`, `CTA2` → `cta2`. */
+export function kebab(name) {
+	return String(name)
+		.replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+		.replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
+		.replace(/[^A-Za-z0-9]+/g, '-')
+		.replace(/^-+|-+$/g, '')
+		.toLowerCase();
+}
+
+/** A Tina template's caracms block key. */
+export const blockKey = (template, site = SITE) => site.blockRenames[template] ?? kebab(template);
+
+/** The 12 hex a copied file's caracms key takes: the first 12 of the source key's SHA-256. */
+export const fileHash = (sourceKey) => createHash('sha256').update(sourceKey).digest('hex').slice(0, 12);
+
+/**
+ * A Tina-served file link → its caracms file key and address, or null when it isn't one.
+ * `slugify` is the package's (bin/media.mjs), so the name part follows the upload route's rule.
+ */
+export function fileLink(href, slugify, site = SITE) {
+	if (typeof href !== 'string') return null;
+	const m = site.fileLinks.pattern.exec(href);
+	if (!m) return null;
+	let name;
+	try {
+		name = decodeURIComponent(m[1]);
+	} catch {
+		return null;
+	}
+	const dot = name.lastIndexOf('.');
+	if (dot <= 0) return null;
+	const ext = name.slice(dot + 1).toLowerCase();
+	const stem = slugify(name.slice(0, dot)) || 'file';
+	const sourceKey = site.fileLinks.sourceKey(name);
+	const hash = fileHash(sourceKey);
+	return { sourceKey, key: `uploads/${hash}/${stem}.${ext}`, address: `/files/${hash}/${encodeURIComponent(`${stem}.${ext}`)}` };
+}
+
+// ── The field kinds (Tina field → caracms field), from the schema ─────────────────────────
+
+const fieldNames = (f) => (f.fields ?? []).map((g) => g.name);
+const optionValues = (f) => f.options.map((o) => (typeof o === 'string' ? o : o.value));
+const isImagePair = (f, siblings) => f.type === 'image' && siblings.some((g) => g.name === `${f.name}Alt` && g.type === 'string' && !g.list);
+const hasLinkPair = (siblings) => siblings.some((f) => f.name === 'linkLabel' && f.type === 'string') && siblings.some((f) => f.name === 'href' && f.type === 'string');
+
+/**
+ * Tina's fields at one level → caracms's, in order: each a spec `{ name, kind, tina, … }`.
+ * `at` is the schema path of the level (`blocks.columns.items`). The pairs merge here: an
+ * image with its `…Alt` becomes one media field (the alt field goes), and `linkLabel` +
+ * `href` become one `link` field where `linkLabel` stood.
+ */
+export function compileFields(fields, at, site = SITE) {
+	const out = [];
+	const pair = hasLinkPair(fields);
+	for (const f of fields) {
+		if (f.type === 'displayOnly' || f.isTitle) continue;
+		if (fields.some((g) => isImagePair(g, fields) && f.name === `${g.name}Alt`)) continue;
+		if (pair && f.name === 'href') continue;
+		if (pair && f.name === 'linkLabel') {
+			out.push({ name: 'link', kind: 'link', label: 'Link', pair: true, at: `${at}.link` });
+			continue;
+		}
+		out.push(compileField(f, fields, `${at}.${f.name}`, site));
+	}
+	return out;
+}
+
+/** One Tina field → its spec. */
+export function compileField(f, siblings, at, site = SITE) {
+	const base = { name: f.name, tina: f, at, label: f.label ?? f.name, help: f.description };
+	if (f.type === 'image') {
+		const alt = isImagePair(f, siblings) ? `${f.name}Alt` : null;
+		return { ...base, kind: 'media', only: 'image', alt, titleAlt: site.docTitleAlt.includes(at) };
+	}
+	if (f.type === 'object' && !f.list && f.fields?.some((g) => g.name === 'kind') && f.fields?.some((g) => g.name === 'src' && g.type === 'image')) {
+		const clips = f.fields.some((g) => g.name === 'playbackId');
+		return { ...base, kind: 'media', object: true, only: clips ? undefined : 'image' };
+	}
+	if (f.type === 'rich-text') {
+		const o = f.overrides;
+		const headings = o?.headingLevels ? o.headingLevels.map((h) => (typeof h === 'number' ? `h${h}` : String(h))).filter((h) => h === 'h2' || h === 'h3') : ['h2', 'h3'];
+		const links = o?.toolbar ? o.toolbar.includes('link') : true;
+		return { ...base, kind: 'richText', headings, links };
+	}
+	if (f.type === 'reference') return { ...base, kind: 'reference', to: f.collections?.[0] };
+	if (f.type === 'boolean') return { ...base, kind: 'toggle', default: site.fieldDefaults[at] };
+	if (f.type === 'number') return { ...base, kind: 'number' };
+	if (f.type === 'datetime') return { ...base, kind: 'date' };
+	if (f.type === 'string') {
+		if (f.options && f.list) return { ...base, kind: 'list', item: { kind: 'select', options: f.options } };
+		if (f.options) return { ...base, kind: 'select', options: f.options, default: site.fieldDefaults[at] };
+		if (f.list) return { ...base, kind: 'list', item: { kind: 'text' } };
+		if (f.name === 'href' || site.addressFields.includes(at)) return { ...base, kind: 'address' };
+		return { ...base, kind: 'text', multiline: f.ui?.component === 'textarea', heading: site.headingFields.includes(f.name) && at.startsWith('blocks.') };
+	}
+	if (f.type === 'object' && f.list && !f.templates) {
+		const names = fieldNames(f).join();
+		if (names === 'label,href,style' && f.fields[2].options) return { ...base, kind: 'buttons', styles: optionValues(f.fields[2]) };
+		if (names === 'label,href') return { ...base, kind: 'list', item: { kind: 'link' } };
+		const inner = compileFields(f.fields, at, site);
+		// A list of one-field objects is a list of that field: [{ line: 'a' }] → ['a'].
+		if (inner.length === 1 && ['text', 'reference', 'media'].includes(inner[0].kind) && !inner[0].object) return { ...base, kind: 'list', item: inner[0], unwrap: inner[0].name };
+		return { ...base, kind: 'list', fields: inner };
+	}
+	if (f.type === 'object' && !f.list && !f.templates) return { ...base, kind: 'group', fields: compileFields(f.fields, at, site) };
+	throw new Error(`${at}: no caracms field for Tina's "${f.type}"${f.list ? ' list' : ''}`);
+}
+
+// ── Values ─────────────────────────────────────────────────────────────────────────────
+
+/** An image URL → its bucket key (`uploads/x.jpg`), the part after `s3://<bucket>/`; null when it isn't one. */
+export function imageKey(src) {
+	if (typeof src !== 'string' || src.trim() === '') return null;
+	const m = src.match(/\/plain\/s3:\/\/[^/]+\/([^?#]+)$/) ?? src.match(/^s3:\/\/[^/]+\/([^?#]+)$/);
+	if (!m) return null;
+	try {
+		return decodeURI(m[1]);
+	} catch {
+		return m[1];
+	}
+}
+
+/** Tina's inline Markdown → caracms's: Tina's escapes undone (caracms escapes only * [ ] \), its line breaks as `\n`, `_`/`__` as `*`/`**`. */
+export function inlineMarkdown(s) {
+	return (
+		s
+			// Tina's two forms of a line break: a trailing backslash, or two spaces.
+			.replace(/(?:\\| {2,})\n/g, '\n')
+			// Tina escapes punctuation Markdown would read (`A\&M`, `mailto\:`).
+			// Left to right, so an escaped backslash (`\\`) stays one escape.
+			.replace(/\\([^\n])/g, (pair, c) => ('*[]\\'.includes(c) ? pair : c))
+			.replace(/(^|[^\w\\*])__(?=\S)([^\n]*?\S)__(?!\w)/g, '$1**$2**')
+			.replace(/(^|[^\w\\*])_(?=\S)([^_\n]*?\S)_(?!\w)/g, '$1*$2*')
+			.trim()
+	);
+}
+
+/**
+ * One Tina rich-text value (Markdown) → caracms's stored rich text: `[{ "p": … }, { "ul": [ … ] }, { "h2": … }]`.
+ * `rewriteHref` turns each link's address (a Tina file link becomes a caracms one).
+ */
+/** @param {unknown} md @param {{ rewriteHref?: (href: string) => string, warn?: (message: string) => void }} [options] */
+export function richText(md, { rewriteHref = (h) => h, warn = () => {} } = {}) {
+	if (typeof md !== 'string') return [];
+	const out = [];
+	const links = (s) => s.replace(/\]\(([^)\s]+)\)/g, (_, href) => `](${rewriteHref(href)})`);
+	const unit = (s) => links(inlineMarkdown(s));
+	for (const chunk of md.replace(/\r\n?/g, '\n').split(/\n[ \t]*\n/)) {
+		const lines = chunk.split('\n');
+		let para = [];
+		let list = null;
+		const flushPara = () => {
+			const text = unit(para.join('\n'));
+			if (text) out.push({ p: text });
+			para = [];
+		};
+		const flushList = () => {
+			if (list && list.items.length) out.push({ [list.kind]: list.items });
+			list = null;
+		};
+		for (const line of lines) {
+			const bullet = /^(\s*)[*+-]\s+(.*)$/.exec(line);
+			const numbered = /^(\s*)\d+[.)]\s+(.*)$/.exec(line);
+			const heading = /^(#{1,6})\s+(.*)$/.exec(line);
+			if (heading) {
+				flushPara();
+				flushList();
+				const level = heading[1].length;
+				if (level === 2 || level === 3) out.push({ [`h${level}`]: unit(heading[2]) });
+				else {
+					warn(`an h${level} in rich text, kept as a paragraph`);
+					out.push({ p: unit(heading[2]) });
+				}
+			} else if (bullet || numbered) {
+				flushPara();
+				const kind = bullet ? 'ul' : 'ol';
+				const m = bullet ?? numbered;
+				if (m[1].length > 0) warn('a nested list item, flattened into its list (caracms has no nested lists)');
+				if (list && list.kind !== kind) flushList();
+				list ??= { kind, items: [] };
+				const item = unit(m[2]);
+				if (item) list.items.push(item);
+			} else if (list && /^\s+\S/.test(line)) {
+				// A list item's continuation line.
+				list.items[list.items.length - 1] = unit(`${list.items[list.items.length - 1]}\n${line.trim()}`);
+			} else {
+				flushList();
+				if (line.trim() !== '' || para.length) para.push(line);
+			}
+		}
+		flushPara();
+		flushList();
+	}
+	return out.filter((b) => {
+		const v = Object.values(b)[0];
+		return Array.isArray(v) ? v.length > 0 : v !== '';
+	});
+}
+
+/** A media value in caracms's key order (media-value.ts → mediaToJson). */
+function imageValue(key, alt, { decorative = false, focal } = {}) {
+	const out = { key, alt: decorative ? '' : (alt ?? '') };
+	if (decorative) out.decorative = true;
+	if (focal) out.focal = focal;
+	return out;
+}
+
+/**
+ * Convert documents, by their compiled specs. One converter per run: it collects the
+ * images (for their sizes) and the file links (for their copies) as it goes.
+ */
+export function converter({ collections, slugify, site = SITE }) {
+	const warnings = [];
+	const images = []; // { value, url } — `value` gets w/h later
+	const files = new Map(); // key → { sourceKey, key }
+	const warn = (where, message) => warnings.push(`${where}: ${message}`);
+
+	const rewriteHref = (href) => {
+		const f = fileLink(href, slugify, site);
+		if (!f) return href;
+		files.set(f.key, f);
+		return f.address;
+	};
+
+	/** A reference (`content/games/x.json`) → the document's path in its collection (`x`). */
+	const refPath = (value, to, where) => {
+		if (typeof value !== 'string' || !value) return undefined;
+		const c = collections[to];
+		const folder = c ? `${c.tina.path.replace(/\/+$/, '')}/` : '';
+		let rel = value.startsWith(folder) ? value.slice(folder.length) : path.posix.basename(value);
+		rel = rel.replace(/\.[^./]+$/, '');
+		if (c?.sections && rel === site.homeFile) rel = 'index';
+		if (!c) warn(where, `a reference to "${value}" in an unknown collection`);
+		return rel;
+	};
+
+	const image = (src, alt, where, opts) => {
+		const key = imageKey(src);
+		if (!key) {
+			if (typeof src === 'string' && src.trim()) warn(where, `"${src}" isn't an image in the media bucket, so it's left out`);
+			return undefined;
+		}
+		const value = imageValue(key, alt, opts);
+		images.push({ value, url: src });
+		return value;
+	};
+
+	function value(spec, raw, parent, where, doc) {
+		const at = spec.at;
+		if (spec.kind === 'link' && spec.pair) {
+			const label = parent?.linkLabel ?? '';
+			const href = parent?.href ?? '';
+			if (!label && !href) return undefined;
+			return { label, href: rewriteHref(href) };
+		}
+		if (raw === undefined || raw === null || (raw === '' && spec.kind !== 'text')) {
+			const fallback = site.fieldDefaults[at];
+			if (fallback !== undefined && (spec.kind === 'select' || spec.kind === 'toggle' || spec.kind === 'text' || spec.kind === 'number')) return fallback;
+			if (spec.kind === 'richText' && raw === '') return [];
+			return undefined;
+		}
+		switch (spec.kind) {
+			case 'text':
+				if (typeof raw !== 'string') warn(where, `expected text, found ${JSON.stringify(raw)}`);
+				return raw;
+			case 'select': {
+				const ok = optionValues({ options: spec.options }).includes(raw);
+				if (!ok) {
+					warn(where, `"${raw}" isn't one of the options, so it's left out (the field's default applies)`);
+					return undefined;
+				}
+				return raw;
+			}
+			case 'toggle':
+			case 'number':
+			case 'date':
+				return raw;
+			case 'address':
+				return { href: rewriteHref(String(raw)) };
+			case 'richText':
+				return richText(raw, { rewriteHref, warn: (m) => warn(where, m) });
+			case 'reference':
+				return refPath(raw, spec.to, where);
+			case 'buttons':
+				return Array.isArray(raw) ? raw.map((b) => ({ label: b?.label ?? '', href: rewriteHref(b?.href ?? ''), style: b?.style ?? spec.styles[0] })) : undefined;
+			case 'media': {
+				if (spec.object) return mediaObject(raw, where);
+				const alt = spec.alt ? (parent?.[spec.alt] ?? '') : spec.titleAlt ? (doc.title ?? '') : '';
+				return image(raw, alt, where, { decorative: !spec.alt && !spec.titleAlt });
+			}
+			case 'list': {
+				if (!Array.isArray(raw)) return undefined;
+				if (spec.item?.kind === 'link') return raw.map((r) => ({ label: r?.label ?? '', href: rewriteHref(r?.href ?? '') }));
+				// The unwrap comes first (M9 port friction 9): a list of one-text-field objects
+				// (`facts: [{ label: 'age 9+' }]`) has a text item too, and isn't a list of strings.
+				if (spec.unwrap) {
+					return raw.map((r, i) => value(spec.item, r?.[spec.unwrap], r, `${where}[${i}]`, doc)).filter((v) => v !== undefined && v !== '');
+				}
+				if (spec.item?.kind === 'select' || spec.item?.kind === 'text') return raw.filter((s) => typeof s === 'string');
+				return raw.map((r, i) => object(spec.fields, r, `${where}[${i}]`, doc));
+			}
+			case 'group':
+				return object(spec.fields, raw, where, doc);
+			default:
+				throw new Error(`${at}: no conversion for "${spec.kind}"`);
+		}
+	}
+
+	function mediaObject(raw, where) {
+		if (!raw || typeof raw !== 'object') return undefined;
+		const kind = raw.kind ?? (raw.src ? 'image' : raw.playbackId ? 'video' : undefined);
+		if (kind === 'image') {
+			const focal = Number.isFinite(raw.focusX) && Number.isFinite(raw.focusY) ? [raw.focusX / 100, raw.focusY / 100] : undefined;
+			return image(raw.src, raw.alt ?? '', where, { focal });
+		}
+		if (kind === 'video' && raw.playbackId) {
+			const out = { video: raw.playbackId, play: raw.playAs === 'player' ? 'player' : 'loop' };
+			if (Number.isFinite(raw.posterTime) && raw.posterTime >= 0) out.poster = raw.posterTime;
+			if (raw.name) out.name = raw.name;
+			if (Number.isFinite(raw.duration) && raw.duration > 0) out.duration = raw.duration;
+			if (raw.mono) warn(where, 'a black-and-white clip: caracms has no mono, so it plays in colour');
+			return out;
+		}
+		return undefined;
+	}
+
+	/** One level of fields → caracms's object, keys in schema order. Unknown keys in Tina's file are dropped with a warning. */
+	function object(specs, raw, where, doc) {
+		const out = {};
+		for (const spec of specs) {
+			const v = value(spec, raw?.[spec.name], raw, `${where}.${spec.name}`, doc);
+			if (v !== undefined) out[spec.name] = v;
+		}
+		if (raw && typeof raw === 'object') {
+			const known = new Set(specs.flatMap((s) => [s.name, ...(s.pair ? ['linkLabel', 'href'] : []), ...(s.alt ? [s.alt] : [])]));
+			for (const k of Object.keys(raw)) if (!known.has(k) && k !== '_template' && raw[k] !== null) warn(where, `"${k}" isn't in Tina's schema any more, so it's left out`);
+		}
+		return out;
+	}
+
+	return { warnings, warn, images, files, object, value, rewriteHref, image };
+}
+
+// ── Layout: the editor's save (serialize.ts → savedForm, toJson), written out again ──────
+
+const pad = (depth) => '  '.repeat(depth);
+const objectText = (members, depth) => (members.length === 0 ? '{}' : `{\n${members.map(([k, v]) => `${pad(depth + 1)}${JSON.stringify(k)}: ${v}`).join(',\n')}\n${pad(depth)}}`);
+const arrayText = (items, depth) => (items.length === 0 ? '[]' : `[\n${items.map((v) => pad(depth + 1) + v).join(',\n')}\n${pad(depth)}]`);
+
+/** Canonical JSON: two-space indent, one member per line, a list of strings on one line. */
+export function toJson(value, depth = 0) {
+	if (value === null || typeof value !== 'object') return JSON.stringify(value ?? null);
+	if (Array.isArray(value)) {
+		if (value.length === 0) return '[]';
+		if (value.every((v) => typeof v === 'string')) return `[${value.map((v) => JSON.stringify(v)).join(', ')}]`;
+		return arrayText(value.map((v) => toJson(v, depth + 1)), depth);
+	}
+	return objectText(Object.entries(value).filter(([, v]) => v !== undefined).map(([k, v]) => [k, toJson(v, depth + 1)]), depth);
+}
+
+function inlineText(value) {
+	if (value === null || typeof value !== 'object') return JSON.stringify(value ?? null);
+	if (Array.isArray(value)) return `[${value.map(inlineText).join(', ')}]`;
+	const entries = Object.entries(value);
+	return entries.length ? `{ ${entries.map(([k, v]) => `${JSON.stringify(k)}: ${inlineText(v)}`).join(', ')} }` : '{}';
+}
+
+const PLAIN = { kind: 'plain' };
+const INLINE = { kind: 'inline' };
+
+/** How a field's value is laid out (serialize.ts → shapeOf). */
+export function shapeOf(spec) {
+	switch (spec.kind) {
+		case 'media':
+			return INLINE;
+		case 'richText':
+			return { kind: 'rich' };
+		case 'group':
+			return { kind: 'object', keys: shapesOf(spec.fields) };
+		case 'list':
+			if (spec.item) return spec.item.kind === 'media' ? { kind: 'list', item: INLINE } : spec.item.kind === 'richText' ? { kind: 'list', item: { kind: 'rich' } } : PLAIN;
+			return { kind: 'list', item: { kind: 'object', keys: shapesOf(spec.fields) } };
+		default:
+			return PLAIN;
+	}
+}
+export const shapesOf = (specs) => new Map(specs.map((s) => [s.name, shapeOf(s)]));
+
+/** A value laid out by its shape (serialize.ts → layout). A list's `item` may be a function of the item (a block's shape is its type's). */
+export function layout(value, shape, depth = 0) {
+	if (value === null || typeof value !== 'object') return toJson(value, depth);
+	switch (shape.kind) {
+		case 'inline':
+			return inlineText(value);
+		case 'rich':
+			if (!Array.isArray(value)) return toJson(value, depth);
+			return arrayText(value.map((e) => (e && typeof e === 'object' && !Array.isArray(e) ? `{ ${Object.entries(e).map(([k, v]) => `${JSON.stringify(k)}: ${toJson(v)}`).join(', ')} }` : toJson(e))), depth);
+		case 'list': {
+			if (!Array.isArray(value)) return toJson(value, depth);
+			const item = typeof shape.item === 'function' ? shape.item : () => shape.item;
+			return arrayText(value.map((v) => layout(v, item(v), depth + 1)), depth);
+		}
+		case 'object':
+			if (Array.isArray(value)) return toJson(value, depth);
+			return objectText(Object.entries(value).map(([k, v]) => [k, layout(v, shape.keys.get(k) ?? PLAIN, depth + 1)]), depth);
+		default:
+			return toJson(value, depth);
+	}
+}
+
+// ── Reading Tina's schema and content ──────────────────────────────────────────────────
+
+/**
+ * Tina's schema → what the conversion and the scaffold need: each collection (sections
+ * or fields) with its compiled fields, the blocks by caracms key, and Site Settings.
+ */
+export function readSchema(schema, site = SITE) {
+	const collections = {};
+	const blocks = new Map(); // key → { template, label, specs }
+	const warnings = [];
+	for (const c of schema.collections) {
+		if (c.name === SETTINGS) continue;
+		const folder = c.path.replace(/^content\/?/, '').replace(/\/+$/, '');
+		const key = kebab(folder);
+		const templates = c.fields.find((f) => f.type === 'object' && f.list && f.templates);
+		const own = c.fields.filter((f) => f !== templates && !f.isTitle && !(templates && (f.name === 'seo' || (f.name === 'hidden' && f.type === 'boolean'))) && !(!templates && f.name === 'seo'));
+		const entry = {
+			tina: c,
+			key,
+			label: c.label ?? c.name,
+			sections: !!templates,
+			blocksField: templates?.name,
+			titleField: c.fields.find((f) => f.isTitle)?.name,
+			hasSeo: c.fields.some((f) => f.name === 'seo' && f.type === 'object'),
+			hasHidden: !!templates && c.fields.some((f) => f.name === 'hidden' && f.type === 'boolean'),
+			specs: compileFields(own, c.name, site),
+			blockKeys: [],
+		};
+		if (templates) {
+			for (const t of templates.templates) {
+				const k = blockKey(t.name, site);
+				const description = templateDescription(t);
+				const specs = withoutBlockDescription(compileFields(t.fields, `blocks.${t.name}`, site), description);
+				if (specs.some((s) => s.name === 'type')) throw new Error(`blocks.${t.name}: a field named "type" clashes with caracms's block type`);
+				const known = blocks.get(k);
+				if (known && known.template !== t.name) throw new Error(`Tina templates "${known.template}" and "${t.name}" both become the block "${k}": rename one in SITE.blockRenames`);
+				if (known && JSON.stringify(known.specs.map(strip)) !== JSON.stringify(specs.map(strip))) warnings.push(`blocks.${t.name}: its fields differ between collections; the first one's are used`);
+				if (!known) blocks.set(k, { template: t.name, label: t.label ?? t.name, help: blockHelp(description), specs });
+				entry.blockKeys.push(k);
+			}
+		}
+		collections[c.name] = entry;
+	}
+	const settings = schema.collections.find((c) => c.name === SETTINGS);
+	const settingsSpecs = settings ? compileFields(settings.fields.filter((f) => !OWN_SETTINGS.has(f.name)), SETTINGS, site) : [];
+	return { collections, blocks, settings, settingsSpecs, warnings };
+}
+/** A Tina template's own description (`ui.description`, or `description`), or ''. */
+const templateDescription = (t) => String(t.ui?.description ?? t.description ?? '').trim();
+
+/**
+ * A template's description → the block's help (M6c G8): its first sentence, and the next
+ * while the two stay short, since the block's help sits at the top of its sidebar level.
+ * Undefined when the template has none.
+ */
+export function blockHelp(description) {
+	const text = String(description ?? '').replace(/\s+/g, ' ').trim();
+	if (!text) return undefined;
+	const sentences = text.match(/[^.!?]+(?:[.!?]+["”’)]*|$)/g)?.map((x) => x.trim()).filter(Boolean) ?? [text];
+	let help = sentences[0];
+	if (sentences[1] && help.length + sentences[1].length + 1 <= 160) help = `${help} ${sentences[1]}`;
+	return help;
+}
+
+/**
+ * A template's fields with the template's description taken out of their help. Some Tina
+ * sites (the template's \`aboutText\`) put it in front of the first field's own
+ * description ("About this block: <description> <the field's help>"), the only place
+ * Tina's editor showed it; in caracms it's the block's help, so each field keeps its own.
+ */
+export function withoutBlockDescription(specs, description) {
+	if (!description) return specs;
+	return specs.map((spec) => {
+		const at = typeof spec.help === 'string' ? spec.help.indexOf(description) : -1;
+		if (at < 0) return spec;
+		const own = spec.help.slice(at + description.length).trim();
+		const { help: _h, ...rest } = spec;
+		return own ? { ...rest, help: own } : rest;
+	});
+}
+
+const strip = ({ tina: _t, at: _a, ...rest }) => JSON.stringify(rest, (k, v) => (k === 'tina' || k === 'at' ? undefined : v));
+
+/** Every `.json` file under a folder, as posix paths relative to it, sorted. */
+function jsonFiles(root, rel = '') {
+	const dir = path.join(root, rel);
+	if (!existsSync(dir)) return [];
+	const out = [];
+	for (const name of readdirSync(dir).sort()) {
+		const r = rel ? `${rel}/${name}` : name;
+		if (statSync(path.join(root, r)).isDirectory()) out.push(...jsonFiles(root, r));
+		else if (name.endsWith('.json')) out.push(r);
+	}
+	return out;
+}
+
+const seoOf = (raw, conv, where) => {
+	if (!raw || typeof raw !== 'object') return undefined;
+	const out = {};
+	if (raw.metaTitle) out.title = raw.metaTitle;
+	if (raw.metaDescription) out.description = raw.metaDescription;
+	if (raw.ogImage) {
+		const image = conv.image(raw.ogImage, raw.ogImageAlt ?? '', `${where}.ogImage`);
+		if (image) out.image = image;
+	}
+	return Object.keys(out).length ? out : undefined;
+};
+const SEO_SHAPE = { kind: 'object', keys: new Map([['image', INLINE]]) };
+
+/**
+ * Convert every document. Returns `{ files: Map<relPath, text>, conv }`; nothing is written.
+ * `recipients`: the `--recipients` address, or undefined.
+ */
+export function convertAll({ from, schema, slugify, site = SITE, recipients }) {
+	const read = readSchema(schema, site);
+	const conv = converter({ collections: read.collections, slugify, site });
+	conv.warnings.push(...read.warnings);
+	const docs = []; // { rel, data, shape }
+
+	for (const c of Object.values(read.collections)) {
+		const folder = path.join(from, c.tina.path);
+		for (const file of jsonFiles(folder)) {
+			const where = `${c.tina.path}/${file}`;
+			const raw = JSON.parse(readFileSync(path.join(folder, file), 'utf8'));
+			let name = file.replace(/\.json$/, '');
+			if (c.sections && name === site.homeFile) name = 'index';
+			const rel = `content/${c.key}/${name}.json`;
+			const title = (c.titleField ? raw[c.titleField] : undefined) ?? name;
+			const doc = { title };
+			const data = { $schema: `${'../'.repeat(rel.split('/').length - 1)}schemas/${c.key}.schema.json`, title };
+			if (c.hasHidden && raw.hidden === true) {
+				if (name === 'index') conv.warn(where, "the home page can't be hidden in caracms, so it's shown");
+				else data.hidden = true;
+			}
+			const own = Object.fromEntries(Object.entries(raw).filter(([k]) => ![c.titleField, c.blocksField, ...(c.hasSeo ? ['seo'] : []), ...(c.hasHidden ? ['hidden'] : [])].includes(k)));
+			Object.assign(data, conv.object(c.specs, own, where, doc));
+			if (c.sections) {
+				const blocksRaw = raw[c.blocksField] ?? [];
+				data.blocks = blocksRaw.map((b, i) => {
+					const w = `${where} ${c.blocksField}[${i}]`;
+					const key = blockKey(b?._template, site);
+					const block = read.blocks.get(key);
+					if (!block) throw new Error(`${w}: no template "${b?._template}" in Tina's schema`);
+					return { type: key, ...conv.object(block.specs, b, w, doc) };
+				});
+			}
+			const seo = c.hasSeo ? seoOf(raw.seo, conv, `${where}.seo`) : undefined;
+			if (seo) data.seo = seo;
+			const keys = shapesOf(c.specs);
+			keys.set('seo', SEO_SHAPE);
+			if (c.sections) keys.set('blocks', { kind: 'list', item: (b) => ({ kind: 'object', keys: shapesOf(read.blocks.get(b.type)?.specs ?? []) }) });
+			docs.push({ rel, data, shape: { kind: 'object', keys } });
+		}
+	}
+
+	if (read.settings) {
+		const folder = path.join(from, read.settings.path);
+		const [file] = jsonFiles(folder);
+		if (file) {
+			const where = `${read.settings.path}/${file}`;
+			const raw = JSON.parse(readFileSync(path.join(folder, file), 'utf8'));
+			const rows = (list, key) => (Array.isArray(list) ? list.map((r) => r?.[key]).filter((v) => typeof v === 'string' && v.trim() !== '') : []);
+			const forms = raw.formNotifications && typeof raw.formNotifications === 'object' ? raw.formNotifications : {};
+			const brand = { name: raw.adminBranding?.name || raw.defaultSeo?.metaTitle?.trim() || 'Site' };
+			if (raw.adminBranding?.accent) brand.accent = raw.adminBranding.accent;
+			if (raw.adminBranding?.logo || raw.adminBranding?.favicon) conv.warn(where, "the editor branding's logo and favicon aren't carried over: upload them in the editor (Site Settings → Brand)");
+			const data = {
+				$schema: '../schemas/site-settings.schema.json',
+				title: 'Site Settings',
+				editors: rows(raw.adminAccess?.allow, 'entry'),
+				brand,
+			};
+			const seo = seoOf(raw.defaultSeo, conv, `${where}.defaultSeo`);
+			if (seo) data.seo = seo;
+			if (raw.googleTag) data.googleTag = raw.googleTag;
+			data.formRecipients = Object.fromEntries(Object.keys(forms).sort().map((form) => [form, recipients ? [recipients] : rows(forms[form], 'address')]));
+			Object.assign(data, conv.object(read.settingsSpecs, Object.fromEntries(Object.entries(raw).filter(([k]) => !OWN_SETTINGS.has(k))), where, { title: 'Site Settings' }));
+			const keys = shapesOf(read.settingsSpecs);
+			keys.set('seo', SEO_SHAPE);
+			keys.set('brand', { kind: 'object', keys: new Map([['logo', INLINE], ['icon', INLINE]]) });
+			docs.push({ rel: 'content/site-settings.json', data, shape: { kind: 'object', keys } });
+		}
+	}
+	return { read, conv, docs };
+}
+
+/** The documents' text, once the images have their sizes. */
+export const renderDocs = (docs) => new Map(docs.map((d) => [d.rel, `${layout(d.data, d.shape, 0)}\n`]));
+
+// ── Image sizes and file copies (the only network the script does) ─────────────────────
+
+function readSizes(file) {
+	try {
+		return JSON.parse(readFileSync(file, 'utf8'));
+	} catch {
+		return {};
+	}
+}
+
+async function fetchSize({ url, key }, tools, creds) {
+	const tries = [];
+	if (/^https?:\/\//.test(url)) tries.push(() => fetch(url, { signal: AbortSignal.timeout(60_000) }));
+	if (creds) {
+		tries.push(() => {
+			const signed = tools.signS3(creds, { method: 'GET', key });
+			return fetch(signed.url, { headers: signed.headers, signal: AbortSignal.timeout(60_000) });
+		});
+	}
+	for (const go of tries) {
+		try {
+			const res = await go();
+			if (!res.ok) continue;
+			const sniffed = tools.sniffImage(new Uint8Array(await res.arrayBuffer()));
+			if (sniffed.ok) return { w: sniffed.w, h: sniffed.h };
+		} catch {
+			// the next way, if any
+		}
+	}
+	return null;
+}
+
+/** Fill every image's `w`/`h`: the cache first, then a fetch for what it lacks. Returns the keys learned and the keys still without a size. */
+export async function fillSizes(images, cacheFile, tools, creds) {
+	const cache = readSizes(cacheFile);
+	const wanted = new Map();
+	for (const { value, url } of images) if (!cache[value.key] && !wanted.has(value.key)) wanted.set(value.key, url);
+	const learned = [];
+	const missing = [];
+	for (const key of [...wanted.keys()].sort()) {
+		const size = await fetchSize({ url: wanted.get(key), key }, tools, creds);
+		if (size) {
+			cache[key] = size;
+			learned.push(key);
+		} else missing.push(key);
+	}
+	for (const { value } of images) {
+		const size = cache[value.key];
+		if (size) Object.assign(value, { w: size.w, h: size.h });
+	}
+	if (learned.length) {
+		mkdirSync(path.dirname(cacheFile), { recursive: true });
+		const sorted = Object.fromEntries(Object.keys(cache).sort().map((k) => [k, { w: cache[k].w, h: cache[k].h }]));
+		writeFileSync(cacheFile, `${JSON.stringify(sorted, null, 2)}\n`);
+	}
+	return { learned, missing };
+}
+
+/** Copy each file link's object to its caracms key, unless that key exists. Never deletes. */
+async function copyFiles(files, tools, creds) {
+	const made = [];
+	const kept = [];
+	for (const f of [...files.values()].sort((a, b) => a.key.localeCompare(b.key))) {
+		const head = tools.signS3(creds, { method: 'HEAD', key: f.key });
+		const exists = await fetch(head.url, { method: 'HEAD', headers: head.headers });
+		if (exists.ok) {
+			kept.push(f.key);
+			continue;
+		}
+		const source = `/${creds.S3_BUCKET}/${f.sourceKey.split('/').map(encodeURIComponent).join('/')}`;
+		const put = tools.signS3(creds, { method: 'PUT', key: f.key, headers: { 'x-amz-copy-source': source } });
+		const res = await fetch(put.url, { method: 'PUT', headers: put.headers });
+		const text = await res.text();
+		if (!res.ok || /<Error>/.test(text)) throw new Error(`copying ${f.sourceKey} to ${f.key} failed: ${res.status} ${text.slice(0, 300)}`);
+		made.push(f.key);
+	}
+	return { made, kept };
+}
+
+/** The installed caracms's plain-JS tools (bin/media.mjs): sniffImage, slugify, signS3, readS3Env. */
+async function caracmsTools(root) {
+	const require = createRequire(path.join(root, 'package.json'));
+	let entry;
+	try {
+		entry = require.resolve('caracms');
+	} catch {
+		throw new Error(`caracms isn't installed in ${root}. Run this from the site's root after \`caracms init --write\` and an install.`);
+	}
+	const pkg = path.resolve(path.dirname(entry), '..');
+	const media = await import(pathToFileURL(path.join(pkg, 'bin/media.mjs')).href);
+	return { ...media, packageRoot: pkg };
+}
+
+// ── The scaffold: a starting caracms.config.ts from the same specs ─────────────────────
+
+const q = (s) => JSON.stringify(s);
+const pascal = (key) => key.replace(/(^|-)([a-z0-9])/g, (_, __, c) => c.toUpperCase());
+
+function optionsText(options) {
+	return `[${options.map((o) => (typeof o === 'string' ? q(o) : `{ value: ${q(o.value)}, label: ${q(o.label ?? o.value)} }`)).join(', ')}]`;
+}
+
+/** One spec → its caracms field helper call, as TypeScript. */
+export function fieldConfig(spec, read, used, indent) {
+	const common = [`label: ${q(spec.label)}`];
+	if (spec.help) common.push(`help: ${q(spec.help)}`);
+	const opts = (...extra) => `{ ${[...extra, ...common].join(', ')} }`;
+	const use = (name) => (used.add(name), name);
+	switch (spec.kind) {
+		case 'text': {
+			const extra = [];
+			if (spec.multiline) extra.push('multiline: true');
+			if (spec.heading) extra.push('heading: true');
+			return `${use('text')}(${opts(...extra)})`;
+		}
+		case 'select':
+			return `${use('select')}(${opts(`options: ${optionsText(spec.options)}`, ...(spec.default !== undefined ? [`default: ${q(spec.default)}`] : []))})`;
+		case 'toggle':
+			return `${use('toggle')}(${opts(...(spec.default !== undefined ? [`default: ${q(spec.default)}`] : []))})`;
+		case 'number':
+			return `${use('number')}(${opts()})`;
+		case 'date':
+			return `${use('date')}(${opts()})`;
+		case 'address':
+			return `${use('link')}(${opts('addressOnly: true')})`;
+		case 'link':
+			return `${use('link')}(${opts()})`;
+		case 'richText':
+			return `${use('richText')}(${opts(`headings: ${q(spec.headings)}`, `links: ${spec.links}`)})`;
+		case 'reference':
+			return `${use('reference')}(${opts(`to: ${q(read.collections[spec.to]?.key ?? spec.to)}`)})`;
+		case 'media':
+			return `${use('media')}(${opts(...(spec.only ? [`only: '${spec.only}'`] : []))})`;
+		case 'buttons':
+			return `${use('buttons')}(${opts(`styles: ${q(spec.styles)}`)})`;
+		case 'group':
+			return `${use('group')}(${fieldsConfig(spec.fields, read, used, indent)}, ${opts()})`;
+		case 'list': {
+			if (spec.item) {
+				const item =
+					spec.item.kind === 'link'
+						? `${use('link')}()`
+						: spec.item.kind === 'select'
+							? `${use('select')}({ options: ${optionsText(spec.item.options)} })`
+							: spec.item.kind === 'text' && !spec.item.label
+								? `${use('text')}()`
+								: fieldConfig(spec.item, read, used, indent);
+				return `${use('list')}(${item}, ${opts()})`;
+			}
+			const label = spec.fields.find((s) => s.kind === 'text')?.name;
+			return `${use('list')}(${fieldsConfig(spec.fields, read, used, indent)}, ${opts(...(label ? [`itemLabel: ${q(label)}`] : []))})`;
+		}
+		default:
+			throw new Error(`${spec.at}: no field helper for "${spec.kind}"`);
+	}
+}
+
+function fieldsConfig(specs, read, used, indent) {
+	if (specs.length === 0) return '{}';
+	return `{\n${specs.map((s) => `${indent}\t${s.name}: ${fieldConfig(s, read, used, `${indent}\t`)},`).join('\n')}\n${indent}}`;
+}
+
+/** The starting caracms.config.ts. */
+export function scaffoldConfig(read) {
+	const used = new Set(['defineSite']);
+	const allBlocks = [...read.blocks.keys()];
+	const cols = Object.values(read.collections).map((c) => {
+		const parts = [`label: ${q(c.label)}`];
+		if (c.sections) {
+			parts.push(`kind: 'sections'`, `folder: ${q(`content/${c.key}`)}`, `urlBase: ${q(c.key === 'pages' ? '/' : `/${c.key}/`)}`);
+			if (c.key === 'pages') parts.push('nested: true');
+			if (c.blockKeys.length !== allBlocks.length) parts.push(`blocks: ${q(c.blockKeys)}`);
+			if (c.specs.length) parts.push(`fields: ${fieldsConfig(c.specs, read, used, '\t\t\t')}`);
+		} else {
+			parts.push(`kind: 'fields'`, `folder: ${q(`content/${c.key}`)}`, `component: ${q(`src/components/caracms/${pascal(c.key)}.astro`)}`, `fields: ${fieldsConfig(c.specs, read, used, '\t\t\t')}`);
+		}
+		return `\t\t${/^[a-z][a-z0-9]*$/.test(c.key) ? c.key : q(c.key)}: {\n\t\t\t${parts.join(',\n\t\t\t')},\n\t\t},`;
+	});
+	const blocks = [...read.blocks.entries()].map(([key, b]) => {
+		const name = /^[a-z][a-z0-9]*$/.test(key) ? key : q(key);
+		const help = b.help ? `\t\t\thelp: ${q(b.help)},\n` : '';
+		return `\t\t${name}: {\n\t\t\tlabel: ${q(b.label)},\n${help}\t\t\tcomponent: ${q(`src/blocks/${pascal(key)}.astro`)},\n\t\t\tfields: ${fieldsConfig(b.specs, read, used, '\t\t\t')},\n\t\t},`;
+	});
+	const settings = read.settingsSpecs.length ? `\tsettings: { fields: ${fieldsConfig(read.settingsSpecs, read, used, '\t')} },\n` : '';
+	return `import { ${[...used].sort().join(', ')} } from 'caracms/config';
+
+/**
+ * caracms's config for this site, first scaffolded from Tina's schema by
+ * scripts/tina-to-caracms.mjs --scaffold-config (Tina's labels and help carried over).
+ * From here on it's the site's own: edit it by hand. The conversion never writes it again.
+ *
+ * Still to do by hand: each block's component (src/blocks/*.astro, drawn through Text,
+ * RichText, Media and Block), heading options, page-wide rules in the page component,
+ * the forms and the text styles. Trim Tina's longer help as you go.
+ */
+export default defineSite({
+	collections: {
+${cols.join('\n')}
+	},
+	blocks: {
+${blocks.join('\n')}
+	},
+${settings}	textStyles: {},
+	page: 'src/components/caracms/Page.astro',
+});
+`;
+}
+
+// ── The run ────────────────────────────────────────────────────────────────────────────
+
+export function parseArgs(argv) {
+	const out = { flags: new Set() };
+	for (let i = 0; i < argv.length; i++) {
+		const a = argv[i];
+		if (a === '--scaffold-config' || a === '--force') out.flags.add(a.slice(2));
+		else if (a === '--from' || a === '--to' || a === '--recipients') out[a.slice(2)] = argv[++i];
+		else throw new Error(`Unknown argument: ${a}`);
+	}
+	return out;
+}
+
+const USAGE = 'Usage: node scripts/tina-to-caracms.mjs --from <a built Tina checkout> [--to .] [--recipients <address>] [--scaffold-config [--force]]';
+
+async function main() {
+	let args;
+	try {
+		args = parseArgs(process.argv.slice(2));
+	} catch (error) {
+		console.error(`${error.message}\n${USAGE}`);
+		return 2;
+	}
+	if (!args.from) {
+		console.error(USAGE);
+		return 2;
+	}
+	const FROM = path.resolve(args.from);
+	const TO = path.resolve(args.to ?? '.');
+	if (FROM === TO) {
+		console.error('--from and --to are the same folder: the run would delete the Tina content it reads. Run it from the caracms site against a separate checkout.');
+		return 2;
+	}
+	if (args.recipients !== undefined && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(args.recipients)) {
+		console.error(`--recipients takes one email address, not "${args.recipients}".`);
+		return 2;
+	}
+	const schemaFile = path.join(FROM, 'tina/__generated__/_schema.json');
+	if (!existsSync(schemaFile)) {
+		console.error(`No ${schemaFile}: build the Tina checkout first (its build generates the schema).`);
+		return 1;
+	}
+	const schema = JSON.parse(readFileSync(schemaFile, 'utf8'));
+	const tools = await caracmsTools(TO);
+	const { values: creds, missing: credsMissing } = tools.readS3Env(process.env, TO);
+	const s3 = credsMissing.length === 0 ? creds : null;
+
+	const { read, conv, docs } = convertAll({ from: FROM, schema, slugify: tools.slugify, recipients: args.recipients });
+
+	if (args.flags.has('scaffold-config')) {
+		const file = path.join(TO, 'caracms.config.ts');
+		const starting = readFileSync(path.join(tools.packageRoot, 'bin/templates/caracms.config.ts.txt'), 'utf8');
+		if (existsSync(file) && readFileSync(file, 'utf8') !== starting && !args.flags.has('force')) {
+			console.error("caracms.config.ts isn't caracms init's starting config, so --scaffold-config leaves it (it's the site's own now). Add --force to replace it.");
+			return 1;
+		}
+		writeFileSync(file, scaffoldConfig(read));
+		console.log('Wrote caracms.config.ts from Tina\'s schema.');
+	}
+
+	const sizes = await fillSizes(conv.images, path.join(TO, SIZES_FILE), tools, s3);
+	const texts = renderDocs(docs);
+
+	rmSync(path.join(TO, 'content'), { recursive: true, force: true });
+	for (const [rel, text] of texts) {
+		mkdirSync(path.dirname(path.join(TO, rel)), { recursive: true });
+		writeFileSync(path.join(TO, rel), text);
+	}
+
+	const counts = {};
+	for (const rel of texts.keys()) {
+		const c = rel.split('/').length > 2 ? rel.split('/')[1] : 'site settings';
+		counts[c] = (counts[c] ?? 0) + 1;
+	}
+	console.log(`Wrote content/: ${Object.entries(counts).map(([k, n]) => `${k} ${n}`).join(', ')}.`);
+	console.log(`Images: ${new Set(conv.images.map((i) => i.value.key)).size} keys; ${sizes.learned.length} new size${sizes.learned.length === 1 ? '' : 's'} learned into ${SIZES_FILE}.`);
+	if (sizes.missing.length) console.log(`No size found for:\n  ${sizes.missing.join('\n  ')}`);
+
+	if (conv.files.size) {
+		if (s3) {
+			const { made, kept } = await copyFiles(conv.files, tools, s3);
+			console.log(`Files: ${made.length} copied, ${kept.length} already there.`);
+		} else {
+			console.log(`Files: no S3_* settings (${credsMissing.join(', ')}), so these copies weren't made. Run again with them; a key that exists is skipped:`);
+			for (const f of [...conv.files.values()].sort((a, b) => a.key.localeCompare(b.key))) console.log(`  ${f.sourceKey} → ${f.key}`);
+		}
+	}
+	if (args.recipients) console.log(`Form recipients: every form's are ${args.recipients} (--recipients).`);
+	if (conv.warnings.length) console.log(`Warnings:\n  ${conv.warnings.join('\n  ')}`);
+	return 0;
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
+	main().then(
+		(code) => {
+			process.exitCode = code;
+		},
+		(error) => {
+			console.error(error instanceof Error ? error.message : error);
+			process.exitCode = 1;
+		},
+	);
+}