create-smoodly-app 0.0.14 → 0.0.16

package/templates/blank/scripts/seed.ts

@@ -0,0 +1,72 @@
+// The starter's content, written through the stores (never raw inserts:
+// the refs index and publish integrity are part of the point). Ships in
+// the scaffold; create-smoodly-app runs `npm run seed` after the first
+// editor. Idempotent: exits once the home page exists in the default
+// locale. Writes the same copy into every configured locale, whatever
+// their codes, so every locale's "/" resolves.
+// Run: npm run seed  (needs .env.local and a Supabase stack).
+import next from "@next/env";
+import type { PageTree } from "smoodly";
+const { loadEnvConfig } = next;
+
+loadEnvConfig(process.cwd());
+
+const { config } = await import("../smoodly/config");
+const { stores } = await import("../smoodly/server");
+const { pages, entries } = stores();
+
+const DEFAULT = config.locales.default;
+const OTHERS = config.locales.supported.filter((l) => l !== DEFAULT);
+
+if (await pages.resolvePath(DEFAULT, "/")) {
+  console.log(`Already seeded — "home" exists in "${DEFAULT}".`);
+  process.exit(0);
+}
+
+// Richtext is TipTap JSON, the stored format; RichText renders it.
+type Node = Record<string, unknown>;
+const p = (s: string): Node => ({ type: "paragraph", content: [{ type: "text", text: s }] });
+const button = (label: string, href: string): Node => ({ type: "element", attrs: { name: "button", fields: { label, href }, styles: {} } });
+const doc = (...content: Node[]) => ({ type: "doc", content });
+
+// --- the site item: name and tagline, published in every locale ------
+
+const site = await entries.create("site", { name: "My site", tagline: "Built with Smoodly" }, { locale: DEFAULT });
+await entries.setStatus("site", site.id, DEFAULT, "published");
+for (const locale of OTHERS) {
+  await entries.addLocale("site", site.id, locale, { from: DEFAULT });
+  await entries.setStatus("site", site.id, locale, "published");
+}
+
+// --- the home page: one Text section ---------------------------------
+
+const tree = {
+  meta: { description: "A new site, built with Smoodly." },
+  zones: {
+    body: [
+      {
+        id: "node-hello",
+        type: "text",
+        fields: {
+          title: "Hello",
+          body: doc(
+            p("This is your home page. Open the admin to edit this text, add sections, create pages and write posts."),
+            p("Everything you see is defined in components/ and registered in smoodly/. The README says where things are."),
+            button("Open the admin", "/admin"),
+          ),
+        },
+      },
+    ],
+  },
+} as unknown as PageTree;
+
+const home = await pages.createPage({ locale: DEFAULT, slug: "home", title: "Home", template: "home" });
+await pages.saveDraft(home.id, DEFAULT, tree);
+await pages.publish(home.id, DEFAULT);
+for (const locale of OTHERS) {
+  await pages.addLocale(home.id, locale, { from: DEFAULT, title: "Home" });
+  await pages.saveDraft(home.id, locale, tree);
+  await pages.publish(home.id, locale);
+}
+
+console.log(`Seeded the blank starter in "${[DEFAULT, ...OTHERS].join('", "')}": the home page and the site item, published.`);

package/templates/blank/smoodly/collections.ts

@@ -0,0 +1,25 @@
+import { f, smoodly } from "smoodly";
+import { text } from "./toolsets";
+
+// A collection: structured content with its own admin list, served at
+// `path` by its entry page (components/pages/Post.tsx). Fields marked
+// .localized() are stored per locale; the rest are shared across
+// locales. To add a
+// collection: copy this block, add it to `collections`, write its view
+// into a new migration with `collectionSQL` from "smoodly", and apply
+// it (supabase db push, or supabase db reset locally).
+export const posts = smoodly.collection({
+  name: "posts",
+  title: "Posts",
+  titleField: "title",
+  path: "posts",
+  order: { by: "date", direction: "desc" },
+  fields: {
+    title: f.text().localized(),
+    slug: f.slug({ from: "title" }),
+    date: f.date(),
+    body: f.richtext({ toolset: text }).localized(),
+  },
+});
+
+export const collections = [posts];

