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

package/src/lib/editor/token-route.ts

@@ -0,0 +1,74 @@
+import type { APIContext } from 'astro';
+import { getRepo } from '../repo';
+import { ApiError, readResponseBytes } from '../api';
+import { sha256Hex } from '../api-keys';
+import { OAuthError, revokeToken, tokenGrant, bearerToken } from './auth';
+import { requireEditorApps } from './config';
+
+// POST /api/v1/auth/token and /api/v1/auth/revoke. OAuth-shaped responses
+// (RFC 6749 §5): top-level fields, errors as { error, error_description },
+// so standard clients (expo-auth-session) work unchanged. Bodies only —
+// secrets are never accepted in the query string.
+
+const headers = {
+  'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Methods': 'POST, OPTIONS', 'Access-Control-Allow-Headers': 'Authorization, Content-Type',
+  'Cache-Control': 'no-store', Pragma: 'no-cache', 'X-Content-Type-Options': 'nosniff',
+};
+export const authPreflight = () => new Response(null, { status: 204, headers });
+const reply = (body: unknown, status = 200, extra: Record<string, string> = {}) => Response.json(body, { status, headers: { ...headers, ...extra } });
+
+async function readForm(request: Request): Promise<Record<string, string>> {
+  const type = request.headers.get('content-type')?.toLowerCase() ?? '';
+  const bytes = await readResponseBytes(request, 10_000);
+  const text = new TextDecoder().decode(bytes);
+  const out: Record<string, string> = {};
+  if (type.startsWith('application/x-www-form-urlencoded')) {
+    for (const [k, v] of new URLSearchParams(text)) {
+      if (k in out) throw new OAuthError(400, 'invalid_request', `Duplicate parameter: ${k}.`);
+      out[k] = v;
+    }
+  } else if (type.startsWith('application/json')) {
+    let json: unknown;
+    try { json = JSON.parse(text); } catch { throw new OAuthError(400, 'invalid_request', 'Body must be valid JSON.'); }
+    if (!json || typeof json !== 'object' || Array.isArray(json)) throw new OAuthError(400, 'invalid_request', 'Body must be an object.');
+    for (const [k, v] of Object.entries(json)) if (typeof v === 'string') out[k] = v;
+  } else throw new OAuthError(415, 'invalid_request', 'Use Content-Type: application/x-www-form-urlencoded (or application/json).');
+  return out;
+}
+const address = (context: APIContext) => { try { return context.clientAddress || 'unknown'; } catch { return 'unknown'; } };
+
+function oauthFailure(error: unknown) {
+  if (error instanceof OAuthError) return reply({ error: error.error, error_description: error.message }, error.status);
+  if (error instanceof ApiError) {
+    if (error.status === 429) return reply({ error: 'rate_limited', error_description: error.message }, 429, { 'Retry-After': '60' });
+    if (error.status === 404) return reply({ error: 'not_found', error_description: error.message }, 404);
+    return reply({ error: 'invalid_request', error_description: error.message }, error.status);
+  }
+  console.error('acms editor auth: token request failed');
+  return reply({ error: 'server_error', error_description: 'Request failed. Please try again.' }, 500);
+}
+
+export async function tokenRoute(context: APIContext) {
+  try {
+    requireEditorApps();
+    if (context.url.search) throw new OAuthError(400, 'invalid_request', 'Send parameters in the request body, not the URL.');
+    const repo = await getRepo(context.locals);
+    if (!await repo.email.rateLimit(`editor:token:${await sha256Hex(address(context))}`, 30, 60_000)) throw new ApiError(429, 'Too many requests. Try again in a minute.');
+    return reply(await tokenGrant(repo, await readForm(context.request)));
+  } catch (error) { return oauthFailure(error); }
+}
+
+export async function revokeRoute(context: APIContext) {
+  try {
+    requireEditorApps();
+    if (context.url.search) throw new OAuthError(400, 'invalid_request', 'Send parameters in the request body, not the URL.');
+    const repo = await getRepo(context.locals);
+    if (!await repo.email.rateLimit(`editor:revoke:${await sha256Hex(address(context))}`, 30, 60_000)) throw new ApiError(429, 'Too many requests. Try again in a minute.');
+    const form = context.request.headers.get('content-type') ? await readForm(context.request) : {};
+    const token = form.token || bearerToken(context.request);
+    if (!token) throw new OAuthError(400, 'invalid_request', 'Send the token to revoke.');
+    await revokeToken(repo, token);
+    // RFC 7009: unknown or already-revoked tokens also succeed
+    return reply({ revoked: true });
+  } catch (error) { return oauthFailure(error); }
+}

package/src/lib/editor/translations.ts

