create-avocado-site 0.9.0

package/dist/templates/sanity.js

@@ -0,0 +1,289 @@
+export function sanityTemplates(_config) {
+    return [
+        { path: "lib/sanity.client.ts", content: SANITY_CLIENT },
+        { path: "lib/sanity.queries.ts", content: SANITY_QUERIES },
+        { path: "lib/sanity.image.ts", content: SANITY_IMAGE },
+        { path: "lib/sanity.utils.ts", content: SANITY_UTILS },
+        { path: "lib/sanity.fetch.ts", content: SANITY_FETCH },
+        { path: "lib/publish.ts", content: SANITY_PUBLISH },
+    ];
+}
+const SANITY_CLIENT = `import { createClient } from "@sanity/client"
+
+const projectId = process.env.NEXT_PUBLIC_SANITY_PROJECT_ID
+if (!projectId) throw new Error("NEXT_PUBLIC_SANITY_PROJECT_ID is required")
+const dataset = process.env.NEXT_PUBLIC_SANITY_DATASET ?? "production"
+const apiVersion = "2024-01-01"
+
+export const client = createClient({
+  projectId, dataset, apiVersion,
+  useCdn: process.env.NODE_ENV === "production",
+})
+
+export const writeClient = createClient({
+  projectId, dataset, apiVersion,
+  useCdn: false,
+  token: process.env.SANITY_API_TOKEN,
+})
+`;
+const SANITY_QUERIES = `import groq from "groq"
+
+export const pageBySlugQuery = groq\`
+  *[_type == "page" && slug.current == $slug][0] {
+    _id, title, "slug": slug.current, pageId,
+    blocks[]-> { _id, _type, ..., "cards": cards[]-> { ... } },
+    meta, _updatedAt
+  }
+\`
+
+export const allSlugsQuery = groq\`
+  *[_type == "page"] { "slug": slug.current }
+\`
+
+export const allPagesQuery = groq\`
+  *[_type == "page"] {
+    _id, title, "slug": slug.current, pageId,
+    blocks[]-> { _id, _type, ..., "cards": cards[]-> { ... } },
+    meta, _updatedAt
+  }
+\`
+
+export const siteConfigQuery = groq\`
+  *[_type == "siteConfig"][0] { name, logo, navLabels }
+\`
+`;
+const SANITY_IMAGE = `import imageUrlBuilder from "@sanity/image-url"
+import { client } from "./sanity.client"
+
+const builder = imageUrlBuilder(client)
+
+export function sanityImageUrl(source: unknown): string {
+  if (!source || typeof source !== "object") return ""
+  const ref = source as { _type?: string; asset?: { _ref?: string } }
+  if (ref._type !== "image" || !ref.asset?._ref) return ""
+  return builder.image(source).auto("format").url()
+}
+`;
+const SANITY_UTILS = `export { blockTypeToCamel as toSanityName, camelToBlockType as sanityNameToBlockType } from "@avocadostudio-ai/shared"
+
+export const REFERENCE_LISTS: Record<string, Set<string>> = {
+  CardGrid: new Set(["cards"]),
+}
+`;
+const SANITY_FETCH = `import { client } from "./sanity.client"
+import { pageBySlugQuery, allSlugsQuery, allPagesQuery, siteConfigQuery } from "./sanity.queries"
+import { sanityImageUrl } from "./sanity.image"
+import { sanityNameToBlockType } from "./sanity.utils"
+import { imageFields, listImageFields } from "./manifest"
+import type { PageDoc, SiteConfig, BlockInstance } from "@avocadostudio-ai/shared"
+
+function sanityDocToBlock(doc: Record<string, unknown>): BlockInstance | null {
+  const type = doc._type as string | undefined
+  if (!type) return null
+  const blockType = sanityNameToBlockType(type)
+  const imgFields = imageFields.get(blockType) ?? new Set<string>()
+  const listImgFields = listImageFields.get(blockType) ?? new Map<string, Set<string>>()
+
+  const props: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(doc)) {
+    if (key.startsWith("_")) continue
+    if (value === null || value === undefined) continue
+    if (imgFields.has(key)) {
+      props[key] = sanityImageUrl(value)
+    } else if (listImgFields.has(key) && Array.isArray(value)) {
+      const itemImageKeys = listImgFields.get(key)!
+      props[key] = value.map((item: Record<string, unknown>) => {
+        const resolved: Record<string, unknown> = {}
+        for (const [ik, iv] of Object.entries(item)) {
+          if (ik.startsWith("_")) continue
+          resolved[ik] = itemImageKeys.has(ik) ? sanityImageUrl(iv) : iv
+        }
+        return resolved
+      })
+    } else {
+      props[key] = value
+    }
+  }
+  return { id: ((doc._id as string) ?? "").replace(/^block-/, ""), type: blockType, props }
+}
+
+function sanityDocToPageDoc(doc: Record<string, unknown>): PageDoc | null {
+  const slug = doc.slug as string | undefined
+  if (!slug) return null
+  const rawBlocks = doc.blocks as Record<string, unknown>[] | undefined
+  const blocks: BlockInstance[] = []
+  if (Array.isArray(rawBlocks)) {
+    for (const raw of rawBlocks) {
+      const block = sanityDocToBlock(raw)
+      if (block) blocks.push(block)
+    }
+  }
+  return {
+    id: (doc.pageId as string) ?? (doc._id as string) ?? "",
+    slug, title: (doc.title as string) ?? "", blocks,
+    meta: (doc.meta ?? undefined) as PageDoc["meta"],
+    updatedAt: (doc._updatedAt as string) ?? new Date().toISOString(),
+  }
+}
+
+export async function getSanityPage(slug: string): Promise<PageDoc | null> {
+  const doc = await client.fetch<Record<string, unknown> | null>(pageBySlugQuery, { slug })
+  return doc ? sanityDocToPageDoc(doc) : null
+}
+
+export async function getSanitySlugs(): Promise<string[]> {
+  const docs = await client.fetch<Array<{ slug: string }>>(allSlugsQuery)
+  return docs.map((d) => d.slug).filter(Boolean)
+}
+
+export async function getSanityPages(): Promise<PageDoc[]> {
+  const docs = await client.fetch<Array<Record<string, unknown>>>(allPagesQuery)
+  return docs.map(sanityDocToPageDoc).filter((p): p is PageDoc => p !== null)
+}
+
+export async function getSanitySiteConfig(): Promise<SiteConfig> {
+  const doc = await client.fetch<Record<string, unknown> | null>(siteConfigQuery)
+  if (!doc) return {}
+  const rawLabels = doc.navLabels as Array<{ slug?: string; label?: string }> | undefined
+  const navLabels = Array.isArray(rawLabels) && rawLabels.length > 0
+    ? Object.fromEntries(rawLabels.filter((l) => l.slug && l.label).map((l) => [l.slug!, l.label!]))
+    : undefined
+  return {
+    name: (doc.name as string) || undefined,
+    logo: (doc.logo as string) || undefined,
+    navLabels,
+  }
+}
+`;
+const SANITY_PUBLISH = `import type { OnPublishFn } from "@avocadostudio-ai/site-sdk/routes"
+import { createImageResolver } from "@avocadostudio-ai/site-sdk/routes"
+import { writeClient } from "./sanity.client"
+import { toSanityName, REFERENCE_LISTS } from "./sanity.utils"
+import { imageFields, listImageFields } from "./manifest"
+
+type SanityImageRef = { _type: "image"; asset: { _type: "reference"; _ref: string } }
+
+async function resolveImageFields(
+  item: Record<string, unknown>,
+  imageKeys: Set<string>,
+  existing: Record<string, unknown> | undefined,
+  resolver: { resolve: (url: string) => Promise<SanityImageRef | null> },
+): Promise<Record<string, unknown>> {
+  const out: Record<string, unknown> = {}
+  for (const [k, v] of Object.entries(item)) {
+    if (imageKeys.has(k) && typeof v === "string" && v) {
+      const ref = await resolver.resolve(v)
+      out[k] = ref ?? existing?.[k] ?? undefined
+    } else {
+      out[k] = v
+    }
+  }
+  return out
+}
+
+async function fetchExistingDocs(ids: string[]): Promise<Map<string, Record<string, unknown>>> {
+  const result = new Map<string, Record<string, unknown>>()
+  if (ids.length === 0) return result
+  try {
+    const docs = await writeClient.fetch<Array<Record<string, unknown>>>(\`*[_id in $ids]\`, { ids })
+    for (const doc of docs) result.set(doc._id as string, doc)
+  } catch { /* first publish */ }
+  return result
+}
+
+export function createSanityPublishHandler(): OnPublishFn {
+  return async (pages, config, context) => {
+    const imageResolver = createImageResolver<SanityImageRef>(
+      async (bytes, fileName, mimeType) => {
+        const asset = await writeClient.assets.upload("image", bytes, { filename: fileName, contentType: mimeType })
+        return { _type: "image" as const, asset: { _type: "reference" as const, _ref: asset._id } }
+      },
+      context?.assets,
+    )
+    const tx = writeClient.transaction()
+
+    for (const page of pages) {
+      const docIds: string[] = []
+      for (const block of page.blocks) {
+        const blockId = \`block-\${block.id}\`.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 128)
+        docIds.push(blockId)
+        const refLists = REFERENCE_LISTS[block.type]
+        if (refLists) {
+          for (const [key, value] of Object.entries(block.props)) {
+            if (refLists.has(key) && Array.isArray(value)) {
+              for (let i = 0; i < value.length; i++) {
+                docIds.push(\`card-\${blockId}-\${i}\`.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 128))
+              }
+            }
+          }
+        }
+      }
+      const existingDocs = await fetchExistingDocs(docIds)
+
+      const blockRefs = await Promise.all(page.blocks.map(async (block) => {
+        const blockId = \`block-\${block.id}\`.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 128)
+        const blockType = toSanityName(block.type)
+        const imgFields = imageFields.get(block.type) ?? new Set<string>()
+        const listImgFields = listImageFields.get(block.type) ?? new Map<string, Set<string>>()
+        const refLists = REFERENCE_LISTS[block.type]
+        const existingDoc = existingDocs.get(blockId)
+        const doc: Record<string, unknown> = { _id: blockId, _type: blockType }
+
+        for (const [key, value] of Object.entries(block.props)) {
+          if (key === "headingLevel") continue
+          if (imgFields.has(key) && typeof value === "string" && value) {
+            const imageRef = await imageResolver.resolve(value)
+            doc[key] = imageRef ?? existingDoc?.[key] ?? undefined
+          } else if (refLists?.has(key) && Array.isArray(value)) {
+            const itemImageKeys = listImgFields.get(key) ?? new Set<string>()
+            const cardRefs = await Promise.all(
+              (value as Record<string, unknown>[]).map(async (item, idx) => {
+                const cardId = \`card-\${blockId}-\${idx}\`.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 128)
+                const fields = await resolveImageFields(item, itemImageKeys, existingDocs.get(cardId), imageResolver)
+                tx.createOrReplace({ _id: cardId, _type: "card", ...fields } as { _id: string; _type: string; [key: string]: unknown })
+                return { _type: "reference" as const, _ref: cardId, _key: \`card-\${idx}\` }
+              })
+            )
+            doc[key] = cardRefs
+          } else if (listImgFields.has(key) && Array.isArray(value)) {
+            const itemImageKeys = listImgFields.get(key)!
+            const existingItems = existingDoc?.[key] as Record<string, unknown>[] | undefined
+            doc[key] = await Promise.all(
+              (value as Record<string, unknown>[]).map(async (item, idx) => ({
+                _key: \`item-\${idx}\`,
+                ...await resolveImageFields(item, itemImageKeys, existingItems?.[idx], imageResolver),
+              }))
+            )
+          } else {
+            doc[key] = value
+          }
+        }
+        tx.createOrReplace(doc as { _id: string; _type: string; [key: string]: unknown })
+        return { _type: "reference" as const, _ref: blockId, _key: block.id }
+      }))
+
+      const pageId = \`page-\${page.slug}\`.replace(/[^a-zA-Z0-9._-]/g, "-")
+      tx.createOrReplace({
+        _id: pageId, _type: "page",
+        slug: { _type: "slug", current: page.slug },
+        title: page.title, pageId: page.id, blocks: blockRefs,
+        ...(page.meta ? { meta: page.meta } : {}),
+      })
+    }
+
+    if (config.name || config.logo || config.navLabels) {
+      tx.createOrReplace({
+        _id: "siteConfig", _type: "siteConfig",
+        name: config.name ?? "", logo: config.logo ?? "", navLabels: config.navLabels ?? {},
+      })
+    }
+
+    try {
+      await tx.commit()
+      return { ok: true }
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : "Sanity transaction failed" }
+    }
+  }
+}
+`;