package/templates/blank/smoodly/config.ts

@@ -0,0 +1,35 @@
+import { defineConfig, f } from "smoodly";
+import { collections } from "./collections";
+import { sections } from "./sections";
+import { shared } from "./shared";
+import { elements } from "./elements";
+import { HomePage } from "@/components/pages/Home";
+import { StandardPage } from "@/components/pages/Page";
+import { PostPage } from "@/components/pages/Post";
+
+export { collections, sections, shared, elements };
+
+// The registry and the plain settings, one file. Runtime-free: nothing
+// here imports a route file or Next, so a script and the CLI's template
+// build can load it outside the app.
+export const config = defineConfig({
+  registry: {
+    sections,
+    elements,
+    collections,
+    shared,
+    pages: [HomePage, StandardPage, PostPage],
+  },
+  locales: { default: "en", supported: ["en"] },
+  // The record the site root serves.
+  homePageSlug: "home",
+  // Editors can nest pages three deep.
+  pages: { tree: { depth: 3 } },
+  // Every section gets this select beside its own styles; the section
+  // wrapper emits it as data-tone, and app/globals.css styles it.
+  styles: {
+    sections: {
+      tone: f.select(["paper", "ink"]).default("paper"),
+    },
+  },
+});

package/templates/blank/smoodly/elements.ts

@@ -0,0 +1,5 @@
+// The site's element registrations, in one list: the config registers
+// them, toolsets embed them by value, and smoodly/richtext.tsx renders them.
+import { Button } from "@/components/elements/Button";
+
+export const elements = [Button];

package/templates/blank/smoodly/sections.ts

@@ -0,0 +1,5 @@
+// The site's section registrations, in one list. config.ts puts it in
+// the registry; the stores and the renderer share the same array.
+import { Text } from "@/components/sections/Text";
+
+export const sections = [Text];

package/templates/blank/smoodly/shared.ts

@@ -0,0 +1,16 @@
+// Shared content: code-declared singletons, edited once under Globals
+// and read anywhere. `site` is an object item — fields code consumes;
+// the layout reads it through q().getShared("site"). A visual item
+// (`section: SomeSection`) renders through a section instead.
+import { f, smoodly } from "smoodly";
+
+export const site = smoodly.shared({
+  name: "site",
+  title: "Site",
+  fields: {
+    name: f.text(),
+    tagline: f.text().localized(),
+  },
+});
+
+export const shared = [site];

package/templates/blank/smoodly/toolsets.ts

@@ -0,0 +1,14 @@
+// Toolsets are values, not registrations: a richtext field names one.
+// `text` is the starter's one set — the default marks and block nodes,
+// plus the Button element. Elements are embedded by value; the config
+// must also register them (smoodly/elements.ts; defineConfig checks).
+// Relative imports on purpose: collections.ts pulls this file into
+// create-smoodly-app's template build, which runs outside the app.
+import { smoodly } from "smoodly";
+import { Button } from "../components/elements/Button";
+
+export const text = smoodly.toolset({
+  marks: ["bold", "italic", "link"],
+  nodes: ["h2", "h3", "bulletList", "orderedList", "blockquote"],
+  elements: [Button],
+});

package/templates/{next → blank}/supabase/migrations/00000000000000_smoodly.sql

@@ -37,6 +37,7 @@ create table if not exists "page_locales" (
   "draft_version_id" uuid,
   "published_version_id" uuid,
   "updated_at" timestamptz not null default now(),
+  "updated_by" text,
   primary key ("page_id", "locale")
 );
 
@@ -49,19 +50,20 @@ create or replace function "smoodly_reorder_pages"(p_ids uuid[]) returns void la
 $$;
 
 -- A version belongs to ONE locale of one page: each locale has its own
