@acms-subir/core 0.3.2 → 0.3.3-next.20260929113209

package/src/lib/import/apply.ts

@@ -0,0 +1,430 @@
+import { z } from 'zod';
+import { Page, Post, normalizeRedirectPath, slugify, type User } from '../schema';
+import { CONTENT, collectionUrl } from '../content';
+import type { ContentRepository, ImportRecord } from '../repo/types';
+import { ASSET_SCHEME, ImportAuthor, ImportIdentity, ImportItem, ImportNav, ImportRedirect, ImportTag, ImportWarning, type ImportBundle } from './bundle';
+
+// Server half of the import pipeline. The browser parses the source file,
+// re-hosts assets and sends the bundle in steps:
+//
+//   plan    → per-item decisions (create / update / skip), nothing written
+//   start   → import run + authors + tags (+ records of re-hosted media)
+//   items   → batches of posts/pages, re-decided server-side, written
+//   finish  → redirects from old URLs, navigation, site identity, report
+//   undo    → removes what a run created and nobody has edited since
+//
+// Every write is recorded (source id ↔ acms id) so a re-run updates the same
+// items instead of duplicating them, and a closed tab can resume.
+
+export const ImportOptions = z.object({
+  // when a slug is already taken by content that wasn't imported from this
+  // source: keep it, overwrite it, or import alongside with a new slug
+  conflict: z.enum(['skip', 'update', 'copy']).default('skip'),
+  identity: z.boolean().default(false),
+  nav: z.boolean().default(false),
+  redirects: z.boolean().default(true),
+  headCode: z.boolean().default(false),
+  // author sourceId → 'create' | 'skip' | an existing user id | 'as:<sourceId>'
+  // (the same person as another author in this import)
+  authors: z.record(z.string().max(200)).default({}),
+});
+export type ImportOptions = z.infer<typeof ImportOptions>;
+
+export type ItemAction = 'create' | 'update' | 'skip';
+export interface ItemDecision {
+  sourceId: string;
+  type: 'post' | 'page';
+  title: string;
+  slug: string;
+  action: ItemAction;
+  reason: '' | 'exists' | 'imported' | 'done';
+  targetId: string;
+}
+
+export interface ImportState {
+  posts: Post[];
+  pages: Page[];
+  records: Map<string, ImportRecord>; // `${kind}:${sourceId}`
+}
+
+export function cleanSlug(slug: string): string {
+  const s = slug.toLowerCase().trim();
+  return /^[a-z0-9][a-z0-9-]*$/.test(s) ? s.slice(0, 200) : slugify(s).slice(0, 200);
+}
+
+export function collectionFor(item: Pick<ImportItem, 'collection'>): string {
+  return CONTENT.collections[item.collection] ? item.collection : 'posts';
+}
+
+export async function loadState(repo: ContentRepository, items: Pick<ImportItem, 'sourceId' | 'type'>[]): Promise<ImportState> {
+  const [posts, pages, postRecs, pageRecs] = await Promise.all([
+    repo.listPosts(),
+    repo.listPages(),
+    repo.findImportRecords('post', items.filter((i) => i.type === 'post').map((i) => i.sourceId)),
+    repo.findImportRecords('page', items.filter((i) => i.type === 'page').map((i) => i.sourceId)),
+  ]);
+  const records = new Map<string, ImportRecord>();
+  for (const r of [...postRecs, ...pageRecs]) records.set(`${r.kind}:${r.sourceId}`, r);
+  return { posts, pages, records };
+}
+
+// Decide every item against the current site. `claimed` tracks slugs taken
+// earlier in the same bundle so two items can't land on one slug.
+export function decideItems(items: Pick<ImportItem, 'sourceId' | 'type' | 'title' | 'slug' | 'collection'>[], state: ImportState, conflict: ImportOptions['conflict'], runId = ''): ItemDecision[] {
+  const claimed = new Set<string>();
+  const key = (type: string, collection: string, slug: string) => (type === 'page' ? `page:${slug}` : `post:${collection}:${slug}`);
+  for (const p of state.posts) claimed.add(key('post', p.collection, p.slug));
+  for (const p of state.pages) claimed.add(key('page', '', p.slug));
+  const out: ItemDecision[] = [];
+  for (const item of items) {
+    const collection = item.type === 'post' ? collectionFor(item) : '';
+    let slug = cleanSlug(item.slug);
+    const base = { sourceId: item.sourceId, type: item.type, title: item.title };
+    const rec = state.records.get(`${item.type}:${item.sourceId}`);
+    const recTarget = rec && (item.type === 'post' ? state.posts.find((p) => p.id === rec.acmsId) : state.pages.find((p) => p.id === rec.acmsId));
+    if (recTarget) {
+      // imported before: this run already wrote it (resume), or an earlier
+      // run did — refresh it only when the user asked for updates
+      if (rec!.runId === runId) out.push({ ...base, slug: recTarget.slug, action: 'skip', reason: 'done', targetId: recTarget.id });
+      else if (conflict === 'update') out.push({ ...base, slug: recTarget.slug, action: 'update', reason: 'imported', targetId: recTarget.id });
+      else out.push({ ...base, slug: recTarget.slug, action: 'skip', reason: 'imported', targetId: recTarget.id });
+      continue;
+    }
+    if (claimed.has(key(item.type, collection, slug))) {
+      const existing = item.type === 'post'
+        ? state.posts.find((p) => p.collection === collection && p.slug === slug)
+        : state.pages.find((p) => p.slug === slug);
+      if (conflict === 'update' && existing) {
+        out.push({ ...base, slug, action: 'update', reason: 'exists', targetId: existing.id });
+        continue;
+      }
+      if (conflict !== 'copy') {
+        out.push({ ...base, slug, action: 'skip', reason: 'exists', targetId: existing?.id ?? '' });
+        continue;
+      }
+      let n = 2;
+      while (claimed.has(key(item.type, collection, `${slug}-${n}`))) n++;
+      slug = `${slug}-${n}`;
+    }
+    claimed.add(key(item.type, collection, slug));
+    out.push({ ...base, slug, action: 'create', reason: '', targetId: '' });
+  }
+  return out;
+}
+
+// ---- plan ----
+
+export interface AuthorPlan { sourceId: string; name: string; email: string; choice: string; match: string }
+
+export function defaultAuthorChoice(author: ImportAuthor, users: User[], previous?: string): string {
+  if (previous && users.some((u) => u.id === previous)) return previous;
+  const byEmail = author.email && users.find((u) => u.email.toLowerCase() === author.email.toLowerCase());
+  if (byEmail) return byEmail.id;
+  return author.inactive ? 'skip' : 'create';
+}
+
+export async function planImport(repo: ContentRepository, bundle: ImportBundle, options: ImportOptions) {
+  const [state, users, userRecs] = await Promise.all([
+    loadState(repo, bundle.items),
+    repo.listUsers(),
+    repo.findImportRecords('user', bundle.authors.map((a) => a.sourceId)),
+  ]);
+  const decisions = decideItems(bundle.items, state, options.conflict);
+  const prev = new Map(userRecs.map((r) => [r.sourceId, r.acmsId]));
+  const authors: AuthorPlan[] = bundle.authors.map((a) => {
+    const match = defaultAuthorChoice(a, users, prev.get(a.sourceId));
+    return { sourceId: a.sourceId, name: a.name, email: a.email, choice: options.authors[a.sourceId] ?? match, match: match === 'create' || match === 'skip' ? '' : match };
+  });
+  // bylines only matter for authors that wrote something in this bundle
+  const writing = new Set(bundle.items.flatMap((i) => i.authors));
+  const count = (type: 'post' | 'page', action: ItemAction) => decisions.filter((d) => d.type === type && d.action === action).length;
+  return {
+    decisions,
+    authors: authors.filter((a) => writing.has(a.sourceId)),
+    users: users.map((u) => ({ id: u.id, name: u.name, email: u.email })),
+    counts: {
+      posts: { create: count('post', 'create'), update: count('post', 'update'), skip: count('post', 'skip') },
+      pages: { create: count('page', 'create'), update: count('page', 'update'), skip: count('page', 'skip') },
+      tags: bundle.tags.length,
+      assets: bundle.assets.filter((a) => a.kind !== 'media').length + bundle.media.length,
+      // only URLs that actually change need a redirect (Ghost pages keep theirs)
+      redirects: options.redirects ? bundle.items.filter((item, i) => {
+        const d = decisions[i];
+        if (!item.legacyPath || d.action === 'skip') return false;
+        const to = item.type === 'post' ? collectionUrl(collectionFor(item), d.slug) : `/${d.slug}`;
+        return normalizeRedirectPath(item.legacyPath) !== normalizeRedirectPath(to);
+      }).length + bundle.redirects.length : 0,
+    },
+  };
+}
+
+// ---- start: run, authors, tags ----
+
+export const StartInput = z.object({
+  source: z.string().min(1).max(100),
+  label: z.string().max(300).default(''),
+  authors: z.array(ImportAuthor).max(2000).default([]),
+  tags: z.array(ImportTag).max(10_000).default([]),
+  // media rows re-hosted from this source before the run started (asset url → media id)
+  media: z.array(z.object({ sourceId: z.string().min(1).max(2000), id: z.string().min(1).max(100) })).max(50_000).default([]),
+  options: ImportOptions,
+});
+
+export async function startImport(repo: ContentRepository, input: z.infer<typeof StartInput>) {
+  // callers send only authors with bylines (Ghost exports list every staff
+  // account, including ones that never wrote anything)
+  const runId = crypto.randomUUID();
+  await repo.createImportRun({ id: runId, source: input.source, label: input.label });
+  const records: ImportRecord[] = [];
+  const record = (kind: ImportRecord['kind'], sourceId: string, acmsId: string, stamp = 0) =>
+    records.push({ runId, kind, sourceId, acmsId, action: 'created', stamp });
+
+  for (const m of input.media) record('media', m.sourceId, m.id);
+
+  // authors: reuse earlier imports and email matches, create the rest
+  let users = await repo.listUsers();
+  const prev = new Map((await repo.findImportRecords('user', input.authors.map((a) => a.sourceId))).map((r) => [r.sourceId, r.acmsId]));
+  const authorIds: Record<string, string | null> = {};
+  const merged: [string, string][] = [];
+  for (const a of input.authors) {
+    const choice = input.options.authors[a.sourceId] ?? defaultAuthorChoice(a, users, prev.get(a.sourceId));
+    if (choice === 'skip') { authorIds[a.sourceId] = null; continue; }
+    if (choice.startsWith('as:')) { merged.push([a.sourceId, choice.slice(3)]); continue; }
+    if (choice !== 'create') { authorIds[a.sourceId] = users.some((u) => u.id === choice) ? choice : null; continue; }
+    const email = (a.email || `${cleanSlug(a.slug || a.name)}@users.invalid`).toLowerCase();
+    const existing = users.find((u) => u.email.toLowerCase() === email);
+    if (existing) { authorIds[a.sourceId] = existing.id; continue; }
+    // imported authors get bylines, not logins: no password until an owner
+    // sets one from Users
+    const user = await repo.createUser({ name: a.name, email, role: 'editor', passHash: '' });
+    await repo.updateUser(user.id, {
+      bio: a.bio,
+      avatar: a.avatar.startsWith(ASSET_SCHEME) ? '' : a.avatar,
+      slug: a.slug ? cleanSlug(a.slug) : '',
+    });
+    users = [...users, user];
+    authorIds[a.sourceId] = user.id;
+    record('user', a.sourceId, user.id);
+  }
+  // merges resolve once their target exists (one level; chains end at null)
+  for (const [from, to] of merged) authorIds[from] = authorIds[to] ?? null;
+
+  // tags: register the source's descriptions/slugs where the name is new
+  const tags = await repo.listTags();
+  for (const t of input.tags) {
+    const slug = cleanSlug(t.slug || t.name);
+    if (tags.some((x) => x.slug === slug || x.name.toLowerCase() === t.name.toLowerCase())) continue;
+    const tag = await repo.createTag({ name: t.name, slug, description: t.description });
+    tags.push(tag);
+    record('tag', t.name, tag.id);
+  }
+
+  if (records.length) await repo.addImportRecords(records);
+  return { runId, authorIds };
+}
+
+// ---- items ----
+
+export const ItemsInput = z.object({
+  runId: z.string().uuid(),
+  items: z.array(ImportItem).min(1).max(50),
+  authorIds: z.record(z.string().nullable()).default({}),
+  options: ImportOptions,
+});
+
+export async function importItems(repo: ContentRepository, input: z.infer<typeof ItemsInput>) {
+  const run = await repo.getImportRun(input.runId);
+  if (!run || run.status !== 'running') throw new Error('This import run has finished or was undone. Start the import again.');
+  const users = new Set((await repo.listUsers()).map((u) => u.id));
+  const state = await loadState(repo, input.items);
+  const decisions = decideItems(input.items, state, input.options.conflict, input.runId);
+  const posts: Post[] = [], pages: Page[] = [];
+  const records: ImportRecord[] = [];
+  const results: { sourceId: string; action: ItemAction; reason: ItemDecision['reason']; id: string; type: 'post' | 'page' }[] = [];
+
+  input.items.forEach((item, i) => {
+    const d = decisions[i];
+    if (d.action === 'skip') { results.push({ sourceId: item.sourceId, action: 'skip', reason: d.reason, id: d.targetId, type: item.type }); return; }
+    const id = d.action === 'update' ? d.targetId : crypto.randomUUID();
+    const html = item.html.includes(ASSET_SCHEME) ? item.html.replace(/acms-asset:[a-z0-9-]+/g, '') : item.html;
+    // new items keep the source's timestamps; refreshed ones are "now". The
+    // stamp is what undo compares against to spot later edits.
+    const stamp = d.action === 'create' ? item.updatedAt : Date.now();
+    if (item.type === 'post') {
+      const existing = state.posts.find((p) => p.id === id);
+      const authorIds = [...new Set(item.authors.map((a) => input.authorIds[a]).filter((a): a is string => !!a && users.has(a)))];
+      posts.push(Post.parse({
+        id, collection: collectionFor(item), slug: d.slug, title: item.title,
+        body: '', bodyJson: '', bodyHtml: html, excerpt: item.excerpt, tags: [...new Set(item.tags)],
+        cover: stripPlaceholder(item.cover), coverAlt: item.coverAlt, seoTitle: item.seoTitle, seoDesc: item.seoDesc,
+        status: item.status, featured: item.featured, authorId: authorIds[0] ?? null, authorIds, template: item.template,
+        draft: null, publishedAt: item.status === 'draft' ? item.publishedAt : item.publishedAt ?? item.createdAt,
+        scheduledAt: item.status === 'scheduled' ? item.scheduledAt : null,
+        createdAt: existing?.createdAt ?? item.createdAt, updatedAt: stamp,
+      }));
+    } else {
+      const existing = state.pages.find((p) => p.id === id);
+      pages.push(Page.parse({
+        id, slug: d.slug, title: item.title, status: item.status === 'scheduled' ? 'draft' : item.status,
+        isHome: existing?.isHome ?? false, locale: existing?.locale ?? item.locale, blocks: [], bodyJson: '', bodyHtml: html,
+        seoTitle: item.seoTitle, seoDesc: item.seoDesc || item.excerpt, template: item.template, draft: null,
+        createdAt: existing?.createdAt ?? item.createdAt, updatedAt: stamp,
+      }));
+    }
+    records.push({ runId: input.runId, kind: item.type, sourceId: item.sourceId, acmsId: id, action: d.action === 'update' ? 'updated' : 'created', stamp });
+    results.push({ sourceId: item.sourceId, action: d.action, reason: d.reason, id, type: item.type });
+  });
+
+  if (posts.length || pages.length) {
+    await repo.writeImported({ posts, pages });
+    await repo.ensureTags([...new Set(posts.flatMap((p) => p.tags))]);
+    await repo.addImportRecords(records);
+  }
+  return { results };
+}
+
+function stripPlaceholder(v: string): string {
+  return v.startsWith(ASSET_SCHEME) ? '' : v;
+}
+
+// ---- finish ----
+
+export const FinishInput = z.object({
+  runId: z.string().uuid(),
+  identity: ImportIdentity.default({}),
+  nav: z.array(ImportNav).max(500).default([]),
+  // sourceId → old path, for the items in this bundle
+  legacy: z.array(z.object({ sourceId: z.string().max(200), type: z.enum(['post', 'page']), path: z.string().max(1000) })).max(50_000).default([]),
+  redirects: z.array(ImportRedirect).max(10_000).default([]),
+  warnings: z.array(ImportWarning).max(10_000).default([]),
+  failedAssets: z.array(z.object({ url: z.string().max(2000), error: z.string().max(500) })).max(50_000).default([]),
+  options: ImportOptions,
+});
+
+export async function finishImport(repo: ContentRepository, input: z.infer<typeof FinishInput>) {
+  const run = await repo.getImportRun(input.runId);
+  if (!run || run.status !== 'running') throw new Error('This import run has already finished.');
+  const records: ImportRecord[] = [];
+  const all = await repo.listImportRecords(input.runId);
+  const created = { redirects: 0, nav: 0 };
+
+  if (input.options.redirects && input.legacy.length) {
+    const byItem = new Map(all.filter((r) => r.kind === 'post' || r.kind === 'page').map((r) => [`${r.kind}:${r.sourceId}`, r.acmsId]));
+    const [posts, pages] = await Promise.all([repo.listPosts(), repo.listPages()]);
+    for (const l of input.legacy) {
+      const id = byItem.get(`${l.type}:${l.sourceId}`);
+      const target = l.type === 'post' ? posts.find((p) => p.id === id) : pages.find((p) => p.id === id);
+      if (!target) continue;
+      const to = l.type === 'post' ? collectionUrl((target as Post).collection, target.slug) : `/${target.slug}`;
+      const from = normalizeRedirectPath(l.path);
+      if (!from || from === '/' || from === normalizeRedirectPath(to)) continue;
+      const r = await repo.createRedirect({ fromPath: from, toPath: to, code: 301 });
+      records.push({ runId: input.runId, kind: 'redirect', sourceId: from, acmsId: r.id, action: 'created', stamp: 0 });
+      created.redirects++;
+    }
+  }
+
+  if (input.options.redirects) {
+    for (const r of input.redirects) {
+      const from = normalizeRedirectPath(r.from), to = normalizeRedirectPath(r.to);
+      if (!from || !to || from === to || from === '/') continue;
+      const rule = await repo.createRedirect({ fromPath: from, toPath: to, code: 301 });
+      records.push({ runId: input.runId, kind: 'redirect', sourceId: from, acmsId: rule.id, action: 'created', stamp: 0 });
+      created.redirects++;
+    }
+  }
+
+  if (input.options.nav && input.nav.length) {
+    const existing = await repo.listNavItems();
+    const seen = new Set(existing.map((n) => `${n.area}:${n.url.replace(/\/+$/, '') || '/'}`));
+    for (const n of input.nav) {
+      const k = `${n.area}:${n.url.replace(/\/+$/, '') || '/'}`;
+      if (seen.has(k) || n.url.includes(ASSET_SCHEME)) continue;
+      seen.add(k);
+      const item = await repo.createNavItem({ label: n.label, url: n.url, area: n.area });
+      records.push({ runId: input.runId, kind: 'nav', sourceId: k, acmsId: item.id, action: 'created', stamp: 0 });
+      created.nav++;
+    }
+  }
+
+  const settings: Record<string, string> = {};
+  if (input.options.identity) {
+    for (const [k, v] of Object.entries(input.identity)) {
+      if (k === 'headCode' || typeof v !== 'string' || !v.trim() || v.includes(ASSET_SCHEME)) continue;
+      settings[k] = v;
+    }
+  }
+  if (input.options.headCode && input.identity.headCode?.trim()) {
+    const current = (await repo.getSettings()).headCode;
+    if (!current.includes(input.identity.headCode.trim())) settings.headCode = [current.trim(), input.identity.headCode.trim()].filter(Boolean).join('\n');
+  }
+  if (Object.keys(settings).length) await repo.updateSettings(settings);
+  if (records.length) await repo.addImportRecords(records);
+
+  const final = [...all, ...records];
+  const count = (kind: ImportRecord['kind'], action?: ImportRecord['action']) => final.filter((r) => r.kind === kind && (!action || r.action === action)).length;
+  const report = {
+    counts: {
+      posts: { created: count('post', 'created'), updated: count('post', 'updated') },
+      pages: { created: count('page', 'created'), updated: count('page', 'updated') },
+      users: count('user'), tags: count('tag'), media: count('media'), redirects: created.redirects, nav: created.nav,
+    },
+    settings: Object.keys(settings),
+    warnings: input.warnings,
+    failedAssets: input.failedAssets,
+  };
+  await repo.updateImportRun(input.runId, { status: 'done', report });
+  return { report };
+}
+
+// ---- undo ----
+
+export async function undoImport(
+  repo: ContentRepository,
+  runId: string,
+  opts: { removeMedia: boolean; deleteMediaObject?: (key: string) => Promise<void> },
+) {
+  const run = await repo.getImportRun(runId);
+  if (!run) throw new Error('Import not found.');
+  if (run.status === 'undone') throw new Error('This import was already undone.');
+  const records = await repo.listImportRecords(runId);
+  const created = (kind: ImportRecord['kind']) => records.filter((r) => r.kind === kind && r.action === 'created');
+  const kept: string[] = [];
+
+  const [posts, pages] = await Promise.all([repo.listPosts(), repo.listPages()]);
+  // anything edited after the import (updated_at moved past the stamp) stays
+  const deletePosts = created('post').filter((r) => {
+    const p = posts.find((x) => x.id === r.acmsId);
+    if (p && p.updatedAt !== r.stamp) kept.push(p.title);
+    return p && p.updatedAt === r.stamp;
+  }).map((r) => r.acmsId);
+  const deletePages = created('page').filter((r) => {
+    const p = pages.find((x) => x.id === r.acmsId);
+    if (p && p.updatedAt !== r.stamp) kept.push(p.title);
+    return p && p.updatedAt === r.stamp;
+  }).map((r) => r.acmsId);
+  if (deletePosts.length || deletePages.length) await repo.writeImported({ deletePosts, deletePages });
+
+  const remaining = posts.filter((p) => !deletePosts.includes(p.id));
+  for (const r of created('redirect')) await repo.deleteRedirect(r.acmsId);
+  for (const r of created('nav')) await repo.deleteNavItem(r.acmsId);
+  for (const r of created('tag')) {
+    const tag = (await repo.listTags()).find((t) => t.id === r.acmsId);
+    if (tag && !remaining.some((p) => p.tags.includes(tag.name))) await repo.deleteTag(tag.id);
+  }
+  for (const r of created('user')) {
+    if (!remaining.some((p) => p.authorIds.includes(r.acmsId))) await repo.deleteUser(r.acmsId);
+  }
+  let mediaRemoved = 0;
+  if (opts.removeMedia) {
+    for (const r of created('media')) {
+      const m = await repo.getMedia(r.acmsId);
+      if (!m) continue;
+      await repo.deleteMedia(m.id);
+      for (const key of [m.key, ...m.variants.map((v) => v.key)]) await opts.deleteMediaObject?.(key).catch(() => {});
+      mediaRemoved++;
+    }
+  }
+  await repo.updateImportRun(runId, { status: 'undone', report: { ...run.report, undo: { removed: deletePosts.length + deletePages.length, kept, mediaRemoved } } });
+  return { removed: deletePosts.length + deletePages.length, kept, mediaRemoved };
+}

