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

package/src/lib/repo/index.ts

@@ -1,23 +1,27 @@
 import type { ContentRepository } from './types';
 
-let repo: ContentRepository | null = null;
+// The promise (not the instance) is cached: concurrent first requests would
+// otherwise each create a repository and race to run pending migrations.
+let repo: Promise<ContentRepository> | null = null;
 
 // Adapter priority: Cloudflare D1 (when the Worker binding exists —
 // production on Workers and local wrangler/astro dev via platformProxy)
 // → libSQL file (plain Node self-hosting).
 // Pass Astro.locals (or the endpoint's `locals`) so the D1 binding is
 // reachable; the chosen adapter is cached for the isolate's lifetime.
-export async function getRepo(locals?: unknown): Promise<ContentRepository> {
-  if (repo) return repo;
+export function getRepo(locals?: unknown): Promise<ContentRepository> {
+  repo ??= create(locals).catch((e) => { repo = null; throw e; });
+  return repo;
+}
+
+async function create(locals?: unknown): Promise<ContentRepository> {
   const d1 = (locals as { runtime?: { env?: { DB?: unknown } } } | undefined)?.runtime?.env?.DB;
   if (d1) {
     const { D1Repository } = await import('./d1');
-    repo = new D1Repository(d1 as import('./d1').D1Database);
-  } else {
-    const { SqliteRepository } = await import('./sqlite');
-    repo = new SqliteRepository();
+    return new D1Repository(d1 as import('./d1').D1Database);
   }
-  return repo;
+  const { SqliteRepository } = await import('./sqlite');
+  return new SqliteRepository();
 }
 
 export type { ContentRepository };

package/src/lib/repo/migrations.ts

@@ -1,4 +1,5 @@
 import { LIVE_MIGRATION } from '../live/migration';
+import { IMPORT_MIGRATION } from '../import/migration';
 import { EMAIL_MIGRATION } from '../email/migration';
 import { WEBHOOK_MIGRATION } from '../webhook-sql';
 // Versioned schema migrations shared by the two SQLite-dialect adapters
@@ -499,6 +500,7 @@ export const MIGRATIONS: Migration[] = [
   ] },
   WEBHOOK_MIGRATION,
   LIVE_MIGRATION,
+  IMPORT_MIGRATION,
 ];
 
 export const LATEST_VERSION = MIGRATIONS[MIGRATIONS.length - 1].version;

package/src/lib/repo/sql.ts

@@ -2,7 +2,7 @@ import { LiveStore } from '../live/store';
 import { LiveConfig } from '../live/types';
 import { ApiError } from '../api';
 import { EmailStore, bookingJobs } from '../email/store';
-import type { ContentRepository, DesignVersion, EventUpdate, SearchResults, Stats } from './types';
+import type { ContentRepository, DesignVersion, EventUpdate, ImportRecord, ImportRecordKind, ImportRun, SearchResults, Stats } from './types';
 import { Page, Post, Link, Media, NavItem, Redirect, Settings, Snippet, Tag, User, Calendar, CalEvent, ApiKey, Webhook, WebhookDelivery, Resource, BookingLink, Booking, isInternalTag, normalizeRedirectPath, publicTags, slugify, type WidgetInstance } from '../schema';
 import { designSnapshot, draftNavItems, pickDesignDraft, pickEventDraft, pickPageDraft, pickPostDraft } from '../drafts';
 import { eventInstants, eventTimeZone, normalizeEventTimes } from '../calendar/events';
@@ -68,6 +68,20 @@ function rowToPost(r: Row, authorIds?: string[]): Post {
     createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
   });
 }
