create-shapio 0.2.0

package/templates/next/scripts/seed.ts

@@ -0,0 +1,396 @@
+import { readdir, readFile, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { parseArgs } from 'node:util';
+import {
+  buildUploadForm,
+  ShapioApiError,
+  type MediaAsset,
+  type SchemaApplyInput,
+  type SchemaSyncResult,
+  type ShapioClient,
+} from '@shapio/client';
+import { connectAdmin } from './lib/admin.js';
+import {
+  AUTHOR,
+  entries,
+  IMAGES,
+  SITE_SETTINGS,
+  type EntrySpec,
+  type ImageSpec,
+  type MediaIds,
+} from './lib/content.js';
+import { createPng } from './lib/png.js';
+
+/**
+ * `npm run seed`: prepares a Shapio instance for this starter, idempotently (run it again to reset the
+ * content to the seed):
+ * 1. the `fr` locale;
+ * 2. the models and components in shapio/ through the schema apply API (live, no restart; the same planner
+ *    as `shapio schema apply` and the admin);
+ * 3. placeholder images, an author, the site settings, pages and articles in English and French, published
+ *    per locale;
+ * 4. a deployment connection named "Preview" whose preview URL opens this starter's /preview/ page (the
+ *    entry document's Preview pane and visual editing; it triggers no builds). The site's URL is SITE_URL, else
+ *    the starter's `--site-url` (its local dev server);
+ * 5. with `--revalidate-path` (the Next.js starter's /api/revalidate), a webhook named "Site revalidation" that
+ *    sends publish, unpublish, delete, change set and schema events to SITE_URL + that path; its signing secret
+ *    (rotated on every run, as Shapio shows it only once) is written to .env as SHAPIO_WEBHOOK_SECRET;
+ * 6. a delivery role and token for the build, written with SHAPIO_URL to .env in the current directory.
+ */
+const SCHEMA_DIR = resolve(import.meta.dirname, '..', 'shapio');
+const SCHEMA_KINDS = ['models', 'components'] as const;
+const SITE_MODELS = ['page', 'article', 'author', 'siteSettings'];
+const DELIVERY_ROLE_KEY = 'starter-delivery';
+const DELIVERY_TOKEN_NAME = 'starter build';
+const PREVIEW_CONNECTION_NAME = 'Preview';
+/** Where Shapio opens a draft: the starter's /preview/ page, the token in the fragment (never sent to a server). */
+const PREVIEW_PATH = '/preview/?model={modelKey}&id={entryId}&locale={locale}#token={token}';
+/** A placeholder build hook: the connection has no triggers, so nothing is ever sent to it. */
+const PREVIEW_BUILD_HOOK = 'https://build.invalid/shapio-starter';
+const REVALIDATE_WEBHOOK_NAME = 'Site revalidation';
+/** The events that change what a published site shows (the starter's route ignores any others). */
+const REVALIDATE_EVENTS = [
+  'entry.published',
+  'entry.unpublished',
+  'entry.deleted',
+  'change_set.shipped',
+  'schema.activated',
+  'schema.deleted',
+];
+/** A local site needs Shapio's OUTBOUND_PRIVATE_NETWORK_ALLOWLIST too; the webhook opts in for loopback only. */
+const LOOPBACK_HOSTS = new Set(['localhost', '127.0.0.1', '[::1]']);
+const MEDIA_READY_TIMEOUT_MS = 120_000;
+const SCHEMA_CHANGE_TIMEOUT_MS = 120_000;
+const POLL_INTERVAL_MS = 500;
+/** No lock file: a first apply. Definitions that already match are skipped by the server. */
+const FIRST_APPLY_BASE: SchemaApplyInput['base'] = { formatVersion: 1, schemaVersion: 0, definitions: {} };
+
+const log = (line: string) => process.stdout.write(`${line}\n`);
+
+const ensureLocale = async (client: ShapioClient) => {
+  const locales = await client.admin.locales.list();
+  if (!locales.some((locale) => locale.code === 'fr')) {
+    await client.admin.locales.create({ code: 'fr', label: 'Français', fallbacks: ['en'] });
+    log('Created the fr locale');
+  }
+};
+
+/** The checked-in definition files (`shapio schema pull` format), models first. */
+const readDefinitions = async (): Promise<unknown[]> => {
+  const definitions: unknown[] = [];
+  for (const kind of SCHEMA_KINDS) {
+    const names = (await readdir(join(SCHEMA_DIR, kind))).filter((name) => name.endsWith('.json')).sort();
+    for (const name of names) {
+      definitions.push(JSON.parse(await readFile(join(SCHEMA_DIR, kind, name), 'utf8')));
+    }
+  }
+  return definitions;
+};
+
+/** A planned change waits for its prerequisite jobs (e.g. an index); this waits until it is live. */
+const waitForChange = async (client: ShapioClient, item: SchemaSyncResult) => {
+  const deadline = Date.now() + SCHEMA_CHANGE_TIMEOUT_MS;
+  for (;;) {
+    const change = await client.admin.schema.change(item.changeId ?? '');
+    if (change.status === 'activated') {
+      return;
+    }
+    if (change.status === 'failed' || change.status === 'cancelled') {
+      throw new Error(`The ${item.apiKey} change ${change.status}: ${JSON.stringify(change.error)}`);
+    }
+    if (Date.now() > deadline) {
+      throw new Error(`The ${item.apiKey} change is still ${change.status}; is the Shapio worker running?`);
+    }
+    await delay(POLL_INTERVAL_MS);
+  }
+};
+
+const applySchema = async (client: ShapioClient) => {
+  const response = await client.admin.schema.apply({
+    definitions: await readDefinitions(),
+    base: FIRST_APPLY_BASE,
+    prune: false,
+    dryRun: false,
+    acknowledgeBreaking: false,
+    acknowledgeDestructive: false,
+  });
+  for (const item of response.results) {
+    if (item.outcome === 'pending') {
+      await waitForChange(client, item);
+    }
+    log(`Schema: ${item.apiKey} ${item.decision.action}`);
+  }
+  log(`Schema version ${response.schemaVersion}`);
+};
+
+const findAsset = async (client: ShapioClient, filename: string) =>
+  (await client.admin.media.assets.list({ search: filename, limit: 50 })).items.find(
+    (asset) => asset.filename === filename,
+  );
+
+/** Uploads a generated PNG through the grant flow (the same for local disk and S3 storage), once. */
+const ensureImage = async (client: ShapioClient, spec: ImageSpec): Promise<MediaAsset> => {
+  const existing = await findAsset(client, spec.filename);
+  if (existing) {
+    return existing;
+  }
+  const png = createPng(spec.width, spec.height, spec.from, spec.to);
+  const grant = await client.admin.media.uploads.create({
+    filename: spec.filename,
+    mimeType: 'image/png',
+    sizeBytes: png.length,
+  });
+  const upload = await fetch(grant.upload.url, {
+    method: 'POST',
+    body: buildUploadForm(grant, new Blob([new Uint8Array(png)], { type: 'image/png' }), spec.filename),
+  });
+  if (!upload.ok) {
+    throw new Error(`Uploading ${spec.filename} failed: HTTP ${upload.status} ${await upload.text()}`);
+  }
+  const asset = await client.admin.media.uploads.confirm(grant.grantId);
+  const updated = await client.admin.media.assets.update(asset.id, {
+    expectedVersion: asset.version,
+    alt: spec.alt,
+  });
+  log(`Uploaded ${spec.filename}`);
+  return updated;
+};
+
+/** Variants are rendered by a background job; the site's srcsets need them. */
+const waitForMedia = async (client: ShapioClient, ids: readonly string[]) => {
+  const deadline = Date.now() + MEDIA_READY_TIMEOUT_MS;
+  for (;;) {
+    const assets = await Promise.all(ids.map((id) => client.admin.media.assets.get(id)));
+    if (assets.every((asset) => asset.status !== 'processing')) {
+      return;
+    }
+    if (Date.now() > deadline) {
+      throw new Error('Media processing did not finish in time; is the Shapio worker running?');
+    }
+    await delay(500);
+  }
+};
+
+const ensureMedia = async (client: ShapioClient): Promise<MediaIds> => {
+  const ids = {} as MediaIds;
+  for (const [key, spec] of Object.entries(IMAGES) as Array<[keyof MediaIds, ImageSpec]>) {
+    ids[key] = (await ensureImage(client, spec)).id;
+  }
+  await waitForMedia(client, Object.values(ids));
+  return ids;
+};
+
+const ensureAuthor = async (client: ShapioClient, avatar: string) => {
+  const page = await client.admin.content.list('author', { pageSize: 100 });
+  const existing = page.items.find((item) => item.data.name === AUTHOR.name);
+  const data = { ...AUTHOR, avatar };
+  const entry = existing
+    ? await client.admin.content.update('author', existing.id, { expectedVersion: existing.version, data })
+    : await client.admin.content.create('author', { data });
+  await client.admin.content.publish('author', entry.id);
+  return entry.id;
+};
+
+/** The locale's draft version, or null when the entry has none in that locale yet. */
+const versionIn = async (client: ShapioClient, model: string, id: string, locale: string) => {
+  try {
+    return (await client.admin.content.get(model, id, { locale })).version;
+  } catch (error) {
+    if (error instanceof ShapioApiError && error.status === 404) {
+      return null;
+    }
+    throw error;
+  }
+};
+
+/** The singleton's one entry, created on the first run, then updated in both locales and published. */
+const ensureSiteSettings = async (client: ShapioClient) => {
+  const existing = (await client.admin.content.list('siteSettings', { locale: 'en' })).items[0];
+  const id = existing
+    ? (
+        await client.admin.content.update('siteSettings', existing.id, {
+          locale: 'en',
+          expectedVersion: await versionIn(client, 'siteSettings', existing.id, 'en'),
+          data: SITE_SETTINGS.en,
+        })
+      ).id
+    : (await client.admin.content.create('siteSettings', { locale: 'en', data: SITE_SETTINGS.en })).id;
+  await client.admin.content.update('siteSettings', id, {
+    locale: 'fr',
+    expectedVersion: await versionIn(client, 'siteSettings', id, 'fr'),
+    data: SITE_SETTINGS.fr,
+  });
+  await client.admin.content.publish('siteSettings', id, { locales: ['en', 'fr'] });
+  log('Published siteSettings (en, fr)');
+};
+
+const upsertEntry = async (client: ShapioClient, spec: EntrySpec) => {
+  const found = await client.admin.content.list(spec.model, {
+    filters: { slug: { $eq: spec.slug } },
+    locale: 'en',
+  });
+  let id = found.items[0]?.id;
+  if (id) {
+    const version = await versionIn(client, spec.model, id, 'en');
+    await client.admin.content.update(spec.model, id, {
+      locale: 'en',
+      expectedVersion: version,
+      data: spec.content.en,
+    });
+  } else {
+    id = (await client.admin.content.create(spec.model, { locale: 'en', data: spec.content.en })).id;
+  }
+  const frVersion = await versionIn(client, spec.model, id, 'fr');
+  await client.admin.content.update(spec.model, id, {
+    locale: 'fr',
+    expectedVersion: frVersion,
+    data: spec.content.fr,
+  });
+  if (spec.publish) {
+    await client.admin.content.publish(spec.model, id, { locales: ['en', 'fr'] });
+  }
+  log(`${spec.publish ? 'Published' : 'Saved draft'} ${spec.model} ${spec.slug} (en, fr)`);
+};
+
+/** A delivery role that reads the site's models, and a fresh token bound to it (older ones are revoked). */
+const createDeliveryToken = async (client: ShapioClient) => {
+  const summary = await client.admin.schema.summary();
+  const modelIds = summary.definitions
+    .filter((definition) => SITE_MODELS.includes(definition.apiKey))
+    .map((definition) => definition.id);
+  const permissions = modelIds.map((modelId) => ({
+    action: 'read' as const,
+    modelId,
+    condition: null,
+    fieldIds: null,
+  }));
+  const roles = await client.admin.roles.list();
+  const existing = roles.find((role) => role.key === DELIVERY_ROLE_KEY);
+  const role = existing
+    ? await client.admin.roles.update(existing.id, { expectedVersion: existing.version, permissions })
+    : await client.admin.roles.create({
+        key: DELIVERY_ROLE_KEY,
+        name: 'Starter site (delivery)',
+        description: 'Reads published pages, articles, authors and the site settings for the starter build.',
+        kind: 'delivery',
+        permissions,
+      });
+  for (const token of await client.admin.tokens.list()) {
+    if (token.name === DELIVERY_TOKEN_NAME && !token.revokedAt) {
+      await client.admin.tokens.revoke(token.id);
+    }
+  }
+  return (await client.admin.tokens.create({ name: DELIVERY_TOKEN_NAME, roleId: role.id })).token;
+};
+
+/** The "Preview" connection, created once and pointed at this starter's /preview/ page on every run. */
+const ensurePreviewConnection = async (client: ShapioClient, siteUrl: string) => {
+  const previewUrlTemplate = `${siteUrl.replace(/\/+$/, '')}${PREVIEW_PATH}`;
+  const existing = (await client.admin.deployments.connections.list()).find(
+    (connection) => connection.name === PREVIEW_CONNECTION_NAME,
+  );
+  if (existing) {
+    await client.admin.deployments.connections.update(existing.id, {
+      expectedVersion: existing.version,
+      previewUrlTemplate,
+    });
+  } else {
+    await client.admin.deployments.connections.create({
+      name: PREVIEW_CONNECTION_NAME,
+      provider: 'generic_webhook',
+      settings: { url: PREVIEW_BUILD_HOOK },
+      secrets: {},
+      triggerPolicy: [],
+      previewUrlTemplate,
+    });
+  }
+  log(`Preview opens ${previewUrlTemplate}`);
+};
+
+/** The "Site revalidation" webhook, created once and pointed at the site on every run; returns a fresh secret. */
+const ensureRevalidateWebhook = async (client: ShapioClient, siteUrl: string, path: string) => {
+  const url = `${siteUrl.replace(/\/+$/, '')}${path}`;
+  const allowPrivateNetwork = LOOPBACK_HOSTS.has(new URL(url).hostname);
+  const existing = (await client.admin.webhooks.list()).find(
+    (webhook) => webhook.name === REVALIDATE_WEBHOOK_NAME,
+  );
+  const settings = { url, events: REVALIDATE_EVENTS, enabled: true, allowPrivateNetwork };
+  let created;
+  if (existing) {
+    await client.admin.webhooks.update(existing.id, { expectedVersion: existing.version, ...settings });
+    created = await client.admin.webhooks.rotateSecret(existing.id);
+  } else {
+    created = await client.admin.webhooks.create({ name: REVALIDATE_WEBHOOK_NAME, ...settings });
+  }
+  log(`Webhook "${REVALIDATE_WEBHOOK_NAME}" calls ${url}`);
+  return created.secret;
+};
+
+/**
+ * Shapio refuses a webhook to a loopback or private address unless its OUTBOUND_PRIVATE_NETWORK_ALLOWLIST
+ * covers it. The site still builds and serves without the webhook, so the seed says how to turn it on and
+ * carries on; the revalidation route answers 503 until SHAPIO_WEBHOOK_SECRET is set.
+ */
+const tryRevalidateWebhook = async (client: ShapioClient, siteUrl: string, path: string) => {
+  try {
+    return await ensureRevalidateWebhook(client, siteUrl, path);
+  } catch (error) {
+    if (error instanceof ShapioApiError && error.code === 'DESTINATION_NOT_ALLOWED') {
+      log(
+        `Skipped the "${REVALIDATE_WEBHOOK_NAME}" webhook: ${error.message} For a local site, start Shapio with ` +
+          'OUTBOUND_PRIVATE_NETWORK_ALLOWLIST=127.0.0.1/32,::1/128 and run the seed again.',
+      );
+      return undefined;
+    }
+    throw error;
+  }
+};
+
+const writeEnv = async (url: string, deliveryToken: string, webhookSecret: string | undefined) => {
+  const path = resolve('.env');
+  const lines = [
+    '# Written by the seed. The delivery token is read-only; keep this file out of git.',
+    `SHAPIO_URL=${url}`,
+    `SHAPIO_DELIVERY_TOKEN=${deliveryToken}`,
+    ...(webhookSecret ? [`SHAPIO_WEBHOOK_SECRET=${webhookSecret}`] : []),
+  ];
+  await writeFile(path, `${lines.join('\n')}\n`, { mode: 0o600 });
+  log(
+    `Wrote SHAPIO_URL, SHAPIO_DELIVERY_TOKEN${webhookSecret ? ' and SHAPIO_WEBHOOK_SECRET' : ''} to ${path}`,
+  );
+};
+
+const main = async () => {
+  const { values } = parseArgs({
+    options: { 'site-url': { type: 'string' }, 'revalidate-path': { type: 'string' } },
+  });
+  const siteUrl = process.env.SITE_URL || values['site-url'] || 'http://localhost:4321';
+  const admin = await connectAdmin(process.env);
+  try {
+    await ensureLocale(admin.client);
+    await applySchema(admin.client);
+    const media = await ensureMedia(admin.client);
+    await ensureSiteSettings(admin.client);
+    const authorId = await ensureAuthor(admin.client, media.avatar);
+    for (const spec of entries(media, authorId)) {
+      await upsertEntry(admin.client, spec);
+    }
+    await ensurePreviewConnection(admin.client, siteUrl);
+    const revalidatePath = values['revalidate-path'];
+    const webhookSecret = revalidatePath
+      ? await tryRevalidateWebhook(admin.client, siteUrl, revalidatePath)
+      : undefined;
+    await writeEnv(admin.url, await createDeliveryToken(admin.client), webhookSecret);
+    log('Seeded. Build the site with: npm run build');
+  } finally {
+    await admin.close();
+  }
+};
+
+main().catch((error: unknown) => {
+  process.stderr.write(
+    `seed failed: ${error instanceof ShapioApiError ? `${error.code}: ${error.message} ${JSON.stringify(error.details ?? '')}` : error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`,
+  );
+  process.exitCode = 1;
+});

package/templates/next/scripts/smokeHttp.ts

@@ -0,0 +1,162 @@
+import { createHmac } from 'node:crypto';
+import { parseArgs } from 'node:util';
+
+/**
+ * `npm run smoke`, after `npm run seed`, `npm run build` and starting the built site (`npm run start` or
+ * `npm run preview`): fetches the site's pages over HTTP and checks the seeded content in English and French,
+ * the site settings singleton, rich text, media variants and the author, that the draft article is not
+ * served, that content carries the visual-editing attributes (@shapio/visual's `shapioAttr`), and that the
+ * preview page is served with a `frame-ancestors` policy. The same checks run against every starter, so all
+ * three render the same blog.
+ *
+ * `--url` is the running site's origin (default: SMOKE_URL, then http://localhost:4321). `--revalidate` (the
+ * Next.js starter) also checks its on-demand revalidation route: an unsigned POST to /api/revalidate is refused,
+ * and an event signed with SHAPIO_WEBHOOK_SECRET is answered 200 with the paths it revalidated.
+ */
+const DRAFT_TITLE = 'Coming soon: our winter projects';
+const ARTICLE = 'modelling-without-a-deploy';
+
+type PageCheck = { path: string; expect: Array<[needle: string, label: string]> };
+
+const PAGES: readonly PageCheck[] = [
+  {
+    path: '/en/',
+    expect: [
+      ['Content that changes as fast as your product', 'hero heading'],
+      ['Static delivery', 'feature grid'],
+      ['From the studio', 'gallery'],
+      ['.webp', 'responsive image variants'],
+      ['Northwind Studio', 'site name from the siteSettings singleton'],
+      ['Built with Shapio', 'footer from the siteSettings singleton'],
+    ],
+  },
+  {
+    path: '/fr/',
+    expect: [
+      ['Un contenu qui évolue aussi vite que votre produit', 'hero heading'],
+      ['lang="fr"', 'lang="fr"'],
+      ['Studio Northwind', 'site name from the siteSettings singleton'],
+    ],
+  },
+  {
+    path: '/en/articles/',
+    expect: [
+      ['Modelling content without a deploy', 'article list'],
+      ['Why our builds pin a snapshot', 'second article'],
+    ],
+  },
+  {
+    path: `/en/articles/${ARTICLE}/`,
+    expect: [
+      ['Modelling content without a deploy', 'title'],
+      ['<table', 'rich-text table'],
+      ['With Shapio', 'rich-text table cell'],
+      ['Ada Moreau', 'populated author'],
+      ['data-shapio-entry="', 'visual-editing entry attribute'],
+      ['data-shapio-path="title"', 'visual-editing attribute on the title'],
+      ['data-shapio-path="body"', 'visual-editing attribute on the body'],
+    ],
+  },
+  { path: `/fr/articles/${ARTICLE}/`, expect: [['Modéliser du contenu sans déploiement', 'title']] },
+  { path: '/fr/about/', expect: [['À propos du studio', 'page from the page collection']] },
+  { path: '/en/colophon/', expect: [['pinned to one publication snapshot per build', 'singleton page']] },
+];
+
+const failures: string[] = [];
+const check = (condition: boolean, message: string) => {
+  process.stdout.write(`${condition ? 'ok  ' : 'FAIL'} ${message}\n`);
+  if (!condition) {
+    failures.push(message);
+  }
+};
+
+const fetchPage = async (origin: string, path: string) => {
+  const response = await fetch(new URL(path, origin));
+  return { status: response.status, html: await response.text() };
+};
+
+const REVALIDATE_PATH = '/api/revalidate/';
+
+const postEvent = (origin: string, body: string, headers: Record<string, string>) =>
+  fetch(new URL(REVALIDATE_PATH, origin), {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', ...headers },
+    body,
+  });
+
+/** Signed like Shapio's webhooks: `v1=<hex HMAC-SHA256(secret, "<timestamp>.<body>")>`. */
+const signatureHeaders = (secret: string, body: string) => {
+  const timestamp = String(Math.floor(Date.now() / 1000));
+  const signature = createHmac('sha256', secret).update(`${timestamp}.${body}`).digest('hex');
+  return { 'x-shapio-timestamp': timestamp, 'x-shapio-signature': `v1=${signature}` };
+};
+
+const checkRevalidation = async (origin: string) => {
+  const secret = process.env.SHAPIO_WEBHOOK_SECRET;
+  if (!secret) {
+    check(
+      false,
+      `${REVALIDATE_PATH}: SHAPIO_WEBHOOK_SECRET is set (the seed writes it with --revalidate-path)`,
+    );
+    return;
+  }
+  const body = JSON.stringify({
+    id: `smoke-${Date.now()}`,
+    type: 'entry.published',
+    createdAt: new Date().toISOString(),
+    site: null,
+    data: { modelKey: 'article', entryId: 'smoke', locale: 'en' },
+  });
+  const unsigned = await postEvent(origin, body, {});
+  check(
+    unsigned.status === 401,
+    `${REVALIDATE_PATH}: an unsigned event is refused (HTTP ${unsigned.status})`,
+  );
+  const response = await postEvent(origin, body, signatureHeaders(secret, body));
+  const text = await response.text();
+  check(response.status === 200, `${REVALIDATE_PATH}: a signed event is accepted (HTTP ${response.status})`);
+  let result: { revalidated?: unknown; skipped?: unknown; from?: unknown; to?: unknown } = {};
+  try {
+    result = JSON.parse(text) as typeof result;
+  } catch {
+    // Reported by the check below.
+  }
+  const listed = Array.isArray(result.revalidated) || typeof result.skipped === 'string';
+  check(listed, `${REVALIDATE_PATH}: the answer lists the revalidated paths: ${text}`);
+};
+
+const main = async () => {
+  const { values } = parseArgs({
+    options: { url: { type: 'string' }, revalidate: { type: 'boolean', default: false } },
+  });
+  const origin = values.url ?? process.env.SMOKE_URL ?? 'http://localhost:4321';
+  for (const page of PAGES) {
+    const { status, html } = await fetchPage(origin, page.path);
+    check(status === 200, `${page.path}: HTTP ${status}`);
+    for (const [needle, label] of page.expect) {
+      check(html.includes(needle), `${page.path}: ${label}`);
+    }
+  }
+  const preview = await fetch(new URL('/preview/', origin));
+  check(preview.status === 200, `/preview/: HTTP ${preview.status}`);
+  check(
+    /frame-ancestors/.test(preview.headers.get('content-security-policy') ?? ''),
+    '/preview/: frame-ancestors policy (only the site and Shapio may frame it)',
+  );
+  const list = await fetchPage(origin, '/en/articles/');
+  check(!list.html.includes(DRAFT_TITLE), 'the unpublished draft is not listed');
+  const draft = await fetchPage(origin, '/en/articles/winter-projects/');
+  check(draft.status === 404, `the unpublished draft is not served (HTTP ${draft.status})`);
+  if (values.revalidate) {
+    await checkRevalidation(origin);
+  }
+  if (failures.length > 0) {
+    throw new Error(`${failures.length} check(s) failed against ${origin}`);
+  }
+  process.stdout.write(`Smoke test passed against ${origin}.\n`);
+};
+
+main().catch((error: unknown) => {
+  process.stderr.write(`smoke: ${error instanceof Error ? error.message : String(error)}\n`);
+  process.exitCode = 1;
+});

package/templates/next/shapio/components/callToAction.json

@@ -0,0 +1,85 @@
+{
+  "apiKey": "callToAction",
+  "category": "Sections",
+  "display": {},
+  "fields": [
+    {
+      "apiKey": "heading",
+      "deprecated": false,
+      "editor": {
+        "id": "textInput",
+        "options": {}
+      },
+      "filterable": false,
+      "id": "f4022efd-611f-46da-96da-1f0a550fcd98",
+      "label": "Heading",
+      "localized": false,
+      "public": true,
+      "required": true,
+      "settings": {},
+      "sortable": false,
+      "type": "string",
+      "unique": false
+    },
+    {
+      "apiKey": "text",
+      "deprecated": false,
+      "editor": {
+        "id": "textarea",
+        "options": {}
+      },
+      "filterable": false,
+      "id": "9a5169a7-3116-496f-8073-806e80d02053",
+      "label": "Text",
+      "localized": false,
+      "public": true,
+      "required": false,
+      "settings": {},
+      "sortable": false,
+      "type": "text",
+      "unique": false
+    },
+    {
+      "apiKey": "buttonLabel",
+      "deprecated": false,
+      "editor": {
+        "id": "textInput",
+        "options": {}
+      },
+      "filterable": false,
+      "id": "377c9217-615d-4928-b2a3-621e6ea51aa5",
+      "label": "Button label",
+      "localized": false,
+      "public": true,
+      "required": true,
+      "settings": {},
+      "sortable": false,
+      "type": "string",
+      "unique": false
+    },
+    {
+      "apiKey": "buttonUrl",
+      "deprecated": false,
+      "description": "A full URL, a mailto: or tel: link, or a path on this site such as /en/articles/",
+      "editor": {
+        "id": "textInput",
+        "options": {}
+      },
+      "filterable": false,
+      "id": "fb10a97c-2199-4d5f-99e0-8ea83313a4f6",
+      "label": "Button link",
+      "localized": false,
+      "public": true,
+      "required": true,
+      "settings": {
+        "pattern": "^(https?://|mailto:|tel:|/)"
+      },
+      "sortable": false,
+      "type": "string",
+      "unique": false
+    }
+  ],
+  "id": "be8255cc-2588-4204-950e-ad3d84db4f2e",
+  "kind": "component",
+  "label": "Call to action"
+}

package/templates/next/shapio/components/feature.json

@@ -0,0 +1,46 @@
+{
+  "apiKey": "feature",
+  "category": "Marketing",
+  "display": {},
+  "fields": [
+    {
+      "apiKey": "title",
+      "deprecated": false,
+      "editor": {
+        "id": "textInput",
+        "options": {}
+      },
+      "filterable": false,
+      "id": "11cba9b7-59b3-4f79-b6c0-4e6b1e1e732e",
+      "label": "Title",
+      "localized": false,
+      "public": true,
+      "required": true,
+      "settings": {},
+      "sortable": false,
+      "type": "string",
+      "unique": false
+    },
+    {
+      "apiKey": "description",
+      "deprecated": false,
+      "editor": {
+        "id": "textarea",
+        "options": {}
+      },
+      "filterable": false,
+      "id": "c14bbc67-0f0f-4455-8e4c-443d4e3ed4b2",
+      "label": "Description",
+      "localized": false,
+      "public": true,
+      "required": false,
+      "settings": {},
+      "sortable": false,
+      "type": "text",
+      "unique": false
+    }
+  ],
+  "id": "66138d48-8c29-499e-ba51-86e5fb1b372b",
+  "kind": "component",
+  "label": "Feature"
+}