package/dist/templates/static.d.ts

@@ -0,0 +1,2 @@
+import type { GeneratedFile, ScaffoldConfig } from "../types.js";
+export declare function staticTemplates(_config: ScaffoldConfig): GeneratedFile[];

package/dist/templates/static.js

@@ -0,0 +1,81 @@
+import { DEMO_PAGES_JSON, DEMO_SITE_CONFIG_JSON } from "./demo-content.js";
+/*
+ * A scaffolded project opens on the Avocado Hub — nine pages, sixty blocks,
+ * every built-in renderer represented.
+ *
+ * It used to open on one Hero block reading "Welcome to your site", with
+ * `ctaHref: "#"` and `imageAlt: "Hero image"`. That is a defensible starter for
+ * somebody who already knows what they are building, and it is the wrong first
+ * thing to show anybody else: the product's whole claim is that you edit a real
+ * site by talking to it, and a single placeholder block gives a new user nothing
+ * to talk about. It also shipped two of the defects the demo seed test exists to
+ * catch — a link that goes nowhere and alt text that describes nothing.
+ *
+ * Both files are generated by scripts/sync-demo-seed.mjs from the same source as
+ * the editor's demo seed, so the three cannot drift apart.
+ */
+/**
+ * One module both the pages and the editor API read through.
+ *
+ * They used to be separate: the page inlined its own `readFile` and the editor
+ * route was scaffolded with `getPages: () => Promise.resolve([])` — a literal
+ * empty array. So `GET /api/editor/pages` answered with nothing while the site
+ * rendered nine pages, and the editor opened on a site with no content in it
+ * while the preview beside it showed the content. Two sources for one file is
+ * how that happens; this is the one source.
+ */
+function contentLib() {
+    return `import { readFile } from "node:fs/promises"
+import { resolve } from "node:path"
+import type { PageDoc, SiteConfig } from "@avocadostudio-ai/shared"
+
+const PAGES_PATH = resolve(process.cwd(), "content/pages.json")
+const SITE_PATH = resolve(process.cwd(), "content/site.json")
+
+/*
+ * Read on every call rather than cached at module load. Publishing rewrites
+ * content/pages.json in place, and a module-level cache would keep serving the
+ * content from before the publish until the dev server happened to restart.
+ */
+export async function getPages(): Promise<PageDoc[]> {
+  try {
+    return JSON.parse(await readFile(PAGES_PATH, "utf-8")) as PageDoc[]
+  } catch {
+    return []
+  }
+}
+
+export async function getPage(slug: string): Promise<PageDoc | null> {
+  const pages = await getPages()
+  return pages.find((page) => page.slug === slug) ?? null
+}
+
+export async function getSlugs(): Promise<string[]> {
+  return (await getPages()).map((page) => page.slug)
+}
+
+/*
+ * The site name, logo and navigation — including which pages are grouped under
+ * which dropdown. Without it the header falls back to one flat link per page,
+ * which on a nine-page site is the wrong shape.
+ */
+export async function getSiteConfig(): Promise<SiteConfig> {
+  try {
+    return JSON.parse(await readFile(SITE_PATH, "utf-8")) as SiteConfig
+  } catch {
+    // Every field of SiteConfig is optional, so this is a real config that
+    // says nothing — not a null the caller has to handle. Returning
+    // \`undefined\` here typechecks under \`next dev\`, which does not run tsc,
+    // and fails \`next build\` with a wall of structural-mismatch output.
+    return {}
+  }
+}
+`;
+}
+export function staticTemplates(_config) {
+    return [
+        { path: "content/pages.json", content: DEMO_PAGES_JSON },
+        { path: "content/site.json", content: DEMO_SITE_CONFIG_JSON },
+        { path: "lib/content.ts", content: contentLib() },
+    ];
+}

