create-avocado-site 0.9.0

package/dist/templates/common.js

@@ -0,0 +1,174 @@
+import { CMS_CONFIGS } from "../cms-config.js";
+export function editorApiRoute(config) {
+    const c = CMS_CONFIGS[config.cms];
+    return `import { createEditorApiHandler } from "@avocadostudio-ai/site-sdk/routes"
+${c.publishImport}
+${c.getPagesImport ? c.getPagesImport + "\n" : ""}
+export const { GET, POST, OPTIONS } = createEditorApiHandler({
+  getPages: ${c.getPages},
+  publishSecret: process.env.PUBLISH_TOKEN?.trim() || undefined,
+  onPublish: ${c.onPublish},
+})
+`;
+}
+export function revalidateRoute(config) {
+    const c = CMS_CONFIGS[config.cms];
+    if (!c.revalidate)
+        return null;
+    const r = c.revalidate;
+    const headerLine = r.secretHeader
+        ? `  secretHeader: ${r.secretHeader},\n`
+        : "";
+    return `import { createRevalidateHandler } from "@avocadostudio-ai/site-sdk/routes"
+${r.getPagesImport}
+
+export const POST = createRevalidateHandler({
+  secretEnvVar: "${r.secretEnvVar}",
+${headerLine}  extractSlug: ${r.extractSlug},
+  getPages: ${r.getPagesFn},
+  siteId: "${config.siteId}",
+})
+`;
+}
+export function manifestFile(config) {
+    if (config.blocksMode === "custom") {
+        return `import type { BlockManifest } from "@avocadostudio-ai/shared"
+import { getManifestImageFields } from "@avocadostudio-ai/site-sdk/routes"
+
+const manifest: BlockManifest = {
+  version: 1,
+  blocks: [
+    // {
+    //   type: "Hero",
+    //   displayName: "Hero Section",
+    //   propsSchema: {
+    //     type: "object",
+    //     properties: {
+    //       heading: { type: "string" },
+    //       imageUrl: { type: "string" },
+    //     },
+    //     required: ["heading"],
+    //   },
+    //   defaultProps: { heading: "Welcome" },
+    // },
+  ],
+}
+
+export function getManifest() { return manifest }
+export const { imageFields, listImageFields, listFieldNames } = getManifestImageFields(manifest)
+`;
+    }
+    return `import { buildBlockManifest } from "@avocadostudio-ai/site-sdk/editor-manifest"
+import { getManifestImageFields } from "@avocadostudio-ai/site-sdk/routes"
+
+export const { imageFields, listImageFields, listFieldNames } = getManifestImageFields(buildBlockManifest())
+`;
+}
+function adjustImportDepth(pageImport, mode) {
+    // CMS config encodes import paths for the single-route layout
+    // (`app/[[...slug]]/page.tsx`). The preview page lives one directory deeper
+    // (`app/preview-draft/[[...slug]]/page.tsx`), so prefix one extra `../` on
+    // every relative import. "auto" and "static" share the shallower depth.
+    if (mode !== "preview")
+        return pageImport;
+    return pageImport.replace(/from "\.\.\//g, `from "../../`);
+}
+export function pageFile(config, mode = "static") {
+    const c = CMS_CONFIGS[config.cms];
+    const pageImport = adjustImportDepth(c.pageImport, mode);
+    // `generateStaticParams` is returned in every mode but is meaningless in the
+    // two dynamic ones, and exporting it from a `force-dynamic` route is a
+    // contradiction Next does not report.
+    const staticParams = mode === "static";
+    const factoryReturn = staticParams ? "{ Page, generateStaticParams, generateMetadata }" : "{ Page, generateMetadata }";
+    const dynamicLine = mode === "preview" ? `\nexport const dynamic = "force-dynamic"\n` : "";
+    const exports = staticParams
+        ? "\nexport default Page\nexport { generateStaticParams, generateMetadata }\n"
+        : "\nexport default Page\nexport { generateMetadata }\n";
+    return `import { createSitePage } from "@avocadostudio-ai/site-sdk/page"
+${pageImport}
+${dynamicLine}
+const ${factoryReturn} = createSitePage({
+  mode: "${mode}",
+  siteId: "${config.siteId}",
+  getPage: ${c.getPage},
+  getSlugs: ${c.getSlugs},${c.getSiteConfig ? `\n  getSiteConfig: ${c.getSiteConfig},` : ""}
+})${exports}`;
+}
+/**
+ * `createSitePage` calls `notFound()` for an unknown slug, which renders this
+ * file with a real 404 status. Without it Next falls back to its own bare
+ * default page — correct status, but none of the site's chrome.
+ */
+export function notFoundFile() {
+    return `export default function NotFound() {
+  return (
+    <main style={{ padding: "4rem", textAlign: "center" }}>
+      <h1>404</h1>
+      <p>Page not found.</p>
+    </main>
+  )
+}
+`;
+}
+/** Next.js 15 and earlier: the rewrite lives in `middleware.ts`. */
+export function middlewareFile() {
+    return `import { createEditorMiddleware } from "@avocadostudio-ai/site-sdk/middleware"
+
+export const { middleware, config } = createEditorMiddleware()
+`;
+}
+/**
+ * Next.js 16+: `middleware` was renamed to the `proxy` convention, and `config`
+ * must be a static object literal — Next 16 reads it by static analysis and
+ * rejects a factory return value or an imported constant.
+ */
+export function proxyFile() {
+    return `import { createEditorProxy } from "@avocadostudio-ai/site-sdk/proxy"
+
+export const proxy = createEditorProxy().proxy
+
+// Must stay a literal — Next.js 16 cannot read \`config\` from a factory result.
+export const config = {
+  matcher: [
+    "/((?!_next|preview-draft|api|favicon\\\\.ico|icon\\\\.svg|logos/|generated-images/|.*\\\\.).*)",
+  ],
+}
+`;
+}
+/**
+ * The integrate path's `.env.local.example`.
+ *
+ * It used to contradict the instructions printed beside it. Step 4 mounts the
+ * orchestrator inside the app at `/api/avocado` — there is no separate service
+ * — while this file set `ORCHESTRATOR_URL=http://localhost:4200`, pointing at
+ * the standalone server the integrator was never told to run. The env var
+ * wins, so every draft read went to a port with nothing on it and the editor
+ * showed published content with the edits silently dropped.
+ *
+ * `DRAFT_MODE_SECRET` was likewise pre-filled with `dev-secret` next to a step
+ * saying to set it to a long random string; it is generated now, as on the
+ * demo path.
+ */
+export function envExample(config) {
+    const c = CMS_CONFIGS[config.cms];
+    const common = `# The orchestrator runs inside this app, at /api/avocado. There is no separate
+# service to start — this must name this app's own origin, not port 4200.
+ORCHESTRATOR_URL=http://localhost:${config.sitePort}/api/avocado
+
+# Where the editor is served from. Named twice on every request — CORS on the
+# editor API and \`frame-ancestors\` on the preview — and \`withAvocado\` derives
+# both from this one variable. Get it wrong and the site reads as offline while
+# the preview stays a blank rectangle, neither of which mentions a port.
+EDITOR_CORS_ORIGINS=http://localhost:${config.editorPort}
+
+# Any long random string; this one was generated for you. Without it draft mode
+# does not work, and the editor quietly renders the published page instead of
+# your edits.
+DRAFT_MODE_SECRET=${config.draftSecret}
+
+# Optional: protects the publish endpoint.
+# PUBLISH_TOKEN=
+`;
+    return c.envVars ? `${c.envVars}\n\n${common}` : common;
+}

package/dist/templates/contentful.d.ts

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

package/dist/templates/contentful.js

@@ -0,0 +1,379 @@
+export function contentfulTemplates(_config) {
+    return [
+        { path: "lib/contentful.ts", content: CONTENTFUL_ADAPTER },
+        { path: "lib/publish.ts", content: CONTENTFUL_PUBLISH },
+    ];
+}
+const CONTENTFUL_ADAPTER = `import { createClient, type Entry, type Asset } from "contentful"
+import { imageFields, listImageFields } from "./manifest"
+import type { PageDoc, SiteConfig, BlockInstance } from "@avocadostudio-ai/shared"
+
+let cachedClient: ReturnType<typeof createClient> | null = null
+
+function getClient() {
+  if (cachedClient) return cachedClient
+  const spaceId = process.env.CONTENTFUL_SPACE_ID
+  const accessToken = process.env.CONTENTFUL_DELIVERY_TOKEN
+  if (!spaceId || !accessToken) throw new Error("CONTENTFUL_SPACE_ID and CONTENTFUL_DELIVERY_TOKEN required")
+  cachedClient = createClient({
+    space: spaceId, accessToken,
+    environment: process.env.CONTENTFUL_ENVIRONMENT ?? "master",
+  })
+  return cachedClient
+}
+
+function assetToUrl(asset: Asset | undefined): string {
+  if (!asset?.fields?.file) return ""
+  const file = asset.fields.file as { url?: string }
+  if (!file.url) return ""
+  return file.url.startsWith("//") ? \`https:\${file.url}\` : file.url
+}
+
+function entryToBlockInstance(entry: Entry, includes?: { Asset?: Asset[] }): BlockInstance | null {
+  const contentTypeId = entry.sys.contentType?.sys?.id
+  if (!contentTypeId?.startsWith("block")) return null
+  const blockType = contentTypeId.replace(/^block/, "")
+  const imgFields = imageFields.get(blockType) ?? new Set<string>()
+  const listImgFieldsForType = listImageFields.get(blockType)
+  const props: Record<string, unknown> = {}
+  const fields = entry.fields as Record<string, unknown>
+
+  for (const [key, value] of Object.entries(fields)) {
+    if (imgFields.has(key)) {
+      const linked = value as { sys?: { id?: string } } | undefined
+      if (linked?.sys?.id && includes?.Asset) {
+        const asset = includes.Asset.find((a) => a.sys.id === linked.sys.id)
+        props[key] = assetToUrl(asset as Asset)
+      } else if (linked && typeof linked === "object" && "fields" in linked) {
+        props[key] = assetToUrl(linked as Asset)
+      } else { props[key] = "" }
+    } else if (listImgFieldsForType?.has(key) && blockType === "CardGrid" && key === "cards") {
+      const refs = value as Array<Entry | { sys: { id: string } }>
+      if (Array.isArray(refs)) {
+        props[key] = refs.map((ref) => {
+          if ("fields" in ref) {
+            const cardInstance = entryToBlockInstance(ref as Entry, includes)
+            return cardInstance?.props
+          }
+          return null
+        }).filter(Boolean)
+      } else { props[key] = [] }
+    } else { props[key] = value }
+  }
+  return { id: entry.sys.id.replace(/^block_/, ""), type: blockType, props }
+}
+
+function entryToPageDoc(page: Entry, includes?: { Asset?: Asset[] }): PageDoc | null {
+  const fields = page.fields as Record<string, unknown>
+  const slug = fields.slug as string | undefined
+  if (!slug) return null
+  const blockRefs = fields.blocks as Array<Entry | { sys: { id: string } }> | undefined
+  const blocks: BlockInstance[] = []
+  if (Array.isArray(blockRefs)) {
+    for (const ref of blockRefs) {
+      if ("fields" in ref) {
+        const block = entryToBlockInstance(ref as Entry, includes)
+        if (block) blocks.push(block)
+      }
+    }
+  }
+  return {
+    id: (fields.pageId as string) ?? page.sys.id,
+    slug, title: fields.title as string, blocks,
+    meta: fields.meta as PageDoc["meta"],
+    updatedAt: (fields.updatedAt as string) ?? page.sys.updatedAt,
+  }
+}
+
+export async function getContentfulPage(slug: string): Promise<PageDoc | null> {
+  const entries = await getClient().getEntries({ content_type: "page", "fields.slug": slug, include: 2, limit: 1 })
+  if (entries.items.length === 0) return null
+  return entryToPageDoc(entries.items[0], entries.includes as { Asset?: Asset[] })
+}
+
+export async function getContentfulSlugs(): Promise<string[]> {
+  const entries = await getClient().getEntries({ content_type: "page", select: ["fields.slug"], limit: 100 })
+  return entries.items
+    .map((item) => (item.fields as Record<string, unknown>).slug)
+    .filter((slug): slug is string => typeof slug === "string" && slug.length > 0)
+}
+
+export async function getContentfulPages(): Promise<PageDoc[]> {
+  const entries = await getClient().getEntries({ content_type: "page", include: 2, limit: 100 })
+  return entries.items
+    .map((page) => entryToPageDoc(page, entries.includes as { Asset?: Asset[] }))
+    .filter((p): p is PageDoc => p !== null)
+}
+
+export async function getContentfulSiteConfig(): Promise<SiteConfig> {
+  try {
+    const entries = await getClient().getEntries({ content_type: "siteConfig", "fields.configKey": "default", limit: 1 })
+    if (entries.items.length === 0) return {}
+    const fields = entries.items[0].fields as Record<string, unknown>
+    return {
+      name: (fields.name as string) || undefined,
+      logo: (fields.logo as string) || undefined,
+      navLabels: (fields.navLabels as Record<string, string>) || undefined,
+    }
+  } catch { return {} }
+}
+`;
+const CONTENTFUL_PUBLISH = `import type { OnPublishFn, InlineAsset } from "@avocadostudio-ai/site-sdk/routes"
+import { isSafeImageUrl } from "@avocadostudio-ai/site-sdk/routes"
+import { imageFields, listFieldNames } from "./manifest"
+
+export interface ContentfulPublishOptions {
+  spaceId: string
+  environmentId?: string
+  managementToken: string
+  locale?: string
+}
+
+export function createContentfulPublishHandler(opts: ContentfulPublishOptions): OnPublishFn {
+  const locale = opts.locale ?? "en-US"
+
+  let cachedEnvPromise: ReturnType<typeof loadEnvironment> | null = null
+
+  async function loadEnvironment() {
+    const mod = await import("contentful-management")
+    const factory = ("default" in mod && typeof (mod.default as Record<string, unknown>)?.createClient === "function")
+      ? (mod.default as { createClient: typeof mod.createClient }).createClient
+      : mod.createClient
+    const client = factory({ accessToken: opts.managementToken })
+    const space = await client.getSpace(opts.spaceId)
+    return space.getEnvironment(opts.environmentId ?? "master")
+  }
+
+  function getEnvironment() {
+    if (!cachedEnvPromise) {
+      cachedEnvPromise = loadEnvironment().catch((err) => { cachedEnvPromise = null; throw err })
+    }
+    return cachedEnvPromise
+  }
+
+  function isReferenceList(blockType: string, listKey: string): string | null {
+    if (blockType === "CardGrid" && listKey === "cards") return "blockCard"
+    return null
+  }
+
+  type CfEnv = Awaited<ReturnType<typeof loadEnvironment>>
+  type CfEntry = Awaited<ReturnType<CfEnv["getEntries"]>>["items"][0]
+
+  async function ensureAsset(
+    env: CfEnv, imageUrl: string, alt: string, assets?: Record<string, InlineAsset>
+  ): Promise<string | null> {
+    const inlineAsset = assets?.[imageUrl]
+    if (inlineAsset) {
+      try {
+        const bytes = Buffer.from(inlineAsset.data, "base64")
+        const upload = await env.createUpload({ file: bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer })
+        const asset = await env.createAsset({
+          fields: {
+            title: { [locale]: alt || inlineAsset.fileName },
+            description: { [locale]: imageUrl },
+            file: { [locale]: { contentType: inlineAsset.mimeType, fileName: inlineAsset.fileName, uploadFrom: { sys: { type: "Link", linkType: "Upload", id: upload.sys.id } } } },
+          },
+        })
+        const processed = await asset.processForAllLocales()
+        const published = await processed.publish()
+        return published.sys.id
+      } catch (err) {
+        console.warn(\`[contentful-publish] inline asset upload failed for \${imageUrl}: \${err instanceof Error ? err.message : err}\`)
+        return null
+      }
+    }
+
+    if (!imageUrl.startsWith("http") || !isSafeImageUrl(imageUrl)) {
+      try {
+        const asset = await env.createAsset({
+          fields: {
+            title: { [locale]: alt || imageUrl },
+            description: { [locale]: imageUrl },
+            file: { [locale]: { contentType: "image/png", fileName: imageUrl.split("/").pop() || "image.png", upload: \`https://placehold.co/800x600/e4e4e7/52525b.png?text=\${encodeURIComponent(alt || "Image")}\` } },
+          },
+        })
+        const processed = await asset.processForAllLocales()
+        const published = await processed.publish()
+        return published.sys.id
+      } catch { return null }
+    }
+
+    try {
+      const existing = await env.getAssets({ "fields.description": imageUrl, limit: 1 })
+      if (existing.items.length > 0) return existing.items[0].sys.id
+    } catch { /* continue */ }
+
+    try {
+      const ext = imageUrl.toLowerCase().split(".").pop()?.split("?")[0] ?? ""
+      const ct = ext === "png" ? "image/png" : ext === "webp" ? "image/webp" : ext === "gif" ? "image/gif" : ext === "svg" ? "image/svg+xml" : "image/jpeg"
+      const asset = await env.createAsset({
+        fields: {
+          title: { [locale]: alt || imageUrl },
+          description: { [locale]: imageUrl },
+          file: { [locale]: { contentType: ct, fileName: imageUrl.split("/").pop()?.split("?")[0] || "image.jpg", upload: imageUrl } },
+        },
+      })
+      const processed = await asset.processForAllLocales()
+      const published = await processed.publish()
+      return published.sys.id
+    } catch (err) {
+      console.warn(\`[contentful-publish] asset upload failed for \${imageUrl}: \${err instanceof Error ? err.message : err}\`)
+      return null
+    }
+  }
+
+  function assetLink(assetId: string) {
+    return { [locale]: { sys: { type: "Link", linkType: "Asset", id: assetId } } }
+  }
+
+  function entryLink(entryId: string) {
+    return { sys: { type: "Link" as const, linkType: "Entry" as const, id: entryId } }
+  }
+
+  function existingAssetId(fieldValue: unknown): string | null {
+    if (!fieldValue || typeof fieldValue !== "object") return null
+    const localeVal = (fieldValue as Record<string, unknown>)[locale]
+    if (!localeVal || typeof localeVal !== "object") return null
+    const sys = (localeVal as Record<string, unknown>).sys as { id?: string; linkType?: string } | undefined
+    return sys?.linkType === "Asset" && sys.id ? sys.id : null
+  }
+
+  async function buildBlockFields(
+    env: CfEnv, blockType: string, props: Record<string, unknown>,
+    resolveAsset: (url: string, alt: string) => Promise<string | null>,
+    existingFields?: Record<string, unknown>,
+  ): Promise<Record<string, unknown>> {
+    const imgFields = imageFields.get(blockType) ?? new Set<string>()
+    const listFieldsForType = listFieldNames.get(blockType) ?? new Set<string>()
+    const fields: Record<string, unknown> = {}
+
+    for (const [key, value] of Object.entries(props)) {
+      if (key === "headingLevel") continue
+      if (imgFields.has(key) && typeof value === "string" && value) {
+        const altKey = key.replace(/Url$/, "Alt").replace(/^image$/, "imageAlt")
+        const alt = typeof props[altKey] === "string" ? (props[altKey] as string) : ""
+        const assetId = await resolveAsset(value, alt)
+        if (assetId) { fields[key] = assetLink(assetId) }
+        else {
+          const prevAssetId = existingAssetId(existingFields?.[key])
+          if (prevAssetId) fields[key] = assetLink(prevAssetId)
+        }
+      } else if (listFieldsForType.has(key)) {
+        if (!isReferenceList(blockType, key)) { fields[key] = { [locale]: value } }
+      } else { fields[key] = { [locale]: value } }
+    }
+    return fields
+  }
+
+  return async (pages, config, context) => {
+    const env = await getEnvironment()
+    const assetCache = new Map<string, Promise<string | null>>()
+    const cachedEnsureAsset = (imageUrl: string, alt: string) => {
+      const cached = assetCache.get(imageUrl)
+      if (cached) return cached
+      const promise = ensureAsset(env, imageUrl, alt, context?.assets)
+      assetCache.set(imageUrl, promise)
+      return promise
+    }
+
+    const upsertResults = await Promise.allSettled(pages.map(async (page) => {
+      const blockEntries = await Promise.all(page.blocks.map(async (block) => {
+        const contentTypeId = \`block\${block.type}\`
+        const rawId = block.id.startsWith("block_") ? block.id : \`block_\${block.id}\`
+        const entryId = rawId.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64)
+
+        let existingEntry: CfEntry | null = null
+        try { existingEntry = await env.getEntry(entryId) } catch { /* first publish */ }
+        const existingFields = existingEntry?.fields as Record<string, unknown> | undefined
+
+        const blockFields = await buildBlockFields(env, block.type, block.props, cachedEnsureAsset, existingFields)
+
+        const blockListFields = listFieldNames.get(block.type) ?? new Set<string>()
+        for (const [key, value] of Object.entries(block.props)) {
+          const refTarget = isReferenceList(block.type, key)
+          if (refTarget && Array.isArray(value) && blockListFields.has(key)) {
+            const items = value as Record<string, unknown>[]
+            const cardRefs = await Promise.all(
+              items.map(async (item, i) => {
+                const cardEntryId = \`card_\${entryId}_\${i}\`.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64)
+                let existingCard: CfEntry | null = null
+                try { existingCard = await env.getEntry(cardEntryId) } catch { /* first publish */ }
+                const childFields = await buildBlockFields(env, "Card", item, cachedEnsureAsset,
+                  existingCard?.fields as Record<string, unknown> | undefined)
+                if (existingCard) {
+                  existingCard.fields = childFields
+                  const updated = await existingCard.update()
+                  await updated.publish()
+                } else {
+                  const created = await env.createEntryWithId(refTarget, cardEntryId, { fields: childFields })
+                  await created.publish()
+                }
+                return entryLink(cardEntryId)
+              })
+            )
+            blockFields[key] = { [locale]: cardRefs }
+            for (let i = items.length; i < items.length + 20; i++) {
+              const staleCardId = \`card_\${entryId}_\${i}\`.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64)
+              try {
+                const staleCard = await env.getEntry(staleCardId)
+                try { await staleCard.unpublish() } catch {}
+                await staleCard.delete()
+              } catch { break }
+            }
+          }
+        }
+
+        if (existingEntry) {
+          existingEntry.fields = blockFields
+          const updated = await existingEntry.update()
+          await updated.publish()
+          return entryLink(updated.sys.id)
+        } else {
+          const entry = await env.createEntryWithId(contentTypeId, entryId, { fields: blockFields })
+          await entry.publish()
+          return entryLink(entry.sys.id)
+        }
+      }))
+
+      const pageFields = {
+        slug: { [locale]: page.slug }, title: { [locale]: page.title },
+        pageId: { [locale]: page.id }, blocks: { [locale]: blockEntries },
+        meta: { [locale]: page.meta ?? null }, updatedAt: { [locale]: page.updatedAt },
+      }
+      const existingPages = await env.getEntries({ content_type: "page", "fields.slug": page.slug, limit: 1 })
+      if (existingPages.items.length > 0) {
+        const existing = existingPages.items[0]
+        existing.fields = pageFields
+        const updated = await existing.update()
+        await updated.publish()
+      } else {
+        const created = await env.createEntry("page", { fields: pageFields })
+        await created.publish()
+      }
+      return page.slug
+    }))
+
+    const failed = upsertResults
+      .filter((r): r is PromiseRejectedResult => r.status === "rejected")
+      .map((r, i) => \`\${pages[i]?.slug ?? "?"}: \${r.reason instanceof Error ? r.reason.message : String(r.reason)}\`)
+
+    if (config.name || config.logo || config.navLabels) {
+      const configFields = {
+        configKey: { [locale]: "default" }, name: { [locale]: config.name ?? "" },
+        logo: { [locale]: config.logo ?? "" }, navLabels: { [locale]: config.navLabels ?? {} },
+      }
+      const existingConfig = await env.getEntries({ content_type: "siteConfig", "fields.configKey": "default", limit: 1 })
+      let configEntry
+      if (existingConfig.items.length > 0) {
+        configEntry = existingConfig.items[0]
+        configEntry.fields = configFields
+        configEntry = await configEntry.update()
+      } else { configEntry = await env.createEntry("siteConfig", { fields: configFields }) }
+      await configEntry.publish()
+    }
+
+    if (failed.length > 0) return { ok: false, error: \`Failed to publish: \${failed.join("; ")}\` }
+    return { ok: true }
+  }
+}
+`;

package/dist/templates/demo-app.d.ts

@@ -0,0 +1,3 @@
+import type { GeneratedFile, ScaffoldConfig } from "../types.js";
+/** The files that exist only in a bootstrapped demo, on top of the shared wiring. */
+export declare function demoAppTemplates(config: ScaffoldConfig): GeneratedFile[];