@@ -0,0 +1,163 @@
+import { z } from 'zod';
+import type { ContentRepository } from '../repo/types';
+import { DocTranslation, type DocTranslations } from '../schema';
+import { ApiError } from '../api';
+import { I18N } from '../i18n';
+import { isExtraLocale } from '../translations';
+import { translateUnits } from '../translate';
+import { textHash, translationUnits } from '../../theme-sdk/fields.mjs';
+import type { SaveHooks } from '../content-service';
+import type { EditorPrincipal } from './auth';
+import { checkRevision, loadDoc, mergedDoc, revisionOf, saveRaw, withDocLock, type DocKind } from './documents';
+import { findSection, stagedPages, stagedTheme, stageSection } from './sections';
+
+// Translations for editor apps, same rules as the web editors: a person
+// setting a text marks it reviewed; AI drafts are stored as "AI draft" for
+// review; "mark reviewed" confirms every translated unit against the current
+// main-language text. Documents save through the content service (live ones
+// stage), sections through the shared design rules (locks apply).
+
+type State = 'ai' | 'reviewed';
+type Meta = Record<string, { state: State; src: string }>;
+interface Unit { path: string; label: string; kind: 'text' | 'textarea' | 'richtext' | 'link' | 'select'; source: string; hash: string }
+export type TranslationStatus = 'missing' | 'ai' | 'reviewed' | 'outdated';
+
+const pathList = z.array(z.string().max(300)).max(500);
+export const SetDocInput = z.object({ revision: z.string().max(60), values: z.record(z.string().max(300), z.string().max(2_000_000)) }).strict();
+export const SetSectionInput = z.object({ revision: z.number().int().nonnegative(), values: z.record(z.string().max(300), z.string().max(60_000)) }).strict();
+export const ReviewDocInput = z.object({ revision: z.string().max(60), paths: pathList.optional() }).strict();
+export const ReviewSectionInput = z.object({ revision: z.number().int().nonnegative(), paths: pathList.optional() }).strict();
+export const AiDocInput = ReviewDocInput.extend({ includeReviewed: z.boolean().default(false) }).strict();
+export const AiSectionInput = ReviewSectionInput.extend({ includeReviewed: z.boolean().default(false) }).strict();
+
+export function requireLocale(locale: string) {
+  if (!isExtraLocale(locale)) throw new ApiError(404, I18N.enabled ? `“${locale}” isn’t one of this site’s extra languages.` : 'This site has one language.');
+}
+
+// ---- documents -------------------------------------------------------------
+
+const DOC_FIELDS: Record<DocKind, [string, string, Unit['kind']][]> = {
+  post: [['title', 'Title', 'text'], ['excerpt', 'Excerpt', 'textarea'], ['bodyHtml', 'Body', 'richtext'], ['seoTitle', 'Search title', 'text'], ['seoDesc', 'Search description', 'textarea']],
+  page: [['title', 'Title', 'text'], ['bodyHtml', 'Body', 'richtext'], ['seoTitle', 'Search title', 'text'], ['seoDesc', 'Search description', 'textarea']],
+  event: [['title', 'Title', 'text'], ['excerpt', 'Summary', 'textarea'], ['bodyHtml', 'Description', 'richtext'], ['seoTitle', 'Search title', 'text'], ['seoDesc', 'Search description', 'textarea'],
+    ['locationName', 'Place name', 'text'], ['ctaLabel', 'Button label', 'text']],
+};
+const emptyDocTr = () => DocTranslation.parse({});
+
+function docUnits(kind: DocKind, doc: Record<string, unknown>): Unit[] {
+  const main = (f: string) => f === 'locationName' ? String((doc.location as { name?: string } | undefined)?.name ?? '')
+    : f === 'ctaLabel' ? String((doc.cta as { label?: string } | undefined)?.label ?? '') : String(doc[f] ?? '');
+  return DOC_FIELDS[kind].map(([path, label, k]) => ({ path, label, kind: k, source: main(path), hash: textHash(main(path)) })).filter((u) => u.source.trim());
+}
+function status(u: Unit, value: string, meta: Meta): TranslationStatus {
+  if (!value.trim()) return 'missing';
+  const m = meta[u.path];
+  if (m && m.src !== u.hash) return 'outdated';
+  return m?.state === 'reviewed' ? 'reviewed' : 'ai';
+}
+function view(units: Unit[], values: Record<string, unknown>, meta: Meta) {
+  const list = units.map((u) => { const value = String(values[u.path] ?? ''); return { path: u.path, label: u.label, kind: u.kind, source: u.source, value, status: status(u, value, meta) }; });
+  const summary = { total: list.length, missing: 0, ai: 0, reviewed: 0, outdated: 0 };
+  for (const u of list) summary[u.status]++;
+  return { units: list, summary };
+}
+
+type Mode = { op: 'set'; values: Record<string, string> } | { op: 'review'; paths?: string[] } | { op: 'ai'; paths?: string[]; includeReviewed: boolean };
+/** apply one operation to a translation's values + review meta; returns how many units changed */
+async function applyMode(units: Unit[], values: Record<string, unknown>, meta: Meta, mode: Mode, locale: string, repo: ContentRepository, locals: unknown): Promise<number> {
+  const byPath = new Map(units.map((u) => [u.path, u]));
+  const pick = (paths?: string[]) => {
+    if (!paths) return units;
+    const unknown = paths.find((p) => !byPath.has(p));
+    if (unknown) throw new ApiError(400, `Nothing to translate at “${unknown}”.`);
+    return paths.map((p) => byPath.get(p)!);
+  };
+  if (mode.op === 'set') {
+    const entries = Object.entries(mode.values);
+    if (!entries.length) throw new ApiError(400, 'Send at least one value.');
+    for (const [path, value] of entries) {
+      const u = byPath.get(path);
+      if (!u) throw new ApiError(400, `Nothing to translate at “${path}”.`);
+      values[path] = value;
+      // a person wrote it: reviewed, against the current main-language text
+      if (value.trim()) meta[path] = { state: 'reviewed', src: u.hash }; else delete meta[path];
+    }
+    return entries.length;
+  }
+  if (mode.op === 'review') {
+    let n = 0;
+    for (const u of pick(mode.paths)) if (String(values[u.path] ?? '').trim()) { meta[u.path] = { state: 'reviewed', src: u.hash }; n++; }
+    return n;
+  }
+  const todo = pick(mode.paths).filter((u) => {
+    const st = status(u, String(values[u.path] ?? ''), meta);
+    return st === 'missing' || (st === 'outdated' && (mode.includeReviewed || meta[u.path]?.state !== 'reviewed')) || (mode.includeReviewed && (st === 'ai' || st === 'reviewed'));
+  });
+  if (!todo.length) return 0;
+  const { results } = await translateUnits((await repo.getSettings()).ai, { locale, units: todo.map((u) => ({ id: u.path, text: u.source, kind: u.kind, label: u.label.slice(0, 200) })) }, locals);
+  let n = 0;
+  for (const u of todo) if (results[u.path] !== undefined) { values[u.path] = results[u.path]; meta[u.path] = { state: 'ai', src: u.hash }; n++; }
+  return n;
+}
+
+export async function getDocTranslation(repo: ContentRepository, kind: DocKind, id: string, locale: string) {
+  requireLocale(locale);
+  const raw = await loadDoc(repo, kind, id);
+  const doc = mergedDoc(kind, raw) as unknown as Record<string, unknown> & { translations?: DocTranslations };
+  const tr = doc.translations?.[locale] ?? emptyDocTr();
+  return { locale, revision: revisionOf(raw), ...view(docUnits(kind, doc), tr as unknown as Record<string, unknown>, tr.meta as Meta) };
+}
+
+export async function changeDocTranslation(repo: ContentRepository, kind: DocKind, id: string, locale: string, revision: string, mode: Mode, hooks: SaveHooks) {
+  requireLocale(locale);
+  const changed = await withDocLock(repo, kind, id, () => changeDocTranslationLocked(repo, kind, id, locale, revision, mode, hooks));
+  return { changed, ...(await getDocTranslation(repo, kind, id, locale)) };
+}
+async function changeDocTranslationLocked(repo: ContentRepository, kind: DocKind, id: string, locale: string, revision: string, mode: Mode, hooks: SaveHooks) {
+  const raw = await loadDoc(repo, kind, id);
+  checkRevision(raw, revision);
+  const doc = mergedDoc(kind, raw) as unknown as Record<string, unknown> & { translations?: DocTranslations };
+  const current = doc.translations?.[locale] ?? emptyDocTr();
+  const next = { ...current, meta: { ...current.meta } } as Record<string, unknown> & { meta: Meta };
+  const changed = await applyMode(docUnits(kind, doc), next, next.meta, mode, locale, repo, hooks.locals);
+  if (changed) {
+    const parsed = DocTranslation.parse(next);
+    await saveRaw(repo, kind, id, { translations: { ...(doc.translations ?? {}), [locale]: parsed } }, hooks);
+  }
+  return changed;
+}
+
+// ---- sections --------------------------------------------------------------
+
+export async function getSectionTranslation(repo: ContentRepository, pageId: string, sectionId: string, locale: string) {
+  requireLocale(locale);
+  const settings = await repo.getSettings();
+  const section = findSection(stagedPages(settings), pageId, sectionId);
+  const def = (await stagedTheme(settings)).sections[section.type];
+  if (!def) throw new ApiError(409, `The “${section.type}” section isn’t available in this theme.`);
+  const tr = section.translations?.[locale] ?? { data: {}, meta: {} };
+  const units: Unit[] = translationUnits(def, section.data).map((u) => ({ path: u.path, label: u.label, kind: u.kind as Unit['kind'], source: u.source, hash: u.hash }));
+  return { locale, revision: settings.designRevision, ...view(units, tr.data, tr.meta as Meta) };
+}
+
+export async function changeSectionTranslation(repo: ContentRepository, who: EditorPrincipal, pageId: string, sectionId: string, locale: string, revision: number, mode: Mode, origin: string, locals: unknown) {
+  requireLocale(locale);
+  const settings = await repo.getSettings();
+  if (settings.designRevision !== revision) throw new ApiError(409, 'Design changed. Pull the latest revision before saving.');
+  const section = findSection(stagedPages(settings), pageId, sectionId);
+  const def = (await stagedTheme(settings)).sections[section.type];
+  if (!def) throw new ApiError(409, `The “${section.type}” section isn’t available in this theme.`);
+  if (section.locked && who.user.role !== 'owner') throw new ApiError(403, `Only an owner can edit the locked “${def.name}” section.`);
+  const units: Unit[] = translationUnits(def, section.data).map((u) => ({ path: u.path, label: u.label, kind: u.kind as Unit['kind'], source: u.source, hash: u.hash }));
+  const cur = section.translations?.[locale] ?? { data: {}, meta: {} };
+  const next = { data: { ...cur.data } as Record<string, unknown>, meta: { ...cur.meta } as Meta };
+  const changed = await applyMode(units, next.data, next.meta, mode, locale, repo, locals);
+  let newRevision = revision;
+  if (changed) {
+    for (const [k, v] of Object.entries(next.data)) if (v === '') { delete next.data[k]; delete next.meta[k]; }
+    const result = await stageSection(repo, who, revision, pageId, sectionId,
+      (s) => ({ ...s, translations: { ...(s.translations ?? {}), [locale]: next as NonNullable<typeof s.translations>[string] } }), origin);
+    newRevision = result.revision;
+  }
+  return { changed, ...(await getSectionTranslation(repo, pageId, sectionId, locale)), revision: newRevision };
+}