package/src/lib/import/bundle.ts

@@ -0,0 +1,167 @@
+import { z } from 'zod';
+import { Media } from '../schema';
+
+// The Import Bundle is the one shape every importer produces (Ghost,
+// WordPress, Markdown…) and the only shape the import API accepts. Serialized
+// with its media it is also acms's own portable export (`acms-export`), so
+// acms → acms moves use the same path as migrations from other CMSes.
+//
+// Bodies are editor-compatible HTML (the `.pc-*` card markup the editor's
+// parseHTML rules load), exactly like the drafts and agent APIs: bodyJson is
+// left empty and fills in on the first editor save.
+//
+// Files that still live on the old site are listed in `assets` and referenced
+// from any string field as `acms-asset:<ref>`. The browser re-hosts each one
+// (resize + variants for images) and swaps the placeholders for /media URLs
+// before items reach the server. acms exports instead carry their media rows
+// verbatim (`media`), with binaries under media/<key> in the ZIP, so keys and
+// every URL in the content stay valid.
+
+export const BUNDLE_FORMAT = 'acms-export';
+export const BUNDLE_VERSION = 1;
+export const ASSET_SCHEME = 'acms-asset:';
+
+export const ImportSourceKind = z.enum(['acms', 'ghost', 'wordpress', 'markdown']);
+export type ImportSourceKind = z.infer<typeof ImportSourceKind>;
+
+const text = (max: number) => z.string().max(max).default('');
+
+export const ImportAsset = z.object({
+  ref: z.string().regex(/^[a-z0-9-]{1,40}$/),
+  // absolute URL on the old site, or a path inside an uploaded content ZIP
+  url: z.string().min(1).max(2000),
+  kind: z.enum(['image', 'file', 'media']),
+  filename: text(300),
+  alt: text(1000),
+});
+export type ImportAsset = z.infer<typeof ImportAsset>;
+
+export const ImportAuthor = z.object({
+  sourceId: z.string().min(1).max(200),
+  name: z.string().min(1).max(200),
+  slug: text(200),
+  email: text(320),
+  bio: text(5000),
+  avatar: text(2000),
+  // Ghost's locked/suspended users: the importer defaults them to "skip"
+  inactive: z.boolean().default(false),
+});
+export type ImportAuthor = z.infer<typeof ImportAuthor>;
+
+export const ImportTag = z.object({
+  name: z.string().min(1).max(200),
+  slug: z.string().min(1).max(200),
+  description: text(5000),
+});
+export type ImportTag = z.infer<typeof ImportTag>;
+
+export const ImportItem = z.object({
+  sourceId: z.string().min(1).max(200),
+  type: z.enum(['post', 'page']),
+  // acms({ content.collections }) key; unknown keys fall back to 'posts'
+  collection: z.string().max(100).default('posts'),
+  slug: z.string().min(1).max(300),
+  title: z.string().max(1000),
+  status: z.enum(['draft', 'published', 'scheduled']),
+  html: z.string().max(5_000_000).default(''),
+  excerpt: text(5000),
+  cover: text(2000),
+  coverAlt: text(1000),
+  seoTitle: text(1000),
+  seoDesc: text(5000),
+  featured: z.boolean().default(false),
+  template: text(100),
+  locale: text(35),
+  tags: z.array(z.string().max(200)).max(200).default([]),
+  // ImportAuthor.sourceId values, in byline order
+  authors: z.array(z.string().max(200)).max(50).default([]),
+  publishedAt: z.number().nullable().default(null),
+  scheduledAt: z.number().nullable().default(null),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+  // the item's path on the old site; the importer adds a 301 when it differs
+  legacyPath: text(1000),
+});
+export type ImportItem = z.infer<typeof ImportItem>;
+
+export const ImportNav = z.object({
+  label: z.string().min(1).max(200),
+  url: z.string().min(1).max(2000),
+  area: z.enum(['header', 'footer', 'social']),
+});
+export type ImportNav = z.infer<typeof ImportNav>;
+
+export const ImportRedirect = z.object({ from: z.string().min(1).max(1000), to: z.string().min(1).max(1000) });
+export type ImportRedirect = z.infer<typeof ImportRedirect>;
+
+// allow-listed site identity; nothing else from a source's settings is kept
+export const ImportIdentity = z.object({
+  siteTitle: z.string().max(200).optional(),
+  tagline: z.string().max(1000).optional(),
+  siteLogo: z.string().max(2000).optional(),
+  siteFavicon: z.string().max(2000).optional(),
+  siteCover: z.string().max(2000).optional(),
+  timezone: z.string().max(100).optional(),
+  locale: z.string().max(35).optional(),
+  headCode: z.string().max(100_000).optional(),
+});
+export type ImportIdentity = z.infer<typeof ImportIdentity>;
+
+export const ImportWarning = z.object({
+  item: z.string().max(200).default(''),
+  code: z.string().max(60),
+  message: z.string().max(2000),
+});
+export type ImportWarning = z.infer<typeof ImportWarning>;
+
+export const ImportBundle = z.object({
+  format: z.literal(BUNDLE_FORMAT),
+  version: z.literal(BUNDLE_VERSION),
+  source: z.object({
+    kind: ImportSourceKind,
+    version: text(50),
+    title: text(200),
+    siteUrl: text(2000),
+    exportedAt: text(40),
+  }),
+  identity: ImportIdentity.default({}),
+  authors: z.array(ImportAuthor).max(2000).default([]),
+  tags: z.array(ImportTag).max(10_000).default([]),
+  items: z.array(ImportItem).max(50_000).default([]),
+  assets: z.array(ImportAsset).max(50_000).default([]),
+  media: z.array(Media).max(50_000).default([]),
+  nav: z.array(ImportNav).max(500).default([]),
+  // the source site's own redirect rules (acms exports)
+  redirects: z.array(ImportRedirect).max(10_000).default([]),
+  warnings: z.array(ImportWarning).max(10_000).default([]),
+});
+export type ImportBundle = z.infer<typeof ImportBundle>;
+
+export const assetPlaceholder = (ref: string) => `${ASSET_SCHEME}${ref}`;
+
+// Swap every acms-asset:<ref> for its re-hosted URL. <img> tags built by the
+// importers carry only src/alt/width/height, so images that gained responsive
+// variants get srcset/sizes added here. Unresolved refs (a failed download)
+// fall back to the original URL, which is reported separately.
+export interface ResolvedAsset { url: string; srcset?: string; sizes?: string }
+const PLACEHOLDER_RE = /acms-asset:([a-z0-9-]{1,40})/g;
+export function resolveAssets(value: string, resolved: Map<string, ResolvedAsset>, fallback: Map<string, string>): string {
+  if (!value.includes(ASSET_SCHEME)) return value;
+  const withSrcset = value.replace(/<img\b([^>]*?)\ssrc="acms-asset:([a-z0-9-]{1,40})"([^>]*)>/g, (tag, before: string, ref: string, after: string) => {
+    const r = resolved.get(ref);
+    if (!r?.srcset || /\ssrcset=/.test(tag)) return tag;
+    return `<img${before} src="acms-asset:${ref}" srcset="${escapeAttr(r.srcset)}" sizes="${escapeAttr(r.sizes ?? '')}"${after}>`;
+  });
+  return withSrcset.replace(PLACEHOLDER_RE, (m, ref: string) => resolved.get(ref)?.url ?? fallback.get(ref) ?? m);
+}
+
+export function assetRefsIn(value: string): string[] {
+  return [...value.matchAll(PLACEHOLDER_RE)].map((m) => m[1]);
+}
+
+export function escapeHtml(s: string): string {
+  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+export function escapeAttr(s: string): string {
+  return escapeHtml(s).replace(/"/g, '&quot;');
+}

package/src/lib/import/export.ts

@@ -0,0 +1,54 @@
+import type { ContentRepository } from '../repo/types';
+import { blocksToHtml } from '../blocksToHtml';
+import { collectionUrl } from '../content';
+import { BUNDLE_FORMAT, BUNDLE_VERSION, type ImportBundle } from './bundle';
+
+// acms's own portable export: the site's content as an Import Bundle, so
+// importing it elsewhere (another acms site, or this one after a reset) runs
+// the same merge pipeline as a Ghost import. Unlike a backup it carries no
+// bookings, credentials, API keys or settings beyond public site identity,
+// and media keeps its storage keys so every /media URL stays valid.
+export async function exportBundle(repo: ContentRepository, now = Date.now()): Promise<ImportBundle> {
+  const [settings, posts, pages, tags, users, nav, media, redirects] = await Promise.all([
+    repo.getSettings(), repo.listPosts(), repo.listPages(), repo.listTags(), repo.listUsers(),
+    repo.listNavItems(), repo.listMedia(), repo.listRedirects(),
+  ]);
+  const authorIds = new Set(posts.flatMap((p) => p.authorIds));
+  return {
+    format: BUNDLE_FORMAT,
+    version: BUNDLE_VERSION,
+    source: { kind: 'acms', version: '', title: settings.siteTitle, siteUrl: settings.siteUrl, exportedAt: new Date(now).toISOString() },
+    identity: {
+      siteTitle: settings.siteTitle, tagline: settings.tagline, siteLogo: settings.siteLogo, siteFavicon: settings.siteFavicon,
+      siteCover: settings.siteCover, timezone: settings.timezone, locale: settings.locale, headCode: settings.headCode,
+    },
+    // only people with bylines travel; staff accounts stay on this site
+    authors: users.filter((u) => authorIds.has(u.id)).map((u) => ({
+      sourceId: u.id, name: u.name, slug: u.slug, email: u.email, bio: u.bio, avatar: u.avatar, inactive: false,
+    })),
+    tags: tags.map((t) => ({ name: t.name, slug: t.slug, description: t.description })),
+    items: [
+      ...posts.map((p) => ({
+        sourceId: p.id, type: 'post' as const, collection: p.collection, slug: p.slug, title: p.title,
+        status: p.status === 'archived' ? 'draft' as const : p.status,
+        html: p.bodyHtml, excerpt: p.excerpt, cover: p.cover, coverAlt: p.coverAlt, seoTitle: p.seoTitle, seoDesc: p.seoDesc,
+        featured: p.featured, template: p.template, locale: '', tags: p.tags, authors: p.authorIds,
+        publishedAt: p.publishedAt, scheduledAt: p.scheduledAt, createdAt: p.createdAt, updatedAt: p.updatedAt,
+        legacyPath: collectionUrl(p.collection, p.slug),
+      })),
+      ...pages.map((p) => ({
+        sourceId: p.id, type: 'page' as const, collection: 'posts', slug: p.slug, title: p.title,
+        status: p.status === 'archived' || p.status === 'scheduled' ? 'draft' as const : p.status,
+        html: p.bodyHtml || blocksToHtml(p.blocks), excerpt: '', cover: '', coverAlt: '', seoTitle: p.seoTitle, seoDesc: p.seoDesc,
+        featured: false, template: p.template, locale: p.locale, tags: [], authors: [],
+        publishedAt: null, scheduledAt: null, createdAt: p.createdAt, updatedAt: p.updatedAt,
+        legacyPath: `/${p.slug}`,
+      })),
+    ],
+    assets: [],
+    media,
+    nav: nav.map((n) => ({ label: n.label, url: n.url, area: n.area })),
+    redirects: redirects.map((r) => ({ from: r.fromPath, to: r.toPath })),
+    warnings: [],
+  };
+}