+function rowToImportRun(r: Row): ImportRun {
+  let report: Record<string, unknown> = {};
+  try { report = JSON.parse(String(r.report ?? '{}')); } catch { /* keep empty */ }
+  return {
+    id: String(r.id), source: String(r.source), label: String(r.label ?? ''), status: String(r.status) as ImportRun['status'],
+    report, createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
+  };
+}
+function rowToImportRecord(r: Row): ImportRecord {
+  return {
+    runId: String(r.run_id), kind: String(r.kind) as ImportRecordKind, sourceId: String(r.source_id), acmsId: String(r.acms_id),
+    action: String(r.action) as ImportRecord['action'], stamp: Number(r.stamp ?? 0),
+  };
+}
 function rowToSnippet(r: Row): Snippet {
   return Snippet.parse({
     id: r.id, name: r.name, contentJson: r.content_json ?? '[]', createdAt: Number(r.created_at),
@@ -1577,7 +1591,7 @@ export class SqlRepository implements ContentRepository {
       // Suppression and re-enabling share the restore transaction. A failed
       // restore cannot leave notifications disabled or emit phantom deletes.
       { sql: 'UPDATE webhook_control SET suppressed=1 WHERE id=1' },
-      ...['email_jobs', 'email_attempts', 'email_delivery_events', 'email_tokens', 'posts', 'pages', 'media', 'links', 'tags', 'nav_items', 'users', 'post_authors', 'redirects', 'calendars', 'events', 'resources', 'booking_links', 'bookings', 'mobile_booking_requests'].map((t) => ({
+      ...['email_jobs', 'email_attempts', 'email_delivery_events', 'email_tokens', 'posts', 'pages', 'media', 'links', 'tags', 'nav_items', 'users', 'post_authors', 'redirects', 'calendars', 'events', 'resources', 'booking_links', 'bookings', 'mobile_booking_requests', 'import_runs', 'import_records'].map((t) => ({
         sql: `DELETE FROM ${t}`,
       })),
       ...(content.calendars ?? []).map((c) => ({
@@ -1656,6 +1670,106 @@ export class SqlRepository implements ContentRepository {
     await this.reindexSearch();
   }
 
+  // ---- imports ----
+  async createImportRun({ id, source, label }: Pick<ImportRun, 'id' | 'source' | 'label'>) {
+    await this.ready;
+    const now = Date.now();
+    await this.driver.run('INSERT INTO import_runs (id, source, label, status, report, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)', [id, source, label, 'running', '{}', now, now]);
+  }
+  async updateImportRun(id: string, data: Partial<Pick<ImportRun, 'status' | 'report'>>) {
+    await this.ready;
+    const sets = ['updated_at = ?'];
+    const args: unknown[] = [Date.now()];
+    if (data.status !== undefined) { sets.push('status = ?'); args.push(data.status); }
+    if (data.report !== undefined) { sets.push('report = ?'); args.push(JSON.stringify(data.report)); }
+    await this.driver.run(`UPDATE import_runs SET ${sets.join(', ')} WHERE id = ?`, [...args, id]);
+  }
+  async listImportRuns() {
+    await this.ready;
+    return (await this.driver.all('SELECT * FROM import_runs ORDER BY created_at DESC')).map(rowToImportRun);
+  }
+  async getImportRun(id: string) {
+    await this.ready;
+    const r = await this.first('SELECT * FROM import_runs WHERE id = ?', [id]);
+    return r ? rowToImportRun(r) : null;
+  }
+  async addImportRecords(records: ImportRecord[]) {
+    await this.ready;
+    const now = Date.now();
+    await this.driver.batch(records.map((r) => ({
+      sql: 'INSERT INTO import_records (run_id, kind, source_id, acms_id, action, stamp, created_at) VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT(run_id, kind, source_id) DO UPDATE SET acms_id = excluded.acms_id, stamp = excluded.stamp',
+      args: [r.runId, r.kind, r.sourceId, r.acmsId, r.action, r.stamp, now],
+    })));
+  }
+  async listImportRecords(runId: string) {
+    await this.ready;
+    return (await this.driver.all('SELECT * FROM import_records WHERE run_id = ? ORDER BY created_at ASC', [runId])).map(rowToImportRecord);
+  }
+  async findImportRecords(kind: ImportRecordKind, sourceIds: string[]) {
+    await this.ready;
+    if (!sourceIds.length) return [];
+    const out: ImportRecord[] = [];
+    // chunked to stay under SQLite's bound-parameter limit
+    for (let i = 0; i < sourceIds.length; i += 200) {
+      const chunk = sourceIds.slice(i, i + 200);
+      const rows = await this.driver.all(
+        `SELECT r.* FROM import_records r JOIN import_runs u ON u.id = r.run_id
+         WHERE u.status != 'undone' AND r.kind = ? AND r.source_id IN (${chunk.map(() => '?').join(', ')})
+         ORDER BY r.created_at ASC`,
+        [kind, ...chunk]
+      );
+      out.push(...rows.map(rowToImportRecord));
+    }
+    // later runs win
+    return [...new Map(out.map((r) => [r.sourceId, r])).values()];
+  }
+  async writeImported(data: { posts?: Post[]; pages?: Page[]; deletePosts?: string[]; deletePages?: string[] }) {
+    await this.ready;
+    const posts = data.posts ?? [], pages = data.pages ?? [];
+    const stmts: SqlStatement[] = [{ sql: 'UPDATE webhook_control SET suppressed=1 WHERE id=1' }];
+    for (const p of posts) {
+      stmts.push({
+        sql: `INSERT INTO posts (id, collection, slug, title, body, body_json, body_html, excerpt, tags, cover, cover_alt, seo_title, seo_desc, status, featured, author_id, template, draft, published_at, scheduled_at, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT(id) DO UPDATE SET collection = excluded.collection, slug = excluded.slug, title = excluded.title, body = excluded.body,
+            body_json = excluded.body_json, body_html = excluded.body_html, excerpt = excluded.excerpt, tags = excluded.tags, cover = excluded.cover,
+            cover_alt = excluded.cover_alt, seo_title = excluded.seo_title, seo_desc = excluded.seo_desc, status = excluded.status,
+            featured = excluded.featured, author_id = excluded.author_id, template = excluded.template, draft = NULL,
+            published_at = excluded.published_at, scheduled_at = excluded.scheduled_at, updated_at = excluded.updated_at`,
+        args: [p.id, p.collection, p.slug, p.title, p.body, p.bodyJson, p.bodyHtml, p.excerpt, JSON.stringify(p.tags), p.cover, p.coverAlt, p.seoTitle, p.seoDesc, p.status, p.featured ? 1 : 0, p.authorIds[0] ?? null, p.template, null, p.publishedAt, p.scheduledAt, p.createdAt, p.updatedAt],
+      });
+      stmts.push({ sql: 'DELETE FROM post_authors WHERE post_id = ?', args: [p.id] });
+      p.authorIds.forEach((aid, i) => stmts.push({ sql: 'INSERT INTO post_authors (post_id, author_id, ord) VALUES (?, ?, ?)', args: [p.id, aid, i] }));
+    }
+    for (const p of pages) {
+      stmts.push({
+        sql: `INSERT INTO pages (id, slug, title, status, is_home, locale, blocks, body_json, body_html, seo_title, seo_desc, template, draft, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT(id) DO UPDATE SET slug = excluded.slug, title = excluded.title, status = excluded.status, locale = excluded.locale,
+            blocks = excluded.blocks, body_json = excluded.body_json, body_html = excluded.body_html, seo_title = excluded.seo_title,
+            seo_desc = excluded.seo_desc, template = excluded.template, draft = NULL, updated_at = excluded.updated_at`,
+        args: [p.id, p.slug, p.title, p.status, p.isHome ? 1 : 0, p.locale, JSON.stringify(p.blocks), p.bodyJson, p.bodyHtml, p.seoTitle, p.seoDesc, p.template, null, p.createdAt, p.updatedAt],
+      });
+    }
+    for (const id of data.deletePosts ?? []) {
+      stmts.push(
+        { sql: 'DELETE FROM posts WHERE id = ?', args: [id] },
+        { sql: 'DELETE FROM post_authors WHERE post_id = ?', args: [id] },
+        { sql: "DELETE FROM search_index WHERE kind = 'post' AND ref_id = ?", args: [id] },
+      );
+    }
+    for (const id of data.deletePages ?? []) {
+      stmts.push(
+        { sql: 'DELETE FROM pages WHERE id = ?', args: [id] },
+        { sql: "DELETE FROM search_index WHERE kind = 'page' AND ref_id = ?", args: [id] },
+      );
+    }
+    stmts.push({ sql: 'UPDATE webhook_control SET suppressed=0 WHERE id=1' });
+    await this.driver.batch(stmts);
+    for (const p of posts) await this.syncPostIndex(p.id);
+    for (const p of pages) await this.syncPageIndex(p.id);
+  }
+
   // ---- redirects ----
   async listRedirects() {
     await this.ready;

package/src/lib/repo/types.ts

@@ -1,6 +1,9 @@
 import type { LiveStore } from '../live/store';
 import type { BookingRequest } from '../backup/content';
 import type { EmailStore } from '../email/store';
+export interface ImportRun { id: string; source: string; label: string; status: 'running' | 'done' | 'undone'; report: Record<string, unknown>; createdAt: number; updatedAt: number }
+export type ImportRecordKind = 'post' | 'page' | 'user' | 'tag' | 'media' | 'redirect' | 'nav';
+export interface ImportRecord { runId: string; kind: ImportRecordKind; sourceId: string; acmsId: string; action: 'created' | 'updated'; stamp: number }
 export interface DesignVersion { id: string; createdAt: number; author: string; summary: string; snapshot: Record<string, unknown> }
 
 import type { Page, Post, Link, Media, NavItem, Redirect, Settings, Snippet, Tag, User, Role, WidgetInstance, Calendar, CalEvent, ApiKey, ApiScope, Webhook, WebhookDelivery, Resource, BookingLink, Booking, BookingStatus } from '../schema';
@@ -260,6 +263,20 @@ export interface ContentRepository {
     bookingRequests?: BookingRequest[];
   }): Promise<void>;
 
+  // imports (lib/import/apply.ts drives these). writeImported is the
+  // id-preserving bulk write for imported posts/pages: original timestamps
+  // are kept and publication webhooks stay silent (a migration of old posts
+  // is not news), in one transaction with the search index refreshed after.
+  createImportRun(run: Pick<ImportRun, 'id' | 'source' | 'label'>): Promise<void>;
+  updateImportRun(id: string, data: Partial<Pick<ImportRun, 'status' | 'report'>>): Promise<void>;
+  listImportRuns(): Promise<ImportRun[]>;
+  getImportRun(id: string): Promise<ImportRun | null>;
+  addImportRecords(records: ImportRecord[]): Promise<void>;
+  listImportRecords(runId: string): Promise<ImportRecord[]>;
+  // latest record per source id across runs that weren't undone
+  findImportRecords(kind: ImportRecordKind, sourceIds: string[]): Promise<ImportRecord[]>;
+  writeImported(data: { posts?: Post[]; pages?: Page[]; deletePosts?: string[]; deletePages?: string[] }): Promise<void>;
+
   // redirects — exact-path forwards, consulted when a request would 404.
   // createRedirect upserts on fromPath and prunes self/loop entries.
   listRedirects(): Promise<Redirect[]>;

package/src/pages/admin/import.astro

@@ -0,0 +1,16 @@
+---
+import Admin from '../../layouts/Admin.astro';
+import ImportExport from '../../components/import/ImportExport';
+import { getRepo } from '../../lib/repo';
+import { validateSession, OWNER_ENV, SESSION_COOKIE } from '../../lib/auth';
+
+// owner-only: an import can create accounts and change site settings
+const repo = await getRepo(Astro.locals);
+const sessionUserId = await validateSession(Astro.cookies.get(SESSION_COOKIE)?.value, Astro.locals);
+const sessionUser = sessionUserId && sessionUserId !== OWNER_ENV ? await repo.getUser(sessionUserId) : null;
+if (sessionUserId !== OWNER_ENV && sessionUser?.role !== 'owner') return Astro.redirect('/admin/settings');
+const tab = Astro.url.searchParams.get('tab');
+---
+<Admin title="Import & export" section="settings" wide>
+  <ImportExport client:load initialTab={tab === 'export' || tab === 'history' ? tab : 'import'} />
+</Admin>

package/src/pages/admin/settings.astro

@@ -229,6 +229,7 @@ const groups = [
     { id: 'code', label: 'Code injection', terms: 'code injection head footer scripts' },
   ] }] : []),
   { label: 'Advanced', items: [
+    ...(isOwner ? [{ id: 'import', label: 'Import & export', terms: 'import export ghost wordpress migrate migration move content' }] : []),
     { id: 'backup', label: 'Backup', terms: 'backup restore export zip' },
     { id: 'backend', label: 'Backend', terms: 'backend database d1 sqlite' },
   ] },
@@ -571,6 +572,16 @@ const groups = [
 
       <div class="set-group-title">Advanced</div>
 
+      {isOwner && (
+        <section class="scard" id="import">
+          <header class="scard-head">
+            <a class="scard-back" href="#" aria-label="All settings"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M15 6l-6 6 6 6" /></svg></a>
+            <div class="grow"><h2>Import &amp; export</h2><p>Import posts, pages, authors and images from Ghost or another acms site, or export this site's content. Imports merge with what's here and can be undone.</p></div>
+            <div class="scard-actions always"><a class="btn" href="/admin/import?tab=export">Export</a><a class="btn" href="/admin/import">Import</a></div>
+          </header>
+        </section>
+      )}
+
       <section class="scard" id="backup">
         <header class="scard-head">
           <a class="scard-back" href="#" aria-label="All settings"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M15 6l-6 6 6 6" /></svg></a>

package/src/pages/api/export.ts

@@ -0,0 +1,41 @@
+import type { APIRoute } from 'astro';
+import { getRepo } from '../../lib/repo';
+import { getMediaStore } from '../../lib/media/store';
+import { apiError, requireSession } from '../../lib/api';
+import { exportBundle } from '../../lib/import/export';
+import { zipStream, type ZipEntry } from '../../lib/backup/zip';
+
+// Portable content export (acms-export v1): bundle.json + media/<key>.
+// Import it into any acms site from Admin → Import & export; unlike a backup
+// it merges instead of replacing and carries no bookings or credentials.
+export const GET: APIRoute = async ({ request, cookies, locals }) => {
+  try {
+    const repo = await getRepo(locals);
+    await requireSession(request, cookies, repo, true);
+    const now = Date.now();
+    const bundle = await exportBundle(repo, now);
+    const store = getMediaStore(locals);
+    const missing: string[] = [];
+    async function* entries(): AsyncGenerator<ZipEntry> {
+      // media first so a truncated download fails loudly on bundle.json
+      for (const m of bundle.media) {
+        for (const key of [m.key, ...m.variants.map((v) => v.key)]) {
+          const obj = await store.get(key);
+          if (!obj) { missing.push(key); continue; }
+          yield { name: `media/${key}`, data: new Uint8Array(await new Response(obj.body).arrayBuffer()) };
+        }
+      }
+      const present = bundle.media.filter((m) => ![m.key, ...m.variants.map((v) => v.key)].some((k) => missing.includes(k)));
+      yield { name: 'bundle.json', data: new TextEncoder().encode(JSON.stringify({ ...bundle, media: present }, null, 1)) };
+    }
+    const stamp = new Date(now).toISOString().slice(0, 10);
+    return new Response(zipStream(entries(), now), {
+      headers: {
+        'Content-Type': 'application/zip',
+        'Cache-Control': 'no-store',
+        'X-Content-Type-Options': 'nosniff',
+        'Content-Disposition': `attachment; filename="acms-export-${stamp}.zip"`,
+      },
+    });
+  } catch (e) { return apiError(e); }
+};

package/src/pages/api/import/asset.ts

@@ -0,0 +1,32 @@
+import type { APIRoute } from 'astro';
+import { z } from 'zod';
+import { getRepo } from '../../../lib/repo';
+import { ApiError, apiError, readJson, readResponseBytes, requireSession } from '../../../lib/api';
+import { fetchPublicUrl } from '../../../lib/net';
+
+// Download one file from the site being imported. The old site won't send
+// CORS headers, so the browser can't fetch it directly; it asks here, then
+// resizes and uploads the bytes like any other media. Owner-only, public
+// hosts only (every redirect hop re-checked), capped, and never HTML — this
+// must not turn into a general-purpose proxy.
+const MAX_BYTES = 30 * 1024 * 1024;
+const Body = z.object({ url: z.string().url().max(2000) });
+
+export const POST: APIRoute = async ({ request, cookies, locals }) => {
+  try {
+    const repo = await getRepo(locals);
+    await requireSession(request, cookies, repo, true);
+    const { url } = Body.parse(await readJson(request, 10_000));
+    const got = await fetchPublicUrl(url, { accept: '*/*', userAgent: 'acms-importer/1.0', timeoutMs: 30_000 });
+    if (!got) throw new ApiError(502, 'The old site could not be reached for this file.');
+    const { res } = got;
+    if (!res.ok) throw new ApiError(502, `The old site answered ${res.status} for this file.`);
+    const type = (res.headers.get('content-type') ?? 'application/octet-stream').split(';')[0].trim().toLowerCase();
+    if (type === 'text/html' || type.startsWith('video/') || type.startsWith('audio/')) {
+      throw new ApiError(415, type === 'text/html' ? 'The old site returned a web page instead of the file.' : 'Video and audio files aren’t re-hosted yet.');
+    }
+    const data = await readResponseBytes(res, MAX_BYTES);
+    // readResponseBytes allocates a fresh, exactly-sized buffer
+    return new Response(data as Uint8Array<ArrayBuffer>, { headers: { 'Content-Type': type, 'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff' } });
+  } catch (e) { return apiError(e); }
+};

package/src/pages/api/import/index.ts

@@ -0,0 +1,47 @@
+import type { APIRoute } from 'astro';
+import { z } from 'zod';
+import { getRepo } from '../../../lib/repo';
+import { getMediaStore } from '../../../lib/media/store';
+import { ApiError, apiError, json, readJson, requireSession } from '../../../lib/api';
+import { ImportBundle } from '../../../lib/import/bundle';
+import { FinishInput, ImportOptions, ItemsInput, StartInput, finishImport, importItems, planImport, startImport, undoImport } from '../../../lib/import/apply';
+
+// Import pipeline steps (see lib/import/apply.ts). Owner-only: an import can
+// create accounts, rewrite navigation and change site settings.
+const Body = z.discriminatedUnion('op', [
+  z.object({ op: z.literal('plan'), bundle: ImportBundle, options: ImportOptions }),
+  z.object({ op: z.literal('start') }).merge(StartInput),
+  z.object({ op: z.literal('items') }).merge(ItemsInput),
+  z.object({ op: z.literal('finish') }).merge(FinishInput),
+  z.object({ op: z.literal('undo'), runId: z.string().uuid(), removeMedia: z.boolean().default(false) }),
+]);
+
+export const GET: APIRoute = async ({ request, cookies, locals }) => {
+  try {
+    const repo = await getRepo(locals);
+    await requireSession(request, cookies, repo, true);
+    return json({ runs: await repo.listImportRuns() });
+  } catch (e) { return apiError(e); }
+};
+
+export const POST: APIRoute = async ({ request, cookies, locals }) => {
+  try {
+    const repo = await getRepo(locals);
+    await requireSession(request, cookies, repo, true);
+    // item batches carry full post bodies
+    const body = Body.parse(await readJson(request, 12 * 1024 * 1024));
+    switch (body.op) {
+      case 'plan': return json(await planImport(repo, body.bundle, body.options));
+      case 'start': return json(await startImport(repo, body));
+      case 'items': return json(await importItems(repo, body));
+      case 'finish': return json(await finishImport(repo, body));
+      case 'undo': {
+        const store = getMediaStore(locals);
+        return json(await undoImport(repo, body.runId, { removeMedia: body.removeMedia, deleteMediaObject: (key) => store.delete(key) }));
+      }
+    }
+  } catch (e) {
+    if (e instanceof Error && !(e instanceof ApiError) && !(e instanceof z.ZodError)) return apiError(new ApiError(400, e.message));
+    return apiError(e);
+  }
+};

package/src/pages/api/import/media.ts

@@ -0,0 +1,31 @@
+import type { APIRoute } from 'astro';
+import { getRepo } from '../../../lib/repo';
+import { getMediaStore } from '../../../lib/media/store';
+import { ApiError, apiError, requireSession } from '../../../lib/api';
+import { Media } from '../../../lib/schema';
+
+// Verbatim media from an acms export: the row keeps its id and storage keys,
+// so every /media URL in the imported content resolves unchanged. Fields:
+// `media` (JSON row) plus one file part per key, named by that key.
+export const POST: APIRoute = async ({ request, cookies, locals }) => {
+  try {
+    const repo = await getRepo(locals);
+    await requireSession(request, cookies, repo, true);
+    const form = await request.formData();
+    const media = Media.parse(JSON.parse(String(form.get('media') ?? 'null')));
+    const keys = [media.key, ...media.variants.map((v) => v.key)];
+    for (const key of keys) {
+      if (!key.startsWith(`${media.id}/`) || key.includes('..') || key.includes('\\') || /[\x00-\x1f]/.test(key)) throw new ApiError(400, 'Unsafe media key.');
+    }
+    if (await repo.getMedia(media.id)) return Response.json({ media, existed: true });
+    const store = getMediaStore(locals);
+    for (const key of keys) {
+      const file = form.get(key);
+      if (!(file instanceof File) || !file.size) throw new ApiError(400, `Missing file for ${key}.`);
+      if (file.size > 30 * 1024 * 1024) throw new ApiError(413, 'File too large (max 30 MB).');
+      await store.put(key, await file.arrayBuffer(), key === media.key ? media.mime : 'image/webp');
+    }
+    const { createdAt: _createdAt, ...row } = media;
+    return Response.json({ media: await repo.createMedia(row), existed: false });
+  } catch (e) { return apiError(e); }
+};