package/src/lib/email/accounts.ts

@@ -1,3 +1,4 @@
+import type { Role } from '../schema';
 import { randomBytes } from 'node:crypto';
 import type { ContentRepository } from '../repo/types';
 import { hashPassword, verifyPassword, checkPassword, OWNER_ENV } from '../auth';
@@ -27,7 +28,7 @@ export async function reauthenticate(repo:ContentRepository, userId:string, pass
   const user=await repo.getUser(userId); if(!user)return false;
   const auth=await repo.getUserAuth(user.email);return !!auth && verifyPassword(password,auth.passHash);
 }
-export async function issueAccountToken(repo:ContentRepository, data:{purpose:'invite'|'reset';email:string;name?:string;role?:'owner'|'editor';expiresDays?:number}, locals?:unknown) {
+export async function issueAccountToken(repo:ContentRepository, data:{purpose:'invite'|'reset';email:string;name?:string;role?:Role;expiresDays?:number}, locals?:unknown) {
   const email=data.email.trim().toLowerCase();
   if(!validAddress(email))throw new Error('Enter a valid email address.');
   const auth=await repo.getUserAuth(email);

package/src/lib/email/types.ts

@@ -1,3 +1,4 @@
+import type { Role } from '../schema';
 export type Provider = 'resend' | 'mailgun' | 'ses' | 'cloudflare';
 export type ProviderChoice = Provider | 'auto' | 'none';
 export interface Attachment { filename: string; type: string; content: string }
@@ -20,7 +21,7 @@ export interface EmailJob {
 }
 export interface NewEmailJob { id?: string; dedupe: string; kind: string; recipient: string; payload: string; configVersion: number; nextAt?: number; expiresAt?: number }
 export type SendResult = { state: 'accepted'; providerId: string } | { state: 'retrying' | 'failed' | 'unknown'; error: string; retryAfter?: number };
-export interface Invitation { id: string; email: string; name: string; role: 'owner' | 'editor'; state: string; expiresAt: number; createdAt: number }
+export interface Invitation { id: string; email: string; name: string; role: Role; state: string; expiresAt: number; createdAt: number }
 export interface PublicEmailSettings {
   version: number; config: EmailConfig; provider: Provider | 'none'; configured: boolean; error: string;
   encryptionAvailable: boolean; environmentLocked: boolean; credentialFields: string[];

package/src/lib/home-source.ts

@@ -0,0 +1,34 @@
+import type { Page, Settings } from './schema';
+import { resolveDesign } from './theme';
+
+// Which homepage do visitors actually get? Mirrors pages/index.astro:
+//   1. the home page has a section layout in 'sections' mode → sections
+//   2. else the active theme ships templates/home.astro and neither the
+//      Design screen nor the page forces 'content' → coded template
+//   3. else → this page's own content
+// The page editor uses it to point people at the right place, instead of
+// letting them edit text that isn't what the homepage shows.
+
+export type HomeSource =
+  | { kind: 'content' }
+  | { kind: 'sections'; editUrl: string; showsPageContent: boolean; sections: number }
+  | { kind: 'template'; editUrl: string; theme: string; file: string };
+
+export function homeSource(settings: Settings, page: Pick<Page, 'id' | 'isHome'>): HomeSource {
+  if (!page.isHome) return { kind: 'content' };
+  const layout = settings.sectionPages?.[page.id];
+  if (layout?.mode === 'sections') {
+    const visible = layout.sections.filter((s) => !s.hidden);
+    return {
+      kind: 'sections',
+      editUrl: `/admin/design?page=${encodeURIComponent(page.id)}#pages`,
+      showsPageContent: visible.some((s) => s.type === 'page-content'),
+      sections: visible.length,
+    };
+  }
+  const design = resolveDesign(settings);
+  if (design.HomeTemplate && design.homeMode !== 'content' && layout?.mode !== 'content') {
+    return { kind: 'template', editUrl: '/admin/design', theme: design.theme.name, file: `src/themes/${design.theme.slug}/templates/home.astro` };
+  }
+  return { kind: 'content' };
+}

package/src/lib/i18n.ts

@@ -38,3 +38,37 @@ export function normalizePageLocale(locale: string): string {
   if (!locale || locale === I18N.defaultLocale) return '';
   return I18N.locales.includes(locale) ? locale : '';
 }
+
+const NAMES: Record<string, string> = { en: 'English', es: 'Spanish', fr: 'French', de: 'German', pt: 'Portuguese', it: 'Italian', nl: 'Dutch', ko: 'Korean', zh: 'Chinese', ja: 'Japanese', tl: 'Tagalog', vi: 'Vietnamese', ar: 'Arabic', ru: 'Russian', uk: 'Ukrainian', pl: 'Polish', ht: 'Haitian Creole' };
+const NATIVE: Record<string, string> = { en: 'English', es: 'Español', fr: 'Français', de: 'Deutsch', pt: 'Português', it: 'Italiano', nl: 'Nederlands', ko: '한국어', zh: '中文', ja: '日本語', tl: 'Tagalog', vi: 'Tiếng Việt', ar: 'العربية', ru: 'Русский', uk: 'Українська', pl: 'Polski', ht: 'Kreyòl' };
+/** "es" → "Spanish" (for AI prompts); native: "es" → "Español" (for people) */
+export function localeName(code: string, native = false): string {
+  const base = code.split('-')[0];
+  return (native ? NATIVE : NAMES)[base] ?? code;
+}
+
+/** the extra (non-default) languages */
+export const extraLocales = (): string[] => (I18N.enabled ? I18N.locales.filter((l) => l !== I18N.defaultLocale) : []);
+
+/** a request's language: set by the middleware for /<locale>/… rewrites, else from the path */
+export function requestLocale(url: URL, locals?: unknown): string {
+  const fromLocals = (locals as { acmsLocale?: string } | undefined)?.acmsLocale;
+  return fromLocals || localeFromPath(url.pathname);
+}
+
+/** "/events/x" in a language: "/es/events/x"; the default language has no prefix */
+export function localePath(path: string, locale: string): string {
+  const bare = stripLocale(path);
+  if (!locale || locale === I18N.defaultLocale || !I18N.enabled) return bare;
+  return bare === '/' ? `/${locale}` : `/${locale}${bare}`;
+}
+
+/** drop a leading non-default locale prefix: "/es/events/x" → "/events/x", "/es" → "/" */
+export function stripLocale(path: string): string {
+  for (const l of I18N.locales) {
+    if (l === I18N.defaultLocale) continue;
+    if (path === `/${l}`) return '/';
+    if (path.startsWith(`/${l}/`)) return path.slice(l.length + 1);
+  }
+  return path || '/';
+}

package/src/lib/import/apply.ts

@@ -2,7 +2,7 @@ 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';
+import { ASSET_SCHEME, ImportAuthor, ImportIdentity, ImportItem, ImportLayout, 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:
@@ -296,6 +296,7 @@ export const FinishInput = z.object({
   // 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([]),
+  layouts: z.array(ImportLayout).max(1000).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,
@@ -347,6 +348,34 @@ export async function finishImport(repo: ContentRepository, input: z.infer<typeo
     }
   }
 
+  // section layouts: staged in the design draft (never live) for pages this
+  // run created or matched; a page that already has a layout keeps it.
+  // Links that pointed at the old site's pages/posts follow them here.
+  let layouts = 0;
+  if (input.layouts?.length) {
+    const byItem = new Map(all.filter((r) => r.kind === 'post' || r.kind === 'page').map((r) => [`${r.kind}:${r.sourceId}`, r.acmsId]));
+    const current = await repo.getSettings();
+    const staged = { ...((current.draftDesign?.sectionPages ?? current.sectionPages) as typeof current.sectionPages) };
+    const remap = (v: unknown): unknown => {
+      if (Array.isArray(v)) return v.map(remap);
+      if (!v || typeof v !== 'object') return v;
+      const o = Object.fromEntries(Object.entries(v as Record<string, unknown>).map(([k, x]) => [k, remap(x)]));
+      if (typeof o.ref === 'string') {
+        const [kind, id] = o.ref.split(':');
+        const to = (kind === 'page' || kind === 'post') ? byItem.get(`${kind}:${id}`) : undefined;
+        if (to) o.ref = `${kind}:${to}`; else delete o.ref;
+      }
+      return o;
+    };
+    for (const l of input.layouts) {
+      const id = byItem.get(`page:${l.sourceId}`);
+      if (!id || staged[id]) continue;
+      staged[id] = { ...l.layout, sections: l.layout.sections.map((s) => ({ ...s, data: remap(s.data) as typeof s.data })) };
+      layouts++;
+    }
+    if (layouts) await repo.setDesignDraft({ ...current.draftDesign, sectionPages: staged }, current.designRevision, 'import');
+  }
+
   const settings: Record<string, string> = {};
   if (input.options.identity) {
     for (const [k, v] of Object.entries(input.identity)) {
@@ -367,7 +396,7 @@ export async function finishImport(repo: ContentRepository, input: z.infer<typeo
     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,
+      users: count('user'), tags: count('tag'), media: count('media'), redirects: created.redirects, nav: created.nav, layouts,
     },
     settings: Object.keys(settings),
     warnings: input.warnings,

package/src/lib/import/bundle.ts

@@ -1,3 +1,4 @@
+import { SectionLayout } from '../../theme-sdk/contract.mjs';
 import { z } from 'zod';
 import { Media } from '../schema';
 
@@ -114,6 +115,7 @@ export const ImportWarning = z.object({
 });
 export type ImportWarning = z.infer<typeof ImportWarning>;
 
+export const ImportLayout = z.object({ sourceId: z.string().max(200), layout: SectionLayout });
 export const ImportBundle = z.object({
   format: z.literal(BUNDLE_FORMAT),
   version: z.literal(BUNDLE_VERSION),
@@ -133,6 +135,8 @@ export const ImportBundle = z.object({
   nav: z.array(ImportNav).max(500).default([]),
   // the source site's own redirect rules (acms exports)
   redirects: z.array(ImportRedirect).max(10_000).default([]),
+  // page section layouts (acms exports), keyed by the page's sourceId
+  layouts: z.array(ImportLayout).max(1000).default([]),
   warnings: z.array(ImportWarning).max(10_000).default([]),
 });
 export type ImportBundle = z.infer<typeof ImportBundle>;

package/src/lib/import/export.ts

@@ -49,6 +49,7 @@ export async function exportBundle(repo: ContentRepository, now = Date.now()): P
     media,
     nav: nav.map((n) => ({ label: n.label, url: n.url, area: n.area })),
     redirects: redirects.map((r) => ({ from: r.fromPath, to: r.toPath })),
+    layouts: pages.filter((p) => settings.sectionPages?.[p.id]).map((p) => ({ sourceId: p.id, layout: settings.sectionPages[p.id] })),
     warnings: [],
   };
 }

package/src/lib/import/ghost.ts

@@ -242,6 +242,7 @@ export function ghostToBundle(json: unknown, options: GhostOptions): ImportBundl
     media: [],
     nav,
     redirects: [],
+    layouts: [],
     warnings,
   };
 }

package/src/lib/media/upload.ts

@@ -0,0 +1,83 @@
+import type { ContentRepository } from '../repo/types';
+import type { Media } from '../schema';
+import { ApiError } from '../api';
+import { getMediaStore } from './store';
+
+// Multipart upload shared by the admin (/api/media/upload) and editor apps
+// (/api/v1/admin/media). For images the client has already done the heavy
+// lifting (EXIF rotation, downscale, WebP re-encode, variant generation);
+// this stores the optimized file + variants and records the media row.
+// SVG/GIF arrive untouched. Documents (for the file/download card) are
+// stored as-is. Video/audio is deliberately rejected — embeds cover video
+// until a streaming upload + Range-serving pipeline exists.
+//
+// Fields: file (primary), width, height, alt?, variant_<w> (File, webp)…
+export const DOCUMENT_TYPES = new Set([
+  'application/pdf',
+  'application/zip',
+  'application/x-zip-compressed',
+  'application/json',
+  'text/plain',
+  'text/csv',
+  'text/markdown',
+  'application/msword',
+  'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  'application/vnd.ms-excel',
+  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  'application/vnd.ms-powerpoint',
+  'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  'application/epub+zip',
+]);
+export const MAX_IMAGE = 30 * 1024 * 1024;
+export const MAX_DOCUMENT = 25 * 1024 * 1024;
+/** a whole multipart body: the image plus its resized variants */
+export const MAX_UPLOAD_BODY = MAX_IMAGE * 2;
+
+export async function storeUpload(form: FormData, locals: unknown, repo: ContentRepository): Promise<Media> {
+  const file = form.get('file');
+  if (!(file instanceof File) || file.size === 0) throw new ApiError(400, 'Missing file');
+  const isImage = file.type.startsWith('image/');
+  const isDocument = DOCUMENT_TYPES.has(file.type);
+  if (!isImage && !isDocument) {
+    throw new ApiError(415, file.type.startsWith('video/') || file.type.startsWith('audio/')
+      ? 'Video and audio uploads aren’t supported yet — use an embed card instead.'
+      : 'Unsupported file type.');
+  }
+  const cap = isImage ? MAX_IMAGE : MAX_DOCUMENT;
+  if (file.size > cap) throw new ApiError(413, `File too large (max ${Math.round(cap / 1024 / 1024)} MB)`);
+
+  const variantFields = [...form.entries()].filter(([field, value]) => /^variant_\d+$/.test(field) && value instanceof File && value.size > 0);
+  if (variantFields.length > 8) throw new ApiError(400, 'Too many image sizes (max 8).');
+  for (const [field, value] of variantFields) {
+    const w = Number(field.slice(8));
+    if (!Number.isInteger(w) || w < 16 || w > 8192) throw new ApiError(400, 'Image sizes must be 16–8192 pixels wide.');
+    if ((value as File).size > MAX_IMAGE) throw new ApiError(413, `File too large (max ${Math.round(MAX_IMAGE / 1024 / 1024)} MB)`);
+  }
+
+  const id = crypto.randomUUID();
+  const ext = (file.name.split('.').pop() || 'bin').toLowerCase().replace(/[^a-z0-9]/g, '') || 'bin';
+  const key = `${id}/original.${ext}`;
+  const store = getMediaStore(locals);
+  await store.put(key, await file.arrayBuffer(), file.type);
+
+  const variants: { w: number; key: string }[] = [];
+  for (const [field, value] of variantFields) {
+    const w = Number(field.slice(8));
+    const vkey = `${id}/w${w}.webp`;
+    await store.put(vkey, await (value as File).arrayBuffer(), 'image/webp');
+    variants.push({ w, key: vkey });
+  }
+  variants.sort((a, b) => a.w - b.w);
+
+  return repo.createMedia({
+    id,
+    key,
+    filename: file.name,
+    mime: file.type,
+    width: Number(form.get('width') ?? 0),
+    height: Number(form.get('height') ?? 0),
+    size: file.size,
+    alt: String(form.get('alt') ?? ''),
+    variants,
+  });
+}

package/src/lib/mobile/associations.ts

@@ -0,0 +1,25 @@
+import type { APIRoute } from 'astro';
+import { userConfig } from 'virtual:acms-config';
+import { ApiError } from '../api';
+import { failure, publicResponse } from './http';
+
+export function association(platform: 'ios' | 'android', mobile = userConfig.mobile) {
+  if (platform === 'ios' && mobile?.ios) {
+    const { teamId, bundleId, paths } = mobile.ios;
+    return { applinks: { apps: [], details: [{ appID: `${teamId}.${bundleId}`, paths }] } };
+  }
+  if (platform === 'android' && mobile?.android) {
+    return [{ relation: ['delegate_permission/common.handle_all_urls'], target: {
+      namespace: 'android_app', package_name: mobile.android.package, sha256_cert_fingerprints: mobile.android.sha256CertFingerprints,
+    } }];
+  }
+  throw new ApiError(404, 'App association not configured.');
+}
+export function associationRoute(platform: 'ios' | 'android'): APIRoute {
+  return async ({ request }) => {
+    let res: Response;
+    try { res = await publicResponse(request, association(platform), true); }
+    catch (error) { res = failure(error); }
+    return request.method === 'HEAD' ? new Response(null, { status: res.status, headers: res.headers }) : res;
+  };
+}

package/src/lib/mobile/calendar.ts

@@ -5,10 +5,12 @@ import { CALENDAR, bookingsEnabled, resourceUrl, bookingLinkUrl } from '../calen
 import { calendarToJson, eventToJson } from '../calendar/api';
 import { eventIsListed, eventIsPublic, expandEvents } from '../calendar/events';
 import { availabilityContext } from '../booking/service';
-import { addDaysYmd, describeLink, linkLengths, slotsForDay, ymd } from '../booking/availability';
+import { addDaysYmd, describeLink, linkLengths, localMidnight, slotsForDay, ymd } from '../booking/availability';
 import { siteOrigin } from '../seo';
 import { safeUrl } from './content';
 import { pageQuery, isoDay, queryParams } from './http';
+import { localizeDoc } from '../translations';
+import { localeQuery, mobileLocale, localizedUrl } from './locale';
 
 export function requireCalendar(bookings = false) {
   if (!CALENDAR.enabled || (bookings && !bookingsEnabled())) throw new ApiError(404, 'This feature is disabled.');
@@ -19,31 +21,36 @@ export async function listCalendars(repo: ContentRepository, url: URL) {
   const origin = siteOrigin(await repo.getSettings(), url);
   return { calendars: (await repo.listCalendars()).filter(c => c.visibility === 'public').map(c => calendarToJson(c, origin)) };
 }
+export const eventsQuery = z.object({ ...pageQuery, locale: localeQuery, from: isoDay.optional(), to: isoDay.optional(), calendar: z.string().min(1).max(200).optional(), q: z.string().max(100).optional() }).strict();
 export async function listEvents(repo: ContentRepository, url: URL) {
   requireCalendar();
-  const q = z.object({ ...pageQuery, from: isoDay.optional(), to: isoDay.optional(), calendar: z.string().min(1).max(200).optional(), q: z.string().max(100).optional() }).strict().parse(queryParams(url));
-  const from = Date.parse(q.from ?? new Date().toISOString().slice(0, 10));
-  const to = q.to ? Date.parse(q.to) : from + 30 * 86400000;
-  if (to <= from || to - from > 90 * 86400000) throw new ApiError(400, 'Use an event window of 1 to 90 days.');
+  const q = eventsQuery.parse(queryParams(url));
+  const locale = mobileLocale(q.locale);
   const [settings, calendars, events] = await Promise.all([repo.getSettings(), repo.listCalendars(), repo.listPublishedEvents()]);
+  // days are the site's calendar days (a New York site's "today" starts at midnight there, not UTC)
+  const tz = settings.timezone || 'UTC';
+  const from = localMidnight(q.from ?? ymd(Date.now(), tz), tz);
+  const to = q.to ? localMidnight(q.to, tz) : localMidnight(addDaysYmd(q.from ?? ymd(Date.now(), tz), 30), tz);
+  if (to <= from || to - from > 90 * 86400000 + 3600000) throw new ApiError(400, 'Use an event window of 1 to 90 days.');
   const all = new Map(calendars.map(c => [c.id, c]));
   const cal = q.calendar ? calendars.find(c => c.slug === q.calendar && c.visibility !== 'private') : null;
   if (q.calendar && !cal) throw new ApiError(404, 'Calendar not found.');
   const publicCalendars = new Map(calendars.filter(c => c.visibility === 'public' || c.id === cal?.id).map(c => [c.id, c]));
-  const visible = events.filter(e => (cal ? e.calendarIds.includes(cal.id) && eventIsPublic(e, all) : eventIsListed(e, all))
+  const visible = events.map(e => localizeDoc(e, locale ?? undefined)).filter(e => (cal ? e.calendarIds.includes(cal.id) && eventIsPublic(e, all) : eventIsListed(e, all))
     && (!q.q || `${e.title} ${e.excerpt} ${e.location.name}`.toLowerCase().includes(q.q.toLowerCase())));
   const occurrences = expandEvents(visible, settings, { displayTz: settings.timezone || 'UTC', now: Date.now(), windowStartMs: from, windowEndMs: to });
   occurrences.sort((a, b) => a.start - b.start || (a.event.id < b.event.id ? -1 : a.event.id > b.event.id ? 1 : 0));
   const start = (q.page - 1) * q.limit;
   const origin = siteOrigin(settings, url);
   return {
-    timezone: settings.timezone || 'UTC', from: new Date(from).toISOString(), to: new Date(to).toISOString(),
+    locale, timezone: settings.timezone || 'UTC', from: new Date(from).toISOString(), to: new Date(to).toISOString(),
     occurrences: occurrences.slice(start, start + q.limit).map(o => {
       const event = eventToJson(o.event, origin, publicCalendars, settings.timezone);
+      event.url = localizedUrl(event.url, origin, locale);
       // Only configured public event fields; no undeclared imported metadata.
       event.fields = Object.fromEntries(CALENDAR.eventFields.filter(f => Object.hasOwn(o.event.fields, f.key)).map(f => [f.key, o.event.fields[f.key]]));
       event.image = safeUrl(o.event.cover, origin);
-      event.cta = { ...event.cta, href: safeUrl(event.cta.href, origin, true) };
+      event.cta = { ...event.cta, href: localizedUrl(safeUrl(event.cta.href, origin, true), origin, locale) };
       return { id: `${o.event.id}:${o.start}`, start: new Date(o.start).toISOString(), end: new Date(o.end).toISOString(), allDay: o.allDay, event };
     }),
     pagination: { page: q.page, limit: q.limit, nextPage: occurrences.length > start + q.limit ? q.page + 1 : null },
@@ -65,11 +72,12 @@ export async function listResources(repo: ContentRepository, url: URL) {
     })),
   })), pagination: { page: q.page, limit: q.limit, nextPage: visible.length > start + q.limit ? q.page + 1 : null } };
 }
+export const availabilityQuery = z.object({ resource: z.string().min(1).max(200), link: z.string().min(1).max(200), from: isoDay.optional(),
+  days: z.coerce.number().int().min(1).max(31).default(7), minutes: z.coerce.number().int().min(1).max(44640).optional(),
+}).strict();
 export async function getAvailability(repo: ContentRepository, url: URL) {
   requireCalendar(true);
-  const q = z.object({ resource: z.string().min(1).max(200), link: z.string().min(1).max(200), from: isoDay.optional(),
-    days: z.coerce.number().int().min(1).max(31).default(7), minutes: z.coerce.number().int().min(1).max(44640).optional(),
-  }).strict().parse(queryParams(url));
+  const q = availabilityQuery.parse(queryParams(url));
   const resource = await repo.getResourceBySlug(q.resource);
   const link = resource ? await repo.getBookingLinkBySlug(resource.id, q.link) : null;
   if (!resource || !link || !link.active) throw new ApiError(404, 'Resource or booking link not found.');