package/dist/templates/strapi.d.ts

@@ -0,0 +1,2 @@
+import type { GeneratedFile, ScaffoldConfig } from "../types.js";
+export declare function strapiTemplates(_config: ScaffoldConfig): GeneratedFile[];

package/dist/templates/strapi.js

@@ -0,0 +1,235 @@
+export function strapiTemplates(_config) {
+    return [
+        { path: "lib/strapi.client.ts", content: STRAPI_CLIENT },
+        { path: "lib/strapi.fetch.ts", content: STRAPI_FETCH },
+        { path: "lib/publish.ts", content: STRAPI_PUBLISH },
+    ];
+}
+const STRAPI_CLIENT = `const STRAPI_URL = process.env.STRAPI_URL?.trim().replace(/\\/+$/, "")
+if (!STRAPI_URL) throw new Error("STRAPI_URL is required")
+const STRAPI_TOKEN = process.env.STRAPI_API_TOKEN?.trim()
+
+export { STRAPI_URL }
+
+export async function strapiFetch<T = unknown>(path: string, options?: RequestInit): Promise<T> {
+  const url = \`\${STRAPI_URL}/api\${path}\`
+  const res = await fetch(url, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...(STRAPI_TOKEN ? { Authorization: \`Bearer \${STRAPI_TOKEN}\` } : {}),
+      ...options?.headers,
+    },
+  })
+  if (!res.ok) {
+    const body = await res.text().catch(() => "")
+    throw new Error(\`Strapi \${res.status} \${res.statusText}: \${body.slice(0, 200)}\`)
+  }
+  const text = await res.text()
+  if (!text) return undefined as T
+  return JSON.parse(text) as T
+}
+`;
+const STRAPI_FETCH = `import { strapiFetch, STRAPI_URL } from "./strapi.client"
+import { lowerToBlockType } from "@avocadostudio-ai/shared"
+import { imageFields } from "./manifest"
+import type { PageDoc, SiteConfig, BlockInstance } from "@avocadostudio-ai/shared"
+
+type StrapiResponse<T> = { data: T; meta?: unknown }
+type StrapiItem = { id: number; documentId: string; [key: string]: unknown }
+
+function resolveMediaUrl(field: unknown): string {
+  if (!field || typeof field !== "object") return ""
+  const media = field as { url?: string; formats?: { large?: { url?: string } } }
+  const url = media.formats?.large?.url ?? media.url
+  if (!url) return ""
+  return url.startsWith("http") ? url : \`\${STRAPI_URL}\${url}\`
+}
+
+function dzComponentToBlock(entry: Record<string, unknown>, index: number): BlockInstance | null {
+  const component = entry.__component as string | undefined
+  if (!component?.startsWith("blocks.")) return null
+  const rawName = component.replace("blocks.", "")
+  const blockType = lowerToBlockType(rawName)
+  const imgFields = imageFields.get(blockType) ?? new Set<string>()
+  const props: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(entry)) {
+    if (key === "id" || key === "__component") continue
+    if (value === null || value === undefined) continue
+    props[key] = imgFields.has(key) ? resolveMediaUrl(value) : value
+  }
+  return { id: entry.id ? \`\${entry.id}-\${index}\` : String(index), type: blockType, props }
+}
+
+function strapiEntryToPageDoc(entry: StrapiItem): PageDoc | null {
+  const slug = entry.slug as string | undefined
+  if (!slug) return null
+  const rawBlocks = entry.blocks as Array<Record<string, unknown>> | undefined
+  const blocks: BlockInstance[] = []
+  if (Array.isArray(rawBlocks)) {
+    for (let i = 0; i < rawBlocks.length; i++) {
+      const block = dzComponentToBlock(rawBlocks[i], i)
+      if (block) blocks.push(block)
+    }
+  }
+  return {
+    id: (entry.pageId as string) ?? entry.documentId ?? String(entry.id),
+    slug, title: (entry.title as string) ?? "", blocks,
+    meta: (entry.pageMeta as PageDoc["meta"]) ?? undefined,
+    updatedAt: (entry.updatedAt as string) ?? new Date().toISOString(),
+  }
+}
+
+export async function getStrapiPage(slug: string): Promise<PageDoc | null> {
+  try {
+    const res = await strapiFetch<StrapiResponse<StrapiItem[]>>(
+      \`/pages?filters[slug][$eq]=\${encodeURIComponent(slug)}&populate[blocks][populate]=*\`
+    )
+    if (!res.data || res.data.length === 0) return null
+    return strapiEntryToPageDoc(res.data[0])
+  } catch { return null }
+}
+
+export async function getStrapiSlugs(): Promise<string[]> {
+  try {
+    const res = await strapiFetch<StrapiResponse<StrapiItem[]>>("/pages?fields[0]=slug&pagination[pageSize]=100")
+    return res.data.map((item) => item.slug as string).filter(Boolean)
+  } catch { return [] }
+}
+
+export async function getStrapiPages(): Promise<PageDoc[]> {
+  try {
+    const res = await strapiFetch<StrapiResponse<StrapiItem[]>>(
+      "/pages?populate[blocks][populate]=*&pagination[pageSize]=100"
+    )
+    return res.data.map(strapiEntryToPageDoc).filter((p): p is PageDoc => p !== null)
+  } catch { return [] }
+}
+
+export async function getStrapiSiteConfig(): Promise<SiteConfig> {
+  try {
+    const res = await strapiFetch<StrapiResponse<StrapiItem>>("/site-config?populate=*")
+    if (!res.data) return {}
+    return {
+      name: (res.data.name as string) || undefined,
+      logo: (res.data.logo as string) || undefined,
+      navLabels: (res.data.navLabels as Record<string, string>) || undefined,
+    }
+  } catch { return {} }
+}
+`;
+const STRAPI_PUBLISH = `import type { OnPublishFn } from "@avocadostudio-ai/site-sdk/routes"
+import { createImageResolver } from "@avocadostudio-ai/site-sdk/routes"
+import { strapiFetch, STRAPI_URL } from "./strapi.client"
+import { imageFields } from "./manifest"
+
+function isStrapiUrl(url: string): boolean {
+  try { return new URL(url).origin === new URL(STRAPI_URL).origin } catch { return false }
+}
+
+async function findStrapiMediaByUrl(imageUrl: string): Promise<number | null> {
+  try {
+    const urlPath = new URL(imageUrl).pathname
+    const headers: Record<string, string> = { "Content-Type": "application/json" }
+    if (process.env.STRAPI_API_TOKEN) headers.Authorization = \`Bearer \${process.env.STRAPI_API_TOKEN}\`
+    const res = await fetch(
+      \`\${STRAPI_URL}/api/upload/files?filters[url][$eq]=\${encodeURIComponent(urlPath)}\`,
+      { headers }
+    )
+    if (!res.ok) return null
+    const data = (await res.json()) as Array<{ id: number }>
+    return data[0]?.id ?? null
+  } catch { return null }
+}
+
+async function uploadToStrapiMedia(blob: Blob, fileName: string): Promise<number | null> {
+  const form = new FormData()
+  form.append("files", blob, fileName)
+  const res = await fetch(\`\${STRAPI_URL}/api/upload\`, {
+    method: "POST",
+    headers: { ...(process.env.STRAPI_API_TOKEN ? { Authorization: \`Bearer \${process.env.STRAPI_API_TOKEN}\` } : {}) },
+    body: form,
+  })
+  if (!res.ok) return null
+  const uploaded = (await res.json()) as Array<{ id: number }>
+  return uploaded[0]?.id ?? null
+}
+
+export function createStrapiPublishHandler(): OnPublishFn {
+  return async (pages, config, context) => {
+    const imageResolver = createImageResolver<number>(
+      async (bytes, fileName) => uploadToStrapiMedia(new Blob([bytes]), fileName),
+      context?.assets,
+    )
+    const errors: string[] = []
+
+    async function resolveMediaId(imageUrl: string): Promise<number | null> {
+      if (!imageUrl.startsWith("http") && imageUrl.startsWith("/")) {
+        return findStrapiMediaByUrl(\`\${STRAPI_URL}\${imageUrl}\`)
+      }
+      if (isStrapiUrl(imageUrl)) return findStrapiMediaByUrl(imageUrl)
+      return imageResolver.resolve(imageUrl)
+    }
+
+    for (const page of pages) {
+      try {
+        const existing = await strapiFetch<{ data: Array<{ documentId: string; blocks?: Array<Record<string, unknown>> }> }>(
+          \`/pages?filters[slug][$eq]=\${encodeURIComponent(page.slug)}&populate[blocks][populate]=*\`
+        )
+        const existingBlocks = existing.data[0]?.blocks as Array<Record<string, unknown>> | undefined
+
+        const dzBlocks = await Promise.all(page.blocks.map(async (block, blockIndex) => {
+          const imgFields = imageFields.get(block.type) ?? new Set<string>()
+          const data: Record<string, unknown> = { __component: \`blocks.\${block.type.toLowerCase()}\` }
+          for (const [key, value] of Object.entries(block.props)) {
+            if (key === "headingLevel") continue
+            if (imgFields.has(key) && typeof value === "string" && value) {
+              const mediaId = await resolveMediaId(value)
+              if (mediaId) { data[key] = mediaId }
+              else {
+                const em = existingBlocks?.[blockIndex]?.[key]
+                const emId = em && typeof em === "object" && !Array.isArray(em)
+                  ? (em as Record<string, unknown>).id as number | undefined : undefined
+                if (emId) data[key] = emId
+              }
+            } else { data[key] = value }
+          }
+          return data
+        }))
+
+        const pageData = {
+          slug: page.slug, title: page.title, pageId: page.id, blocks: dzBlocks,
+          ...(page.meta ? { pageMeta: page.meta } : {}),
+        }
+
+        if (existing.data.length > 0) {
+          await strapiFetch(\`/pages/\${existing.data[0].documentId}\`, { method: "PUT", body: JSON.stringify({ data: pageData }) })
+        } else {
+          await strapiFetch("/pages", { method: "POST", body: JSON.stringify({ data: pageData }) })
+        }
+      } catch (err) {
+        errors.push(\`\${page.slug}: \${err instanceof Error ? err.message : String(err)}\`)
+      }
+    }
+
+    if (config.name || config.logo || config.navLabels) {
+      try {
+        await strapiFetch("/site-config", {
+          method: "PUT",
+          body: JSON.stringify({ data: { name: config.name ?? "", logo: config.logo ?? "", navLabels: config.navLabels ?? {} } }),
+        })
+      } catch {
+        try {
+          await strapiFetch("/site-config", {
+            method: "POST",
+            body: JSON.stringify({ data: { name: config.name ?? "", logo: config.logo ?? "", navLabels: config.navLabels ?? {} } }),
+          })
+        } catch { /* optional */ }
+      }
+    }
+
+    if (errors.length > 0) return { ok: false, error: \`Failed: \${errors.join("; ")}\` }
+    return { ok: true }
+  }
+}
+`;

