@marktiderman/genesis-sites 0.1.0 → 0.3.0

package/dist/{chunk-GA7U3CIN.js → chunk-FBQF2L7O.js}

@@ -1,93 +1,7 @@
-import { getSection, pagePathProblems, isReservedPath, ReleaseSnapshot, DEFAULT_RESERVED_PATHS, validatePagePath, redirectsAfterMove, PageDoc, SiteDoc } from './chunk-KEF3V5ZN.js';
+import { getSection, PostSlug, PostDoc, ReleaseSnapshot, validatePostSlug, MAX_IMPORT_POSTS, MAX_LIVE_POSTS, postSummary, redirectsAfterMove, PageDoc, SiteDoc } from './chunk-ZGWGQGT2.js';
+import { pagePathProblems, isReservedPath, DEFAULT_RESERVED_PATHS, validatePagePath } from './chunk-3VKTBE7S.js';
 import { genesisBrand, themeFromBrand } from '@marktiderman/genesis-design-system';
 
-// src/core/migrate.ts
-function migrateNode(node, lookup = getSection) {
-  const def = lookup(node.type);
-  const where = { sectionId: node.id, type: node.type };
-  if (!def) {
-    return {
-      node: null,
-      changed: false,
-      issues: [{ ...where, severity: "error", code: "unknown-section", message: `No section "${node.type}" is registered; section ${node.id} can't be shown.` }]
-    };
-  }
-  if (node.v > def.version) {
-    return {
-      node: null,
-      changed: false,
-      issues: [
-        {
-          ...where,
-          severity: "error",
-          code: "newer-version",
-          message: `Section ${node.id} was saved by a newer "${node.type}" (v${node.v}) than this code knows (v${def.version}).`
-        }
-      ]
-    };
-  }
-  let props = node.props;
-  for (let n = node.v + 1; n <= def.version; n++) {
-    const step = def.migrations?.[n];
-    try {
-      props = step ? step(structuredClone(props)) : props;
-    } catch (err) {
-      return {
-        node: null,
-        changed: false,
-        issues: [{ ...where, severity: "error", code: "migration-failed", message: `Migrating section ${node.id} to v${n} failed: ${err.message}` }]
-      };
-    }
-  }
-  const parsed = def.schema.safeParse(props);
-  if (!parsed.success) {
-    return {
-      node: null,
-      changed: false,
-      issues: [
-        {
-          ...where,
-          severity: "error",
-          code: "invalid-props",
-          message: `Section ${node.id} (${def.label}): ${parsed.error.issues.map((i) => `${i.path.join(".") || "props"}: ${i.message}`).join("; ")}`
-        }
-      ]
-    };
-  }
-  const issues = [];
-  let variant = node.variant ?? def.defaultVariant;
-  if (!def.variants.some((v) => v.id === variant)) {
-    issues.push({ ...where, severity: "warning", code: "unknown-variant", message: `Section ${node.id} asks for variant "${variant}", which "${node.type}" doesn't have; showing "${def.defaultVariant}".` });
-    variant = def.defaultVariant;
-  }
-  const next = { ...node, v: def.version, variant, props: parsed.data };
-  const changed = node.v !== def.version || variant !== node.variant || JSON.stringify(parsed.data) !== JSON.stringify(node.props);
-  return { node: next, changed, issues };
-}
-function migratePage(doc, lookup) {
-  const issues = [];
-  let changed = false;
-  const content = doc.content.map((node) => {
-    const m = migrateNode(node, lookup);
-    issues.push(...m.issues);
-    if (m.node && m.changed) changed = true;
-    return m.node ?? node;
-  });
-  return { doc: changed ? { ...doc, content } : doc, changed, issues };
-}
-function migrateSite(site, lookup) {
-  const issues = [];
-  let changed = false;
-  const run = (nodes) => nodes.map((node) => {
-    const m = migrateNode(node, lookup);
-    issues.push(...m.issues);
-    if (m.node && m.changed) changed = true;
-    return m.node ?? node;
-  });
-  const header = run(site.header);
-  const footer = run(site.footer);
-  return { site: changed ? { ...site, header, footer } : site, changed, issues };
-}
 var FONT_CHOICES = Object.freeze({
   system: { label: "System", stack: 'ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif' },
   inter: { label: "Inter", stack: "Inter, ui-sans-serif, system-ui, sans-serif", google: "Inter:wght@400;500;600;700" },
@@ -217,7 +131,10 @@ function pairsFor(c, mode) {
     { name: "body text on a muted band", mode, foreground: c.foreground, background: c.muted, minimum: 4.5 },
     { name: "button and accent-band text on the primary colour", mode, foreground: c.primaryForeground, background: c.primary, minimum: 4.5 },
     { name: "text on an inverse band", mode, foreground: c.background, background: c.foreground, minimum: 4.5 },
-    { name: "the focus ring on the page", mode, foreground: c.ring, background: c.background, minimum: 3 }
+    { name: "the focus ring on the page", mode, foreground: c.ring, background: c.background, minimum: 3 },
+    // Non-text (1.4.11): the primary colour as a border or marker (a timetable chip, the picked day, a timeline's step).
+    // Every such mark also has text or a shape (a chip names its type, a marker shows a dot), so it warns.
+    { name: "the primary colour as a border or marker on the page", mode, foreground: c.primary, background: c.background, minimum: 3, severity: "warning" }
   ];
 }
 function stableHash(value) {
@@ -277,13 +194,101 @@ function themeCss(theme) {
   return block(":root", theme.light) + ":root{color-scheme:light}";
 }
 
+// src/core/migrate.ts
+function migrateNode(node, lookup = getSection) {
+  const def = lookup(node.type);
+  const where = { sectionId: node.id, type: node.type };
+  if (!def) {
+    return {
+      node: null,
+      changed: false,
+      issues: [{ ...where, severity: "error", code: "unknown-section", message: `No section "${node.type}" is registered; section ${node.id} can't be shown.` }]
+    };
+  }
+  if (node.v > def.version) {
+    return {
+      node: null,
+      changed: false,
+      issues: [
+        {
+          ...where,
+          severity: "error",
+          code: "newer-version",
+          message: `Section ${node.id} was saved by a newer "${node.type}" (v${node.v}) than this code knows (v${def.version}).`
+        }
+      ]
+    };
+  }
+  let props = node.props;
+  for (let n = node.v + 1; n <= def.version; n++) {
+    const step = def.migrations?.[n];
+    try {
+      props = step ? step(structuredClone(props)) : props;
+    } catch (err) {
+      return {
+        node: null,
+        changed: false,
+        issues: [{ ...where, severity: "error", code: "migration-failed", message: `Migrating section ${node.id} to v${n} failed: ${err.message}` }]
+      };
+    }
+  }
+  const parsed = def.schema.safeParse(props);
+  if (!parsed.success) {
+    return {
+      node: null,
+      changed: false,
+      issues: [
+        {
+          ...where,
+          severity: "error",
+          code: "invalid-props",
+          message: `Section ${node.id} (${def.label}): ${parsed.error.issues.map((i) => `${i.path.join(".") || "props"}: ${i.message}`).join("; ")}`
+        }
+      ]
+    };
+  }
+  const issues = [];
+  let variant = node.variant ?? def.defaultVariant;
+  if (!def.variants.some((v) => v.id === variant)) {
+    issues.push({ ...where, severity: "warning", code: "unknown-variant", message: `Section ${node.id} asks for variant "${variant}", which "${node.type}" doesn't have; showing "${def.defaultVariant}".` });
+    variant = def.defaultVariant;
+  }
+  const next = { ...node, v: def.version, variant, props: parsed.data };
+  const changed = node.v !== def.version || variant !== node.variant || stableHash(props) !== stableHash(node.props);
+  return { node: next, changed, issues };
+}
+function migratePage(doc, lookup) {
+  const issues = [];
+  let changed = false;
+  const content = doc.content.map((node) => {
+    const m = migrateNode(node, lookup);
+    issues.push(...m.issues);
+    if (m.node && m.changed) changed = true;
+    return m.node ?? node;
+  });
+  return { doc: { ...doc, content }, changed, issues };
+}
+function migrateSite(site, lookup) {
+  const issues = [];
+  let changed = false;
+  const run = (nodes) => nodes.map((node) => {
+    const m = migrateNode(node, lookup);
+    issues.push(...m.issues);
+    if (m.node && m.changed) changed = true;
+    return m.node ?? node;
+  });
+  const header = run(site.header);
+  const footer = run(site.footer);
+  return { site: { ...site, header, footer }, changed, issues };
+}
+
 // src/core/a11y.ts
 var isPublishable = (issues) => !issues.some((i) => i.severity === "error");
 function images(value, path = []) {
   if (!value || typeof value !== "object") return [];
   if (Array.isArray(value)) return value.flatMap((v, i) => images(v, [...path, String(i)]));
   const record = value;
-  const found = typeof record.src === "string" && ("alt" in record || "decorative" in record || /\.(png|jpe?g|webp|avif|gif|svg)(\?|$)/i.test(record.src)) ? [{ path: path.join("."), image: record }] : [];
+  const found = typeof record.src === "string" && !("mime" in record) && ("alt" in record || "decorative" in record || /\.(png|jpe?g|webp|avif|gif|svg)(\?|$)/i.test(record.src)) ? [{ path: path.join("."), image: record }] : [];
   return [...found, ...Object.entries(record).flatMap(([k, v]) => k === "src" ? [] : images(v, [...path, k]))];
 }
 function richTextHeadings(value) {
@@ -368,7 +373,7 @@ function checkSiteDoc(site, lookup = getSection) {
 }
 function checkContrast(theme) {
   return theme.pairs.map((pair) => ({ pair, ratio: contrastRatio(pair.foreground, pair.background) })).filter(({ pair, ratio }) => ratio < pair.minimum).map(({ pair, ratio }) => ({
-    severity: "error",
+    severity: pair.severity ?? "error",
     code: "contrast",
     message: `In ${pair.mode} mode, ${pair.name} is ${ratio.toFixed(2)}:1 (${pair.foreground} on ${pair.background}); it needs ${pair.minimum}:1. Adjust the brand colours.`
   }));
@@ -384,6 +389,7 @@ function checkRelease(snapshot, options = {}) {
     issues.push(...checkPage(page, lookup, options.reserved));
   }
   if (!paths.has("/")) issues.push({ severity: "error", code: "no-home", message: "The site has no home page (a page at /)." });
+  issues.push(...checkBlog(snapshot, lookup));
   for (const r of snapshot.site.redirects) {
     if (paths.has(r.from)) issues.push({ severity: "error", code: "redirect-shadows-page", path: r.from, message: `The redirect from ${r.from} hides the page there; remove the redirect.` });
     const target = r.to.split(/[?#]/)[0];
@@ -397,6 +403,55 @@ function checkRelease(snapshot, options = {}) {
   if (options.theme) issues.push(...checkContrast(options.theme));
   return issues;
 }
+function checkBlog(snapshot, lookup = getSection) {
+  const issues = [];
+  const postPages = snapshot.pages.filter((p) => p.kind === "post");
+  if (postPages.length > 1) {
+    issues.push({ severity: "error", code: "post-page-count", message: `The site has ${postPages.length} post pages (${postPages.map((p) => p.path).join(", ")}); posts render in one.` });
+  }
+  for (const page of postPages) {
+    const base = { pageId: page.id, path: page.path };
+    if (page.path === "/") issues.push({ ...base, severity: "error", code: "post-page-home", message: "The home page can't be the post page: posts would take over the site's paths. Put it at /blog." });
+    if (page.path.split("/").filter(Boolean).length >= 8) issues.push({ ...base, severity: "error", code: "post-page-depth", message: `${page.path}: the post page is too deep for posts to go below it.` });
+    if (!page.doc.content.some((n) => !n.hidden && n.type === "post-body")) {
+      issues.push({ ...base, severity: "error", code: "post-page-body", message: `${page.path}: the post page needs a Post section, where each post's title and text go.` });
+    }
+  }
+  if (!postPages.length) {
+    for (const page of snapshot.pages) {
+      for (const node of page.doc.content) {
+        if (!node.hidden && node.type === "blog-list" && lookup(node.type)) {
+          issues.push({ pageId: page.id, path: page.path, sectionId: node.id, severity: "error", code: "blog-list-no-post-page", message: `${page.path}: a post list needs the site's post page (a page of kind "post", such as /blog) for its links to open.` });
+        }
+      }
+    }
+  }
+  return issues;
+}
+function checkPost(slug, doc) {
+  const issues = [];
+  const at = `The post ${JSON.stringify(slug)}`;
+  if (!PostSlug.safeParse(slug).success) issues.push({ severity: "error", code: "post-slug", message: `${at}: a slug is lowercase letters, digits and single hyphens.` });
+  const parsed = PostDoc.safeParse(doc);
+  if (!parsed.success) {
+    issues.push({ severity: "error", code: "post-invalid", message: `${at}: ${parsed.error.issues.map((i) => `${i.path.join(".") || "post"} ${i.message}`).join("; ")}` });
+    return issues;
+  }
+  for (const { path, image } of images(parsed.data)) {
+    if (path.startsWith("seo")) continue;
+    const alt = typeof image.alt === "string" ? image.alt.trim() : "";
+    if (!alt && image.decorative !== true) issues.push({ severity: "error", code: "image-alt", message: `${at}: an image (${path || "image"}) needs alt text, or to be marked decorative.` });
+  }
+  const levels = richTextHeadings(parsed.data.body);
+  for (let i = 0; i < levels.length; i++) {
+    const level = levels[i];
+    const previous = i === 0 ? 1 : levels[i - 1];
+    if (level === 1) issues.push({ severity: "error", code: "heading-h1", message: `${at}: the text can't hold a level 1 heading; the post's title is the page's.` });
+    else if (level > previous + 1) issues.push({ severity: "error", code: "heading-order", message: `${at}: a level ${level} heading follows a level ${previous}; don't skip a level.` });
+  }
+  if (!parsed.data.excerpt && !parsed.data.seo?.description) issues.push({ severity: "warning", code: "seo-description", message: `${at}: no excerpt for the list, search results and the feed.` });
+  return issues;
+}
 function checkHtmlOutline(html) {
   const issues = [];
   const body = html.replace(/<script\b[\s\S]*?<\/script>/gi, "").replace(/<style\b[\s\S]*?<\/style>/gi, "");
@@ -415,6 +470,11 @@ function checkHtmlOutline(html) {
 
 // src/core/store.ts
 var isConflict = (result) => "conflict" in result;
+var ASSET_TYPES = Object.freeze(["image/png", "image/jpeg", "image/webp", "image/avif", "image/gif", "application/pdf"]);
+function assetPath(siteId, id, name, mime) {
+  const clean = (name ?? "file").toLowerCase().replace(/[^a-z0-9.]+/g, "-").replace(/\.{2,}/g, ".").replace(/^[.-]+/, "").slice(0, 80) || "file";
+  return `sites/${siteId}/${mime === "application/pdf" ? "files/" : ""}${id}-${clean}`;
+}
 var PublishBlockedError = class extends Error {
   constructor(issues) {
     const errors = issues.filter((i) => i.severity === "error");
@@ -479,6 +539,39 @@ function withCacheInvalidation(store, invalidate) {
     deletePage: (id) => store.deletePage(id),
     listReleases: (id) => store.listReleases(id),
     ...store.putAsset ? { putAsset: store.putAsset.bind(store) } : {},
+    ...store.listLivePosts ? { listLivePosts: store.listLivePosts.bind(store) } : {},
+    ...store.getLivePost ? { getLivePost: store.getLivePost.bind(store) } : {},
+    ...store.listPosts ? { listPosts: store.listPosts.bind(store) } : {},
+    ...store.getPost ? { getPost: store.getPost.bind(store) } : {},
+    ...store.savePost ? { savePost: store.savePost.bind(store) } : {},
+    ...store.publishPost ? {
+      async publishPost(postId) {
+        const meta = await store.publishPost(postId);
+        await purge(meta.siteId, "post");
+        return meta;
+      }
+    } : {},
+    ...store.unpublishPost ? {
+      async unpublishPost(postId) {
+        const meta = await store.unpublishPost(postId);
+        await purge(meta.siteId, "post");
+        return meta;
+      }
+    } : {},
+    ...store.deletePost ? {
+      async deletePost(postId) {
+        const deleted = await store.deletePost(postId);
+        if (deleted) await purge(deleted.siteId, "post");
+        return deleted;
+      }
+    } : {},
+    ...store.importPosts ? {
+      async importPosts(siteId, list) {
+        const result = await store.importPosts(siteId, list);
+        await purge(siteId, "post");
+        return result;
+      }
+    } : {},
     async publish(siteId, options) {
       const release = await store.publish(siteId, options);
       await purge(siteId, "publish");
@@ -491,6 +584,23 @@ function withCacheInvalidation(store, invalidate) {
     }
   };
 }
+function prepareImportPost(item) {
+  const slug = typeof item?.slug === "string" ? item.slug : String(item?.slug);
+  try {
+    validatePostSlug(slug);
+  } catch (err) {
+    return { slug, reason: err.message };
+  }
+  const parsed = PostDoc.safeParse(item.doc);
+  if (!parsed.success) return { slug, reason: `The post doesn't parse: ${parsed.error.issues.map((i) => `${i.path.join(".") || "post"} ${i.message}`).join("; ")}` };
+  const now = Date.now();
+  const given = item.publishedAt ? new Date(item.publishedAt) : new Date(now);
+  if (Number.isNaN(given.getTime()) || given.getTime() < 0) return { slug, reason: `"${item.publishedAt}" isn't a usable publish date.` };
+  const date = new Date(Math.min(given.getTime(), now));
+  const errors = checkPost(slug, parsed.data).filter((i) => i.severity === "error").map((i) => i.message);
+  const status = item.status === "draft" || errors.length ? "draft" : "published";
+  return { doc: parsed.data, status, publishedAt: date.toISOString(), issues: errors };
+}
 var clone = (value) => structuredClone(value);
 function createMemorySiteStore(options = {}) {
   const reserved = options.reserved ?? DEFAULT_RESERVED_PATHS;
@@ -498,6 +608,7 @@ function createMemorySiteStore(options = {}) {
   const sites = /* @__PURE__ */ new Map();
   const pages = /* @__PURE__ */ new Map();
   const releases = /* @__PURE__ */ new Map();
+  const posts = /* @__PURE__ */ new Map();
   let seq = 0;
   const id = (prefix) => `${prefix}_${(++seq).toString(36).padStart(4, "0")}`;
   const editable = (siteId) => {
@@ -510,6 +621,20 @@ function createMemorySiteStore(options = {}) {
   const meta = (p) => ({ id: p.id, siteId: p.siteId, path: p.path, kind: p.kind, title: p.doc.root.props.title, sort: p.sort, rev: p.rev });
   const releaseMeta = ({ snapshot: _s, ...m }) => clone(m);
   const pathTaken = (siteId, path, except) => livePages(siteId).some((p) => p.path === path && p.id !== except);
+  const sitePosts = (siteId) => [...posts.values()].filter((p) => p.siteId === siteId && !p.deleted);
+  const postMeta = (p) => ({ id: p.id, siteId: p.siteId, slug: p.slug, title: p.doc.title, status: p.status, rev: p.rev, publishedAt: p.publishedAt, updatedAt: p.updatedAt });
+  const byNewest = (a, b) => (b.publishedAt ?? b.updatedAt).localeCompare(a.publishedAt ?? a.updatedAt);
+  const livePost = (p) => p.status === "published" && p.published && p.publishedAt ? { slug: p.slug, publishedAt: p.publishedAt, updatedAt: p.published.at, doc: clone(p.published.doc) } : null;
+  const siteIsLive = (siteId) => {
+    const s = sites.get(siteId);
+    return Boolean(s && s.status === "live" && s.liveReleaseId);
+  };
+  const editablePost = (postId) => {
+    const p = posts.get(postId);
+    if (!p || p.deleted) throw new Error(`No post ${postId}.`);
+    editable(p.siteId);
+    return p;
+  };
   const store = {
     async createSite(input) {
       const siteId = input.id ?? id("site");
@@ -644,15 +769,110 @@ function createMemorySiteStore(options = {}) {
     },
     async putAsset(siteId, file, assetMeta = {}) {
       editable(siteId);
+      const mime = file.type || "application/octet-stream";
+      if (!ASSET_TYPES.includes(mime)) throw new Error(`${mime} isn't an image (PNG, JPEG, WebP, AVIF, GIF) or a PDF.`);
       const assetId = id("asset");
-      const name = (assetMeta.name ?? "file").toLowerCase().replace(/[^a-z0-9.]+/g, "-").slice(0, 80) || "file";
-      const path = `sites/${siteId}/${assetId}-${name}`;
-      return { id: assetId, siteId, path, url: `/${path}`, mime: file.type || "application/octet-stream", alt: assetMeta.alt ?? null, width: assetMeta.width ?? null, height: assetMeta.height ?? null };
+      const path = assetPath(siteId, assetId, assetMeta.name, mime);
+      return { id: assetId, siteId, path, url: `/${path}`, mime, alt: assetMeta.alt ?? null, width: assetMeta.width ?? null, height: assetMeta.height ?? null };
+    },
+    async listLivePosts(siteId) {
+      if (!siteIsLive(siteId)) return [];
+      return sitePosts(siteId).map(livePost).filter((p) => p !== null).sort(byNewest).slice(0, MAX_LIVE_POSTS).map(postSummary);
+    },
+    async getLivePost(siteId, slug) {
+      if (!siteIsLive(siteId)) return null;
+      const p = sitePosts(siteId).find((x) => x.slug === slug);
+      return p ? livePost(p) : null;
+    },
+    async listPosts(siteId) {
+      if (options.canEdit && !options.canEdit(siteId)) return [];
+      return sitePosts(siteId).map(postMeta).sort(byNewest);
+    },
+    async getPost(postId) {
+      const p = posts.get(postId);
+      if (!p || p.deleted || options.canEdit && !options.canEdit(p.siteId)) return null;
+      return { ...postMeta(p), doc: clone(p.doc) };
+    },
+    async savePost(siteId, input) {
+      editable(siteId);
+      validatePostSlug(input.slug);
+      const doc = PostDoc.parse(clone(input.doc));
+      const at = now().toISOString();
+      if (!input.id) {
+        if (sitePosts(siteId).some((p2) => p2.slug === input.slug)) throw new Error(`A post is already at ${input.slug}.`);
+        const postId = id("post");
+        posts.set(postId, { id: postId, siteId, slug: input.slug, doc, rev: 1, status: "draft", published: null, publishedAt: null, updatedAt: at, deleted: false });
+        return { id: postId, rev: 1 };
+      }
+      const p = editablePost(input.id);
+      if (p.siteId !== siteId) throw new Error(`Post ${input.id} isn't one of site ${siteId}'s.`);
+      if (p.rev !== input.rev) return { id: p.id, conflict: clone(p.doc), rev: p.rev };
+      if (input.slug !== p.slug) {
+        if (p.publishedAt) throw new Error("A post keeps its slug once it has been published: its address is out in the world.");
+        if (sitePosts(siteId).some((x) => x.slug === input.slug && x.id !== p.id)) throw new Error(`A post is already at ${input.slug}.`);
+        p.slug = input.slug;
+      }
+      p.doc = doc;
+      p.rev += 1;
+      p.updatedAt = at;
+      return { id: p.id, rev: p.rev };
+    },
+    async publishPost(postId) {
+      const p = editablePost(postId);
+      if (sites.get(p.siteId)?.status === "archived") throw new Error("An archived site can't publish posts.");
+      const issues = checkPost(p.slug, p.doc);
+      if (!isPublishable(issues)) throw new PublishBlockedError(issues);
+      const at = now().toISOString();
+      p.published = { doc: clone(p.doc), at };
+      p.status = "published";
+      p.publishedAt ??= at;
+      p.updatedAt = at;
+      return postMeta(p);
+    },
+    async unpublishPost(postId) {
+      const p = editablePost(postId);
+      p.status = "draft";
+      p.published = null;
+      p.updatedAt = now().toISOString();
+      return postMeta(p);
+    },
+    async deletePost(postId) {
+      const p = posts.get(postId);
+      if (!p || p.deleted) return null;
+      editable(p.siteId);
+      p.deleted = true;
+      p.status = "draft";
+      p.published = null;
+      return { siteId: p.siteId };
+    },
+    async importPosts(siteId, list) {
+      if (editable(siteId).status === "archived") throw new Error(`No site ${siteId} to import into: it is archived.`);
+      if (list.length > MAX_IMPORT_POSTS) throw new Error(`Import at most ${MAX_IMPORT_POSTS} posts at a time.`);
+      const result = { imported: [], skipped: [] };
+      const seen = new Set(sitePosts(siteId).map((p) => p.slug));
+      for (const item of list) {
+        const prepared = prepareImportPost(item);
+        if ("reason" in prepared) {
+          result.skipped.push(prepared);
+          continue;
+        }
+        if (seen.has(item.slug)) {
+          result.skipped.push({ slug: item.slug, reason: "The site already has a post at this slug." });
+          continue;
+        }
+        seen.add(item.slug);
+        const postId = id("post");
+        const at = now().toISOString();
+        const published = prepared.status === "published" ? { doc: clone(prepared.doc), at: prepared.publishedAt } : null;
+        posts.set(postId, { id: postId, siteId, slug: item.slug, doc: prepared.doc, rev: 1, status: prepared.status, published, publishedAt: published ? prepared.publishedAt : null, updatedAt: at, deleted: false });
+        result.imported.push({ slug: item.slug, id: postId, status: prepared.status, ...prepared.issues.length ? { issues: prepared.issues } : {} });
+      }
+      return result;
     }
   };
   return store;
 }
 
-export { FONT_CHOICES, PublishBlockedError, SiteConflictError, brandDisplayName, checkContrast, checkHtmlOutline, checkPage, checkRelease, checkSiteDoc, contrastRatio, createMemorySiteStore, formCacheTag, hexToHslTriplet, isConflict, isPublishable, isSiteBrand, luminance, migrateNode, migratePage, migrateSite, mix, parseHex, prepareRelease, siteCacheTag, siteTheme, stableHash, themeCss, toCanonicalBrand, withCacheInvalidation };
-//# sourceMappingURL=chunk-GA7U3CIN.js.map
-//# sourceMappingURL=chunk-GA7U3CIN.js.map
+export { ASSET_TYPES, FONT_CHOICES, PublishBlockedError, SiteConflictError, assetPath, brandDisplayName, checkBlog, checkContrast, checkHtmlOutline, checkPage, checkPost, checkRelease, checkSiteDoc, contrastRatio, createMemorySiteStore, formCacheTag, hexToHslTriplet, isConflict, isPublishable, isSiteBrand, luminance, migrateNode, migratePage, migrateSite, mix, parseHex, prepareImportPost, prepareRelease, siteCacheTag, siteTheme, stableHash, themeCss, toCanonicalBrand, withCacheInvalidation };
+//# sourceMappingURL=chunk-FBQF2L7O.js.map
+//# sourceMappingURL=chunk-FBQF2L7O.js.map