--- draft, its own publish and its own history.
+-- draft, its own publish and its own history. One row per publish plus
+-- the live draft (spec 2026-09-13 history §1): the unpublished draft row
+-- is rewritten in place and saved_at is when its content last changed.
 create table if not exists "page_versions" (
   "id" uuid primary key default gen_random_uuid(),
   "space_id" uuid not null default '00000000-0000-0000-0000-000000000000',
   "page_id" uuid not null references "pages" ("id") on delete cascade,
   "locale" text not null,
   "tree" jsonb not null,
-  "created_by" text,
-  "created_at" timestamptz not null default now()
+  "saved_at" timestamptz not null default now()
 );
 
 create index if not exists "page_versions_page_locale_idx"
-  on "page_versions" ("page_id", "locale", "created_at");
+  on "page_versions" ("page_id", "locale", "saved_at");
 
 create table if not exists "entries" (
   "id" uuid primary key default gen_random_uuid(),
@@ -98,6 +100,7 @@ create table if not exists "entry_locales" (
   "draft_version_id" uuid,
   "published_version_id" uuid,
   "updated_at" timestamptz not null default now(),
+  "updated_by" text,
   primary key ("entry_id", "locale")
 );
 
@@ -107,19 +110,19 @@ create index if not exists "entry_locales_status_idx"
 -- A version belongs to ONE locale of one entry and stores the MERGED
 -- fields (shared + localized + slug) as they were at that save, so
 -- restoring an old Finnish version restores the shared fields too.
--- Rows exist only for collections registered with `versions: true`.
+-- Rows for every collection and every shared item (spec 2026-09-14 §1).
+-- One row per publish plus the live draft (spec 2026-09-13 history §1).
 create table if not exists "entry_versions" (
   "id" uuid primary key default gen_random_uuid(),
   "space_id" uuid not null default '00000000-0000-0000-0000-000000000000',
   "entry_id" uuid not null references "entries" ("id") on delete cascade,
   "locale" text not null,
   "fields" jsonb not null,
-  "created_by" text,
-  "created_at" timestamptz not null default now()
+  "saved_at" timestamptz not null default now()
 );
 
 create index if not exists "entry_versions_entry_locale_idx"
-  on "entry_versions" ("entry_id", "locale", "created_at");
+  on "entry_versions" ("entry_id", "locale", "saved_at");
 
 -- v1 reorder (DESIGN.md §3 Manual ordering): rewrite sort 1..N in ONE
 -- statement. Deliberately does not touch updated_at — a drag must not
@@ -498,21 +501,7 @@ create policy "smoodly_media_write" on storage.objects for all
   using ("bucket_id" = 'media' and (select public."smoodly_key_kind"()) = 'write' and not (select public."smoodly_space_key_revoked"()) and split_part("name", '/', 1) = (select public."smoodly_current_space"())::text)
   with check ("bucket_id" = 'media' and (select public."smoodly_key_kind"()) = 'write' and not (select public."smoodly_space_key_revoked"()) and split_part("name", '/', 1) = (select public."smoodly_current_space"())::text);
 
-create or replace view "people" with (security_invoker = true) as
-select
-  e."id",
-  l."locale",
-  l."slug",
-  e."sort",
-  e."created_at",
-  l."updated_at",
-  e."fields"->>'name' as "name",
-  l."fields"->>'role' as "role"
-from "entries" e
-join "entry_locales" l on l."entry_id" = e."id"
-where e."collection" = 'people' and l."status" = 'published';
-
-create or replace view "articles" with (security_invoker = true) as
+create or replace view "posts" with (security_invoker = true) as
 select
   e."id",
   l."locale",
@@ -520,17 +509,13 @@ select
   e."sort",
   e."created_at",
   l."updated_at",
-  v."fields"->>'title' as "title",
-  v."fields"->'image' as "image",
-  (v."fields"->>'date')::timestamptz as "date",
-  v."fields"->>'author' as "author",
-  v."fields"->>'excerpt' as "excerpt",
-  v."fields"->'body' as "body",
-  v."fields"->'tags' as "tags"
+  coalesce(v."fields", e."fields" || l."fields")->>'title' as "title",
+  (coalesce(v."fields", e."fields" || l."fields")->>'date')::timestamptz as "date",
+  coalesce(v."fields", e."fields" || l."fields")->'body' as "body"
 from "entries" e
 join "entry_locales" l on l."entry_id" = e."id"
-join "entry_versions" v on v."id" = l."published_version_id"
-where e."collection" = 'articles' and l."status" = 'published';
+left join "entry_versions" v on v."id" = l."published_version_id"
+where e."collection" = 'posts' and l."status" = 'published';
 
-create index if not exists "entries_articles_date_idx"
-  on "entries" (("fields"->'date')) where "collection" = 'articles';
+create index if not exists "entries_posts_date_idx"
+  on "entries" (("fields"->'date')) where "collection" = 'posts';

package/templates/blank-intl/AGENTS.md

@@ -0,0 +1,50 @@
+# Working in this Smoodly site
+
+This is a Next.js app with Smoodly installed: content lives in Supabase,
+the admin is mounted at /admin from the `smoodly` package, and the site
+reads content through `smoodly/server.ts`. Read README.md first: it says
+where things are.
+
+## Rules
+
+- **Register everything in `smoodly/`.** Every section, element,
+  collection and shared item is listed in its barrel (`sections.ts`,
+  `elements.ts`, `collections.ts`, `shared.ts`) and `smoodly/config.ts`
+  is the one registry. A component that is not registered does not exist
+  for the admin.
+- **A new collection is a new migration.** Write its view with
+  `collectionSQL` from `smoodly` into a new file under
+  `supabase/migrations/`, then apply it: `supabase db push` (hosted) or
+  `supabase db reset` (local). The admin cannot list a collection whose
+  view is missing.
+- **Seed through the stores.** `scripts/seed.ts` is starter content,
+  written through the page and entry stores, never raw SQL. It is
+  idempotent; run it with `npm run seed`.
+- **Never import the admin into the site.** Nothing under `app/(site)`,
+  `app/[locale]` or `components/` may import `@/smoodly/admin` or
+  `smoodly/admin/next`; the admin's chunk must not reach visitors.
+- **Two root layouts.** The site's layout lives in its route group or
+  locale segment and is never the admin's parent; `app/(smoodly)/admin`
+  is a second root layout. Do not add an `app/layout.tsx`.
+- **Toolsets and elements.** A richtext field names a toolset
+  (`smoodly/toolsets.ts`); a toolset embeds elements by value; the config
+  must register those elements too. Files the toolset imports use
+  relative paths, not `@/`.
+- **Section styles are data attributes.** `<smoodly.Section>` renders the
+  root element and emits the config's section styles as `data-*`
+  attributes; `app/globals.css` styles them. Marks
+  (`smoodly.marks(schema)`) tie rendered elements to fields so the
+  editor can select and edit them in place.
+- **Multilingual sites.** Content locales are Smoodly's; URL locales are
+  next-intl's. The locale set is `i18n/routing.ts`. UI strings of the
+  site's own go through next-intl's messages in `messages/<locale>.json`.
+- **Fixed versus open pages.** A page shape with a `slug` is fixed: one
+  record, created for you, never deleted. Without one it is open: editors
+  create as many as they like.
+
+## Commands
+
+    npm run dev          # http://localhost:3000, /admin is the editor
+    npm run build        # next build
+    npm run seed         # starter content, idempotent
+    npm run typecheck    # tsc --noEmit

package/templates/blank-intl/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

package/templates/blank-intl/README.md

@@ -0,0 +1,76 @@
+# Smoodly site
+
+Created by `create-smoodly-app`. Content lives in Supabase; the admin is
+mounted at `/admin` from the `smoodly` package. AGENTS.md holds the rules
+for an agent (or a person) building the site.
+
+    npm run dev          # http://localhost:3000 — /admin is the editor
+
+## Where things are
+
+- `app/[locale]/page.tsx` — the home page: one line calling renderSmoodlyPath([], { locale }).
+- `app/[locale]/[...path]/page.tsx` — every other page and every collection entry, at any depth, with translated segments per locale.
+- `app/[locale]/layout.tsx` — the site's root layout: `app/globals.css`, the locale links, the footer line from the `site` item; the admin has its own under `app/(smoodly)/admin/`.
+- `i18n/routing.ts` — the locales and the default; `smoodly/config.ts` reads them from here. `i18n/request.ts` and `i18n/navigation.ts` are next-intl's stock files; `proxy.ts` is its locale routing (`/admin` excluded). UI strings go in `messages/<locale>.json`.
+- `components/pages/` — the page shapes and the entry page: `Home` (fixed at /, one freeform zone), `Page` (open, editors create many), `Post` (the entry page for posts).
+- `components/sections/Text.tsx` — the one section: a title and a richtext body. Listed in `smoodly/sections.ts`.
+- `components/elements/Button.tsx` — the one element: a link styled as a button, embedded in richtext through `smoodly/toolsets.ts`.
+- `smoodly/` — the wiring: `config.ts` (the registry and settings), `collections.ts` (posts), `shared.ts` (the site item), `sections.ts`, `elements.ts`, `toolsets.ts`, `server.ts` (stores, site layer, renderer, the read API `q`), `ops.ts` (the admin's one server action), `admin.tsx` (the admin mount), `richtext.tsx` (the bound renderer).
+- `scripts/seed.ts` — the home page and the site item, written through the stores. `npm run seed` is idempotent.
+- `app/globals.css` — a reset, a container, the two tones. Replace it.
+- `.env.local` — `SMOODLY_URL`, `SMOODLY_SECRET_KEY`, `SMOODLY_PUBLISHABLE_KEY`.
+
+## Add a section
+
+Copy `components/sections/Text.tsx`, give the schema a new `name` and
+`title`, declare its fields, render them inside `<smoodly.Section>` with
+marks on each field. Add it to `sections` in `smoodly/sections.ts`, then
+to the `sections` list of every zone that may hold it in
+`components/pages/*.tsx`. It appears in the editor's "+" picker.
+
+## Add an element
+
+Copy `components/elements/Button.tsx` (relative imports only). Add it to
+`elements` in `smoodly/elements.ts` and to the `elements` of the toolset
+in `smoodly/toolsets.ts` that may embed it. It appears in the richtext
+editor's "/" menu.
+
+## Add a collection
+
+Copy the `posts` block in `smoodly/collections.ts`, add the new
+collection to `collections`, and write its entry page by copying
+`components/pages/Post.tsx` (register it in `config.ts` under `pages`).
+Then create a migration with its view:
+
+    import { collectionSQL } from "smoodly";
+    import { people } from "./smoodly/collections";
+    console.log(collectionSQL(people));
+
+Save the output as `supabase/migrations/<timestamp>_people.sql` and apply
+it with `supabase db push` (hosted) or `supabase db reset` (local).
+
+## Add a shared item
+
+Copy the `site` block in `smoodly/shared.ts` and add it to `shared`. An
+object item (`fields`) is read in code with `q().getShared("name")`; a
+visual item (`section: SomeSection`) renders through its section and can
+be placed on pages from the picker's Shared group. Edit both under
+Globals in the admin.
+
+Reseed an empty database any time with `npm run seed`.
+
+## Editors
+
+Anyone who may open `/admin` is a Supabase Auth user with a row in the
+`editors` table. To add one: create the user in Supabase Studio
+(Authentication → Users), then in the SQL editor:
+
+    insert into editors (user_id, role) values ('<the user id>', 'editor');
+
+## Hosted Supabase
+
+    supabase init        # if the CLI has not been set up here yet
+    supabase link        # pick the project
+    supabase db push     # applies supabase/migrations/
+
+Then put the project's URL and keys in `.env.local`.

package/templates/blank-intl/app/[locale]/layout.tsx

@@ -0,0 +1,42 @@
+import type { ReactNode } from "react";
+import { notFound } from "next/navigation";
+import { hasLocale, NextIntlClientProvider } from "next-intl";
+import { routing } from "@/i18n/routing";
+import { href, q } from "@/smoodly/server";
+import "../globals.css";
+
+// The site's root layout under the locale segment; the admin has its own
+// under app/(smoodly)/admin, outside [locale], as a second root layout.
+// The `site` shared item gives the document title and the footer line,
+// read per locale through `q`, null until published in this locale. The
+// locale links are the visitor's only language switch, since locale
+// detection is off (see i18n/routing.ts).
+export async function generateMetadata({ params }: { params: Promise<{ locale: string }> }) {
+  const { locale } = await params;
+  const site = await q().getShared("site", { locale });
+  return { title: site?.name ?? "Smoodly site" };
+}
+
+export default async function LocaleLayout({ children, params }: { children: ReactNode; params: Promise<{ locale: string }> }) {
+  const { locale } = await params;
+  if (!hasLocale(routing.locales, locale)) notFound();
+  const site = await q().getShared("site", { locale });
+  const locales = routing.locales.map((code) => ({ code, url: href("/", code), current: code === locale }));
+  return (
+    <html lang={locale}>
+      <body>
+        <NextIntlClientProvider>
+          {locales.length > 1 && (
+            <nav className="container locales" aria-label="Language">
+              {locales.map((l) => (
+                <a key={l.code} href={l.url} aria-current={l.current ? "page" : undefined}>{l.code}</a>
+              ))}
+            </nav>
+          )}
+          <main>{children}</main>
+          {site && <footer className="container site-footer">{site.name} · {site.tagline}</footer>}
+        </NextIntlClientProvider>
+      </body>
+    </html>
+  );
+}

package/templates/blank-intl/app/globals.css

@@ -0,0 +1,47 @@
+/* The blank starter's one stylesheet: a reset, a system font, a
+   container, prose defaults, the button element, and the two tones the
+   config's section style emits as data-tone. Replace freely. */
+
+:root {
+  --paper: #ffffff;
+  --ink: #1a1a1a;
+  --muted: #666666;
+  --container: 720px;
+}
+
+* { box-sizing: border-box; }
+html, body { margin: 0; padding: 0; }
+body {
+  background: var(--paper);
+  color: var(--ink);
+  font-family: system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+  line-height: 1.5;
+  min-height: 100vh;
+  display: flex;
+  flex-direction: column;
+}
+main { flex: 1; }
+a { color: inherit; }
+
+.container { width: min(var(--container), 100% - 2rem); margin-inline: auto; }
+
+/* Sections carry data-tone from the config's section styles. */
+[data-tone="paper"] { background: var(--paper); color: var(--ink); }
+[data-tone="ink"] { background: var(--ink); color: var(--paper); }
+section[data-tone] { padding-block: 3rem; }
+
+.prose > * + * { margin-top: 1em; }
+.prose h1, .prose h2, .prose h3 { line-height: 1.2; }
+
+/* The Button element, inside richtext. */
+.button {
+  display: inline-block;
+  padding: 0.6em 1.2em;
+  border: 1px solid currentColor;
+  border-radius: 4px;
+  text-decoration: none;
+}
+
+.site-footer { padding-block: 2rem; color: var(--muted); font-size: 0.875rem; }
+.locales { display: flex; gap: 0.75rem; padding-block: 1rem; font-size: 0.875rem; }
+.locales a[aria-current="page"] { font-weight: 600; }

package/templates/blank-intl/components/elements/Button.tsx

@@ -0,0 +1,26 @@
+import { f, smoodly, type Props } from "smoodly";
+
+// An Element: a small registered block editors insert inside richtext
+// (the `richtext` context). This one is a link styled as a button. Copy
+// this file to add another element, then list it in smoodly/elements.ts
+// and in the toolsets that may embed it (smoodly/toolsets.ts).
+// Relative imports only in this file and in smoodly/toolsets.ts: the
+// template build imports them outside the app, where `@/` has no mapping.
+export const buttonSchema = smoodly.schema.element({
+  name: "button",
+  title: "Button",
+  icon: "→",
+  description: "A link styled as a button.",
+  contexts: ["richtext"],
+  fields: {
+    label: f.text().max(60),
+    href: f.link(),
+  },
+  sample: { label: "Read more", href: "/" },
+});
+
+function ButtonView({ label, href }: Props<typeof buttonSchema>) {
+  return <a className="button" href={href}>{label}</a>;
+}
+
+export const Button = smoodly.element(buttonSchema, ButtonView);

package/templates/blank-intl/components/pages/Home.tsx

@@ -0,0 +1,22 @@
+import { smoodly, z, Zone, type Props } from "smoodly";
+import { Text } from "../sections/Text";
+
+// A page shape: zones declared, <Zone /> placed, one file. `slug` makes
+// it fixed — one record editors can neither delete nor duplicate — and
+// the config's homePageSlug maps that record to "/". The body is a
+// freeform zone over the sections listed here.
+export const homeSchema = smoodly.schema.page({
+  name: "home",
+  title: "Home",
+  slug: "home",
+  zones: {
+    body: z.freeform({ sections: [Text] }),
+  },
+  meta: { seo: true },
+});
+
+function HomeView({ zones }: Props<typeof homeSchema>) {
+  return <Zone of={zones.body} />;
+}
+
+export const HomePage = smoodly.page(homeSchema, HomeView);

package/templates/blank-intl/components/pages/Page.tsx

@@ -0,0 +1,25 @@
+import { smoodly, z, Zone, type Props } from "smoodly";
+import { Text } from "../sections/Text";
+
+// An open page shape: no `slug`, so editors create as many as they like,
+// anywhere in the tree the config allows. `page` is where this one sits
+// (title, path, ancestors, children).
+export const pageSchema = smoodly.schema.page({
+  name: "page",
+  title: "Page",
+  zones: {
+    body: z.freeform({ sections: [Text] }),
+  },
+  meta: { seo: true },
+});
+
+function PageView({ zones, page }: Props<typeof pageSchema>) {
+  return (
+    <>
+      <h1 className="container">{page.title}</h1>
+      <Zone of={zones.body} />
+    </>
+  );
+}
+
+export const StandardPage = smoodly.page(pageSchema, PageView);

package/templates/blank-intl/components/pages/Post.tsx

@@ -0,0 +1,21 @@
+import { smoodly, type EntryPageProps } from "smoodly";
+import { RichText } from "@/smoodly/richtext";
+import { posts } from "@/smoodly/collections";
+
+// The entry page for `posts`, served at /posts/<slug>. It receives the
+// entry's fields; the body is richtext rendered by the site's bound
+// RichText, which knows the registered elements.
+type PostFields = { title: string; date?: string; body?: unknown };
+
+function PostView({ entry }: EntryPageProps) {
+  const post = entry.fields as PostFields;
+  return (
+    <article className="container prose">
+      <h1>{post.title}</h1>
+      {post.date && <p><time dateTime={post.date}>{post.date.slice(0, 10)}</time></p>}
+      <RichText doc={post.body} />
+    </article>
+  );
+}
+
+export const PostPage = smoodly.entryPage(posts, PostView);

package/templates/blank-intl/components/sections/Text.tsx

@@ -0,0 +1,39 @@
+import { f, smoodly, type Props } from "smoodly";
+import { RichText } from "@/smoodly/richtext";
+import { text } from "@/smoodly/toolsets";
+
+// A section: a title and a richtext body. Registered in
+// smoodly/sections.ts and allowed in the page shapes' zones
+// (components/pages/*.tsx). Copy this file to add another section.
+// The section wrapper renders the root element and emits the config's
+// section styles as data attributes (data-tone here) for app/globals.css.
+export const textSchema = smoodly.schema.section({
+  name: "text",
+  title: "Text",
+  description: "A title and a body of text.",
+  fields: {
+    title: f.text(),
+    body: f.richtext({ toolset: text }),
+  },
+  sample: {
+    title: "Hello",
+    body: { type: "doc", content: [{ type: "paragraph", content: [{ type: "text", text: "Write something here." }] }] },
+  },
+});
+
+// Marks tie the rendered elements to their fields, so the editor can
+// select and inline-edit them on the canvas.
+const m = smoodly.marks(textSchema);
+
+function TextView({ title, body, styles }: Props<typeof textSchema>) {
+  return (
+    <smoodly.Section styles={styles}>
+      <div className="container prose">
+        <h2 {...m.field("title")}>{title}</h2>
+        <div {...m.field("body")}><RichText doc={body} /></div>
+      </div>
+    </smoodly.Section>
+  );
+}
+
+export const Text = smoodly.section(textSchema, TextView);

package/templates/blank-intl/messages/en.json

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