package/dist/types.d.ts

@@ -0,0 +1,48 @@
+export type CmsChoice = "sanity" | "contentful" | "strapi" | "none";
+export type BlocksMode = "default" | "custom";
+/**
+ * What the CLI was asked to do.
+ *
+ * `demo` creates a whole runnable project — package.json, Next config, layout,
+ * an orchestrator mounted in-process — and installs it. `integrate` writes
+ * wiring into a Next.js app that already exists, which is what this scaffolder
+ * did exclusively before, and leaves that app's own package.json, config and
+ * layout alone.
+ */
+export type ScaffoldMode = "demo" | "integrate";
+export type ScaffoldConfig = {
+    mode: ScaffoldMode;
+    cms: CmsChoice;
+    siteId: string;
+    blocksMode: BlocksMode;
+    /**
+     * Next.js major version of the target project. Decides whether the
+     * request rewrite is scaffolded as `proxy.ts` (16+) or `middleware.ts`.
+     * `undefined` when detection failed — treated as pre-16.
+     *
+     * Unused in `demo` mode, which pins its own Next and needs neither file:
+     * the orchestrator is mounted in the app, so there is nothing to rewrite to.
+     */
+    nextMajor?: number;
+    /** Port the Next app listens on. Demo mode only. */
+    sitePort: number;
+    /** Port the editor UI is served on. Demo mode only. */
+    editorPort: number;
+    /**
+     * Value written as `DRAFT_MODE_SECRET`. Generated per scaffold rather than
+     * fixed, so two demos on one machine do not share a draft cookie secret.
+     */
+    draftSecret: string;
+};
+export type GeneratedFile = {
+    path: string;
+    /** Text to write. Omit when `source` is set. */
+    content?: string;
+    /**
+     * Absolute path to copy bytes from, for the files that are not text: the
+     * demo's logo and its eleven images. They travel with the package rather
+     * than being generated, and a scaffold without them renders a broken logo on
+     * every page.
+     */
+    source?: string;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};