camox 0.47.0 → 0.51.0

package/skills/camox/references/block-definitions.md

@@ -18,8 +18,9 @@ const myBlock = createBlock({
   content: (field) => ({
     title: field.string({ default: "Welcome" }),
   }),
-  component: MyBlockComponent,
-  toMarkdown: (c) => [`# ${c.title}`],
+  toReact: MyBlockComponent,
+  toTitle: ({ content }) => content.title,
+  toMarkdown: ({ content }) => [`# ${content.title}`],
 });
 
 function MyBlockComponent() {
@@ -37,17 +38,19 @@ For DOM listeners, scrolling, scripts, widgets, or JavaScript-driven animation,
 
 ## The `createBlock` options
 
-| Option        | Required | Description                                                                                  |
-| ------------- | -------- | -------------------------------------------------------------------------------------------- |
-| `id`          | yes      | Unique kebab-case identifier matching the filename without extension.                        |
-| `title`       | yes      | CMS display name.                                                                            |
-| `description` | yes      | Agent guidance on placement, expected content, and tone.                                     |
-| `content`     | yes      | `(field) => ({ ... })`: field names mapped to `field.*` builders for editable content.       |
-| `settings`    | no       | `(setting) => ({ ... })`: settings-panel options; only `setting.enum` and `setting.boolean`. |
-| `layoutOnly`  | no       | If true, restricts placement to layouts and hides the type from the add-block picker.        |
-| `synced`      | no       | Defaults to false. Shares content/settings across placements; see below.                     |
-| `component`   | yes      | Named React function component.                                                              |
-| `toMarkdown`  | yes      | `(c, s) => [...]` markdown builder; see below.                                               |
+| Option             | Required | Description                                                                                    |
+| ------------------ | -------- | ---------------------------------------------------------------------------------------------- |
+| `id`               | yes      | Unique kebab-case identifier matching the filename without extension.                          |
+| `title`            | yes      | CMS display name.                                                                              |
+| `description`      | yes      | Agent guidance on placement, expected content, and tone.                                       |
+| `content`          | yes      | `(field) => ({ ... })`: field names mapped to `field.*` builders for editable content.         |
+| `settings`         | no       | `(setting) => ({ ... })`: settings-panel options; only `setting.enum` and `setting.boolean`.   |
+| `layoutOnly`       | no       | If true, restricts placement to layouts and hides the type from the add-block picker.          |
+| `synced`           | no       | Defaults to false. Shares content/settings across placements; see below.                       |
+| `toReact`          | yes      | Named React function component. Receives `{ content, settings }` as props.                     |
+| `toTitle`          | yes      | `({ content, settings }) => ...` one-line title; see below.                                    |
+| `toMarkdown`       | yes      | `({ content, settings }) => [...]` markdown builder; see below.                                |
+| `toStructuredData` | no       | `({ content, settings }) => node \| [...]`: the things the block shows, as JSON-LD; see below. |
 
 ## Synced blocks (`synced`, optional)
 
@@ -59,14 +62,30 @@ For shared navbar/footer data across layouts, use `layoutOnly: true, synced: tru
 - Position, layout slot, and deletion remain per placement; deleting one placement leaves the others.
 - Enabling syncing on an existing type applies the oldest placement's data to all placements. Disabling it leaves independently editable copies.
 
+## Titles (`toTitle`)
+
+Required on blocks and repeaters. Names each block and repeatable item in the studio and to agents until it has a Summary, which always wins once it exists. Receives `{ content, settings }` like `toMarkdown` and returns one line: a field, a template literal, or a fixed string for blocks with no telling field.
+
+```tsx
+toTitle: ({ content }) => content.title;
+toTitle: ({ content }) => `${content.number} ${content.label}`;
+toTitle: () => "Navigation";
+```
+
+Titles read the default locale's content as plain text: a Link reads as its text. References aren't resolved in titles, so name a block by its own fields.
+
 ## Markdown Representation (`toMarkdown`)
 
-Required on blocks and repeaters. Receives typed proxies `c` (content) and `s` (settings); returns entries joined with `\n\n` for AI summaries and SEO. Lines whose referenced fields are all empty, or whose condition is false, are omitted.
+Required on blocks and repeaters. Receives `{ content, settings }`, typed proxies of the block's content and settings; returns entries joined with `\n\n` for AI summaries and SEO. Lines whose referenced fields are all empty, or whose condition is false, are omitted.
 
-Use bare `c.field` for single-field lines and template literals for markdown or combined fields:
+Use bare `content.field` for single-field lines and template literals for markdown or combined fields:
 
 ```tsx
-toMarkdown: (c) => [`> ${c.quote}`, `— ${c.author}, ${c.company}`, c.photo];
+toMarkdown: ({ content }) => [
+  `> ${content.quote}`,
+  `— ${content.author}, ${content.company}`,
+  content.photo,
+];
 ```
 
 Field resolution:
@@ -87,16 +106,16 @@ Field resolution:
 Boolean settings wrap one line or an array; Enum settings match a variant:
 
 ```tsx
-toMarkdown: (c, s) => [
-  `# ${c.title}`,
-  s.showCta(c.cta),
-  s.showDetails([c.subtitle, c.description]),
-  s.variant("banner", `**${c.headline}** — ${c.subtext}`),
-  s.variant("inline", `${c.headline}: ${c.cta}`),
+toMarkdown: ({ content, settings }) => [
+  `# ${content.title}`,
+  settings.showCta(content.cta),
+  settings.showDetails([content.subtitle, content.description]),
+  settings.variant("banner", `**${content.headline}** — ${content.subtext}`),
+  settings.variant("inline", `${content.headline}: ${content.cta}`),
 ];
 ```
 
-Only Boolean/Enum settings support these conditionals. A repeater's `s` refers to the item's settings, not the parent block's.
+Only Boolean/Enum settings support these conditionals. A repeater's `settings` refers to the item's settings, not the parent block's.
 
 ## Content Field Types
 
@@ -203,7 +222,7 @@ field.artifact({ size: "fill", data: ["headline", "variant"] }); // shares sibli
 
 ### field.repeater
 
-Structured items with their own content, optional settings, and required `toMarkdown`. `minItems` must be at least 1; repeaters cannot be empty. Nest repeaters in an item's `content` when needed.
+Structured items with their own content, optional settings, and required `toTitle` and `toMarkdown`. `minItems` must be at least 1; repeaters cannot be empty. Nest repeaters in an item's `content` when needed.
 
 ```tsx
 field.repeater({
@@ -217,12 +236,73 @@ field.repeater({
   minItems: 1,
   maxItems: 10,
   title: "Features",
-  toMarkdown: (c, s) => [`### ${c.name}`, s.highlighted(c.description)],
+  toTitle: ({ content }) => content.name,
+  toMarkdown: ({ content, settings }) => [
+    `### ${content.name}`,
+    settings.highlighted(content.description),
+  ],
 });
 ```
 
 Reference the repeater field in the parent block's `toMarkdown` to include its rendered items.
 
+## Structured Data (`toStructuredData`, optional)
+
+On blocks and repeaters. Describes the things a block shows (a video, a product, questions, reviews) as schema.org nodes in the page's JSON-LD graph. Returns one node or a list. Camox links each node to the page (`isPartOf` for creative works, `subjectOf` for anything else) and gives each placement its own nodes. Only the layout says what the page is, so a block never returns a kind of web page, and Camox alone emits the site's `Organization` and `WebSite`. `@type` and properties are typed: invented types or properties, or a node missing what search engines require (a `Product`'s offers, review or rating), fail to compile.
+
+```tsx
+toStructuredData: ({ content }) => ({
+  "@type": "VideoObject",
+  name: content.title,
+  embedUrl: content.video,
+  thumbnailUrl: content.thumbnail,
+  uploadDate: "2026-01-15",
+});
+```
+
+Field tokens resolve as follows; template literals read their fields as plain text:
+
+| Type           | Value                                                                                                                     |
+| -------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| String         | Plain text                                                                                                                |
+| Image          | An `ImageObject` with its absolute URL, width, height and alt text                                                        |
+| File           | Its absolute URL                                                                                                          |
+| Link           | The page's absolute URL in the page's locale, or the external href                                                        |
+| Embed          | Its URL                                                                                                                   |
+| Repeater       | Its items' nodes, from the repeater's own `toStructuredData`                                                              |
+| Reference      | A link to the record's node, from its collection's `toStructuredData`, or the record's title when the collection has none |
+| Reference list | A list of such links                                                                                                      |
+
+Icon and artifact fields have no token. A property whose field is empty is left out. A reference's fields are tokens too (`content.author.name`). The place referencing a record decides its role, such as a testimonial's `author: content.author`; Camox adds the record's node to the graph once, however many blocks link it.
+
+Place a repeater's token where its items' nodes go, such as an FAQ's questions:
+
+```tsx
+items: field.repeater({
+  content: (field) => ({ question: field.string({ default: "Why?" }), answer: field.string({ default: "Because" }) }),
+  minItems: 1,
+  maxItems: 20,
+  toTitle: ({ content }) => content.question,
+  toMarkdown: ({ content }) => [`Q: ${content.question}`, `A: ${content.answer}`],
+  toStructuredData: ({ content }) => ({
+    "@type": "Question",
+    name: content.question,
+    acceptedAnswer: { "@type": "Answer", text: content.answer },
+  }),
+}),
+// On the block:
+toStructuredData: ({ content }) => content.items,
+```
+
+Settings show a part of the template only while they hold: a Boolean setting takes the part, an Enum setting the option it must equal, then the part. The part is left out otherwise, and a list it shows inside a list adds its entries:
+
+```tsx
+toStructuredData: ({ content, settings }) => [
+  { "@type": "Product", name: content.name, description: settings.variant("detailed", content.description), offers: { "@type": "Offer", price: 49, priceCurrency: "EUR" } },
+  settings.showFaq(content.questions),
+],
+```
+
 ## Rendering in the Component
 
 Field renderers receive `(props, data)`:

package/skills/camox/references/layout-definitions.md

@@ -25,8 +25,9 @@ const myLayout = createLayout({
     after: [footerBlock],
     initial: [() => import("../blocks/hero")],
   },
-  component: MyLayoutComponent,
-  buildMetaTitle: ({ pageMetaTitle, projectName }) => `${pageMetaTitle} | ${projectName}`,
+  toReact: MyLayoutComponent,
+  toTitle: ({ page, project }) => `${page.title} | ${project.name}`,
+  toDescription: ({ page }) => page.description,
 });
 
 function MyLayoutComponent({ children }: { children: React.ReactNode }) {
@@ -44,16 +45,28 @@ export { myLayout as layout };
 
 ## The `createLayout` options
 
-| Option                 | Required | Description                                                                                                                  |
-| ---------------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------- |
-| `id`                   | yes      | Unique kebab-case identifier matching the filename without extension.                                                        |
-| `title`                | yes      | CMS display name.                                                                                                            |
-| `description`          | yes      | Guidance for users and agents on which pages suit this layout.                                                               |
-| `blocks`               | yes      | `before`, `after`, and optional `initial` arrays; see layout slot rules below.                                               |
-| `component`            | yes      | Named function component receiving `{ children }`.                                                                           |
-| `buildMetaTitle`       | yes      | `({ pageMetaTitle, projectName, pageFullPath }) => string` for the browser title.                                            |
-| `buildMetaDescription` | no       | `({ pageMetaDescription, projectName, pageFullPath }) => string \| undefined`. Without it, the editor's description is used. |
-| `buildOgImage`         | no       | `({ title, description, projectName }) => JSX` for a sharing image.                                                          |
+| Option             | Required | Description                                                                                            |
+| ------------------ | -------- | ------------------------------------------------------------------------------------------------------ |
+| `id`               | yes      | Unique kebab-case identifier matching the filename without extension.                                  |
+| `title`            | yes      | CMS display name.                                                                                      |
+| `description`      | yes      | Guidance for users and agents on which pages suit this layout.                                         |
+| `blocks`           | yes      | `before`, `after`, and optional `initial` arrays; see layout slot rules below.                         |
+| `toReact`          | yes      | Named function component receiving the context and `{ children }` as props.                            |
+| `toTitle`          | yes      | `(context) => string`: the head title, `og:title`, and the Markdown front matter's `title`.            |
+| `toDescription`    | yes      | `(context) => string \| undefined`: the head description and `og:description`. May return `undefined`. |
+| `toImage`          | no       | `(context) => JSX`: the sharing image; see below.                                                      |
+| `toStructuredData` | no       | `(context) => node \| undefined`: what the page is, in its JSON-LD; see below.                         |
+
+## The `to*` options and their context
+
+Every `to*` option receives the same context object, and none receives another one's output: Camox joins the outputs itself.
+
+- `page.title`: the page's undecorated title. On curated pages, the editor's or generated meta title.
+- `page.description`: on curated pages, the editor's or generated description. Absent otherwise.
+- `page.path`: the page's path, with its locale's prefix. `page.locale`: the locale's tag, such as `de`.
+- `project.name`: the project's name.
+
+Singleton and derived layouts also receive `data` and `params`, and record pages `content`; see [Routed layouts](routed-layouts.md#metadata-and-markdown).
 
 ## Layout Slots — `before`, `after`, and `initial`
 
@@ -70,12 +83,12 @@ export { myLayout as layout };
 - At most one layout per app may define `initial`; multiple definitions cause a startup error.
 - Without `initial`, Camox seeds an empty homepage using the first curated layout. Apps with only singleton/derived layouts do not seed a curated homepage.
 
-## OG Image — `buildOgImage` (optional)
+## OG Image — `toImage` (optional)
 
 Returns JSX rendered as a 1200×630 image. Use **inline styles, not Tailwind**, and `display: "flex"` for layout: this runs in an image-generation engine, not a browser.
 
 ```tsx
-buildOgImage: ({ title, description, projectName }) => (
+toImage: ({ page, project }) => (
   <div
     style={{
       display: "flex",
@@ -88,9 +101,32 @@ buildOgImage: ({ title, description, projectName }) => (
       fontFamily: "sans-serif",
     }}
   >
-    {projectName && <div style={{ fontSize: 24 }}>{projectName}</div>}
-    <div style={{ fontSize: 64 }}>{title}</div>
-    {description && <div style={{ fontSize: 28 }}>{description}</div>}
+    {project.name && <div style={{ fontSize: 24 }}>{project.name}</div>}
+    <div style={{ fontSize: 64 }}>{page.title}</div>
+    {page.description && <div style={{ fontSize: 28 }}>{page.description}</div>}
   </div>
 ),
 ```
+
+The site serves the image at `/og?path=<page path>` for real pages only, rendered from the page as it is published. An editor's custom image replaces it, and a layout without one gets Camox's default image showing the page title and project name.
+
+## Structured Data — `toStructuredData` (optional)
+
+Every page's head carries a JSON-LD graph that Camox builds itself: the project's `Organization` and `WebSite`, and a `WebPage` named and described by `toTitle` and `toDescription`, with its URL, language, image and publish dates. `toStructuredData` only says what the page is. Return one of:
+
+- **A kind of web page**, which the page's node becomes: `AboutPage`, `ContactPage`, `CollectionPage`, `FAQPage`, `ProfilePage`, `ItemPage`, `QAPage`, `SearchResultsPage`, `CheckoutPage`, `MedicalWebPage` or `RealEstateListing`.
+- **A main entity**, emitted as its own node and linked as the page's `mainEntity`: an Article type (`BlogPosting`, `NewsArticle`, `TechArticle`, …), `Product`, `Event`, `Person`, `Place`, `Review`, `Question`, `HowTo`, `Recipe`, `Course`, `JobPosting`, `SoftwareApplication`, `VideoObject`, `ImageObject`, `Book`, `Service`, …. Camox fills what you leave out: the name (an Article's `headline`), description, URL and image, plus the dates, publisher and language of creative works. Values you set win. An Article makes `og:type` `article`.
+
+```tsx
+toStructuredData: () => ({ "@type": "AboutPage" }),
+// A derived layout: the post is the page's main entity.
+toStructuredData: ({ data }) => ({ "@type": "BlogPosting", wordCount: data.wordCount }),
+toStructuredData: ({ data }) => ({
+  "@type": "Product",
+  offers: { price: data.price, priceCurrency: "EUR" },
+}),
+```
+
+- Only the listed types type-check, each with only its schema.org properties. There's no way out to the rest of schema.org.
+- Properties search engines require and Camox can't fill are required, such as a `Product`'s `offers`, `review` or `aggregateRating`, an `Event`'s `startDate` and `location`, and a `JobPosting`'s `datePosted` and `hiringOrganization`.
+- Layouts can't return `Organization` or `WebSite`: Camox builds the website's own from the project.

package/skills/camox/references/routed-layouts.md

@@ -29,10 +29,11 @@ export const layout = createLayout("pokedex")({
     after: [footerBlock],
   },
   loader: async () => ({ kind: "data", data: await loadPokemon() }),
-  // After the loader: these callbacks' `data` is inferred from it.
-  buildMetaTitle: ({ pageMetaTitle }) => pageMetaTitle,
+  // After the loader: these options' `data` is inferred from it.
+  toTitle: ({ page }) => page.title,
+  toDescription: ({ data }) => `${data.length} Pokémon to browse.`,
   toMarkdown: ({ data }) => [`${data.length} Pokémon`, data.map((p) => `- ${p.name}`).join("\n")],
-  component: PokedexPage,
+  toReact: PokedexPage,
 });
 
 function PokedexPage() {
@@ -105,10 +106,10 @@ export const Layout = createLayout("articles.$slug")({
   description: "One article, found by its slug.",
   blocks: { before: [navbarBlock], after: [footerBlock] },
   ...articles.pages({ by: "slug", param: "slug" }),
-  buildMetaTitle: ({ item, projectName }) => `${item.title} | ${projectName}`,
-  buildMetaDescription: ({ item }) => item.excerpt || undefined,
+  toTitle: ({ page, project }) => `${page.title} | ${project.name}`,
+  toDescription: ({ content }) => content.excerpt || undefined,
   toMarkdown: ({ item }) => [`# ${item.title}`, `By ${item.author.name}`, item.body],
-  component: ArticlePage,
+  toReact: ArticlePage,
 });
 
 function ArticlePage() {
@@ -133,11 +134,13 @@ function ArticlePage() {
 - Several records sharing a value in the same source is a server error naming the collection, field, value and records. Camox does not enforce uniqueness: keep the field unique.
 - The loader returns a `collection-item` envelope, `{ kind: "collection-item", collectionId, data: { id, content } }`, typed as `LayoutCollectionItemResult` from `camox/createLayout`. `layout.useData()` returns the unwrapped record, `{ id, content }`. Camox rejects an envelope naming an unregistered collection or a malformed record id.
 - `routes` lists one entry per record that can have a page, in the request's source: the sitemap lists published records only, even when an editor asks, while the Canvas previews a signed-in editor's first record, draft-only records included. Each entry is `{ params, target: { kind: "collection-item", collectionId, id } }`; `target` names the record independently of its current value. Records whose value is empty or contains `/` are left out. Several records sharing a value fail discovery, so `/sitemap.xml` responds 500 naming the layout and the records. An empty collection returns `{ data: [] }`, and the Canvas asks for a path.
-- `layout.Item` renders the page's record with the same typed scope as a block's `Reference`: `Field`, `Image`, `File`, `Embed`, `ImageList`, `FileList`, `Reference` and `ReferenceList`, plus `id` and `label`. Field names are checked against the collection. The record is the first hop: `Reference` and `ReferenceList` render the records it links, which link nothing further. Prefer it to `useData()`, whose `content` holds stored values (String fields may be rich-text state).
+- `layout.Item` renders the page's record with the same typed scope as a block's `Reference`: `Field`, `Image`, `File`, `Embed`, `ImageList`, `FileList`, `Reference` and `ReferenceList`, plus `id`, `title` and `description` (from the collection's `toTitle` and `toDescription`). Field names are checked against the collection. The record is the first hop: `Reference` and `ReferenceList` render the records it links, which link nothing further. Prefer it to `useData()`, whose `content` holds stored values (String fields may be rich-text state).
 - `layout.Item` exists only when every return of the loader is a record of one collection. On a loader that may return external data or records of several collections, using it is a type error. At runtime it renders nothing when the result isn't a record.
 - In Studio, editors edit record page fields in place, like a referenced record's: purple overlays, selection, and the record's fields in the sidebar. Edits change the shared record everywhere it appears.
 - `toMarkdown` also receives `item`, the same Markdown builder as a reference list's `toMarkdown`: interpolate fields (`item.title`, `item.author.name`, `item.cover`) and Camox fills them with the live record, rich text included. `data` stays the raw record. Markdown always shows live content, whoever asks.
-- `buildMetaTitle` and `buildMetaDescription` also receive `item`: the record's String fields as plain text.
+- `toTitle`, `toDescription`, `toImage`, `toReact` and `toStructuredData` also receive `content`, the record's String fields as plain text and its references as links to their records' Structured Data nodes. Their `page.title` is the record's title.
+- A collection's `toStructuredData` describes each of its records as one node, from tokens of its fields: `toStructuredData: ({ content }) => ({ "@type": "BlogPosting", author: content.author, image: content.cover })`. Camox fills its name (an Article's `headline`) and description from the record's title and description, and gives it one `@id` per record and locale, which every page referencing the record links. Collections may describe records as an `Organization` (a customer, a partner), never as the `WebSite`.
+- When the layout's `toStructuredData` declares nothing, the record's node is the page's main entity, dated by the record's publish times. Otherwise link the record's references from the layout, such as `toStructuredData: ({ content }) => ({ "@type": "BlogPosting", author: content.author })`. A reference to a collection without `toStructuredData` reads as the record's title. Records the page's content references that no node links are listed as the page's `mentions`.
 - To wrap the helper, pass the whole loader input through, `context` included, and return the envelope unchanged. Type it as the helper's loader (`ReturnType<typeof articlePages.loader>`) to keep `layout.Item` and `item` typed:
 
 ```tsx
@@ -162,22 +165,22 @@ The playground's `/pokedex`, `/pokemon/pikachu`, and `/pokemon-types/electric` a
 
 ## Metadata and Markdown
 
-Singleton and derived pages get the same head as curated pages: title, description, `og:*` tags, the `/og` image, and the favicon. They have no editor metadata, so the callbacks receive the loader's unwrapped `data` and the route `params` instead:
+Singleton and derived pages get the same head as curated pages: title, description, `og:*` tags, the `/og` image, and the favicon. They have no editor metadata, so the `to*` options also receive the loader's unwrapped `data` and the route `params`:
 
 ```tsx
 export const Layout = createLayout("pokemon.$name")({
   kind: "derived",
   // Other options omitted.
   loader: async ({ params }) => ({ kind: "data", data: await loadPokemon(params.name) }),
-  buildMetaTitle: ({ data, pageMetaTitle }) => `${data.name} – ${pageMetaTitle}`,
-  buildMetaDescription: ({ data }) => `${data.name} is a ${data.types.join("/")} type Pokémon.`,
+  toTitle: ({ data, page }) => `${data.name} – ${page.title}`,
+  toDescription: ({ data }) => `${data.name} is a ${data.types.join("/")} type Pokémon.`,
   toMarkdown: ({ data, params }) => [`# ${data.name}`, `Types: ${data.types.join(", ")}`],
 });
 ```
 
-- **Put `loader` before `buildMetaTitle`, `buildMetaDescription`, and `toMarkdown`.** TypeScript infers their `data` from the loader only in that order. Otherwise the loader is inferred as `never` and fails to type-check.
-- `buildMetaTitle` receives `pageMetaTitle` (the layout's `title` on these pages), `projectName`, `pageFullPath`, `data`, and `params`. The `/og` image shows its result.
-- `buildMetaDescription` is optional; without it these pages have no description.
+- **Put `loader` before `toTitle`, `toDescription`, `toImage`, `toReact`, and `toMarkdown`.** TypeScript infers their `data` from the loader only in that order. Otherwise the loader is inferred as `never` and fails to type-check.
+- `toTitle`, `toDescription`, `toImage` and `toReact` receive the same context as on curated pages (see [Layout Definitions](layout-definitions.md#the-to-options-and-their-context)), plus `data` and `params`. Here `page.title` is the layout's `title` (the record's title on record pages) and `page.description` is absent.
+- `toDescription` may return `undefined`: these pages then have no description.
 - `toMarkdown` returns the page's Markdown Representation as a list of strings. Empty strings are dropped and the rest joined with blank lines. A request with `Accept: text/markdown` gets YAML front matter (the `title` and `description` the head shows, and the page's `url`), then the live before-block Markdown, then this output, then the live after-block Markdown. Curated pages' Markdown opens with the same front matter. Without `toMarkdown`, the page answers HTML only. `throw notFound()` in the loader answers 404. Curated layouts cannot declare `toMarkdown`: their Markdown comes from their blocks.
 - The playground's Pokémon, Pokémon type, and Pokédex layouts declare these. Try `curl -H "Accept: text/markdown" http://localhost:3000/pokemon/pikachu`.