create-smoodly-app 0.0.4 → 0.0.6

package/templates/next/smoodly/server.ts

@@ -0,0 +1,72 @@
+// Server-only glue: the client, both stores, the site layer and the
+// renderer, constructed lazily so `next build` doesn't need env vars at
+// import time. The env shape is the package's (SMOODLY_*); whether the
+// secret is a service-role key or a cloud write key is invisible here.
+import {
+  createSmoodlyClient, createSmoodlySite, smoodlyEnv, SupabaseEntryStore, SupabasePageStore, SupabasePathIndex,
+} from "smoodly";
+import { supabaseAdminAuth, type AdminAuth, type AuthConfig } from "smoodly/admin/next";
+import { createPageRenderer, type PageRegistration } from "smoodly/next";
+import type { SupabaseClient } from "@supabase/supabase-js";
+import { collections, config, sections } from "./config";
+
+let cached: { db: SupabaseClient; pages: SupabasePageStore; entries: SupabaseEntryStore; auth: AdminAuth } | null = null;
+
+function bound() {
+  if (cached) return cached;
+  const env = smoodlyEnv();
+  const db = createSmoodlyClient(env);
+  // ONE path index for both stores: pages and entries share the URL space.
+  const paths = new SupabasePathIndex(db);
+  const locales = config.locales;
+  const entries = new SupabaseEntryStore(db, collections, { paths, locales });
+  const pages = new SupabasePageStore(db, {
+    sections, entries, paths, locales,
+    homePageSlug: config.homePageSlug,
+    tree: config.pages?.tree,
+  });
+  const auth = supabaseAdminAuth({ authUrl: env.authUrl, authKey: env.authKey, db });
+  cached = { db, pages, entries, auth };
+  return cached;
+}
+
+export function stores() {
+  const { pages, entries } = bound();
+  return { pages, entries };
+}
+
+/** The server-side client (seed script, one-off admin tasks). */
+export const client = () => bound().db;
+
+/** The admin gate: session verified against the auth project, editors row read with the write key. */
+export const adminAuth = () => bound().auth;
+
+/** What the browser needs to sign in — public values only. */
+export function publicAuth(): AuthConfig {
+  const env = smoodlyEnv();
+  return { url: env.authUrl, key: env.authKey };
+}
+
+/** Locale-relative CMS path → site URL: the one seam for the renderer
+ * (metadata alternates, the `page` prop's links) and the admin (canvas,
+ * View live). The identity for a single-language site; with next-intl it
+ * becomes a locale-prefixing lookup. */
+export const href = (path: string, _locale: string) => path;
+
+/** The site layer: (locale, path) → page or entry, and the content API
+ * (site.getPagesTree for menus, site.getEntries for lists). */
+export const site = createSmoodlySite({
+  stores,
+  collections,
+  sections,
+  locales: config.locales,
+  homePageSlug: config.homePageSlug,
+});
+
+/** The two route files call these. */
+export const { renderSmoodlyPath, smoodlyMetadata, renderSmoodlyPage, smoodlyPageMetadata } = createPageRenderer({
+  site,
+  sections,
+  pages: (config.registry.pages ?? []) as PageRegistration[],
+  href,
+});

package/templates/next/supabase/migrations/00000000000000_smoodly.sql

@@ -11,18 +11,37 @@ $$;
 create table if not exists "pages" (
   "id" uuid primary key default gen_random_uuid(),
   "space_id" uuid not null default '00000000-0000-0000-0000-000000000000',
+  "parent_id" uuid references "pages" ("id") on delete restrict,
   "slug" text not null,
-  "template" text not null,
+  "title" text not null,
+  "i18n" jsonb,
+  "template" text,
   "status" text not null default 'draft',
   "sort" numeric,
   "locales" text[],
   "draft_version_id" uuid,
   "published_version_id" uuid,
   "created_at" timestamptz not null default now(),
-  "updated_at" timestamptz not null default now(),
-  unique ("space_id", "slug")
+  "updated_at" timestamptz not null default now()
 );
 
+-- The tree is the URL (spec 2026-09-05 §1): a node stores its own segment
+-- and its parent. Siblings are unique per segment; NULLS NOT DISTINCT so
+-- two root nodes cannot share one either. template null = folder.
+create unique index if not exists "pages_sibling_slug_key"
+  on "pages" ("space_id", "parent_id", "slug") nulls not distinct;
+
+create index if not exists "pages_parent_idx"
+  on "pages" ("space_id", "parent_id", "sort");
+
+-- Sibling reorder for pages: same shape as smoodly_reorder for entries.
+create or replace function "smoodly_reorder_pages"(p_ids uuid[]) returns void language sql as $$
+  update "pages" pg set "sort" = u.ord
+  from unnest(p_ids) with ordinality as u(id, ord)
+  where pg."id" = u.id
+    and pg."space_id" = "smoodly_current_space"();
+$$;
+
 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',
@@ -52,6 +71,7 @@ create table if not exists "entries" (
   "id" uuid primary key default gen_random_uuid(),
   "space_id" uuid not null default '00000000-0000-0000-0000-000000000000',
   "collection" text not null,
+  "parent_id" uuid references "entries" ("id") on delete restrict,
   "fields" jsonb not null default '{}'::jsonb,
   "i18n" jsonb,
   "status" text not null default 'draft',
@@ -61,8 +81,22 @@ create table if not exists "entries" (
   "updated_at" timestamptz not null default now()
 );
 
-create unique index if not exists "entries_slug_key"
-  on "entries" ("space_id", "collection", ("fields"->>'slug'));
+-- Entry slugs are unique among SIBLINGS, like pages: one rule for every
+-- node in the tree, and the URL is the tree. NULLS NOT DISTINCT so two
+-- ROOT entries (parent_id null) cannot share a slug either. The partial
+-- predicate keeps absent, null, empty or non-string slugs out of the
+-- index entirely: with NULLS NOT DISTINCT a null slug would otherwise
+-- collide with the next null slug, and a collection with no slug field
+-- at all could hold only one entry per parent. jsonb_typeof(...) =
+-- 'string' is required because ->> renders ANY JSON scalar as text —
+-- a number, boolean or null slug would otherwise print as non-empty
+-- text and claim the index; only a non-empty string slug claims a URL,
+-- absent, null, empty or non-string slugs never conflict — the same
+-- rule as slugOf in paths.ts. A flat collection (every entry a root)
+-- therefore behaves exactly as per-collection uniqueness did.
+create unique index if not exists "entries_sibling_slug_key"
+  on "entries" ("space_id", "collection", "parent_id", ("fields"->>'slug')) nulls not distinct
+  where (jsonb_typeof("fields"->'slug') = 'string' and "fields"->>'slug' <> '');
 
 create index if not exists "entries_collection_status_idx"
   on "entries" ("space_id", "collection", "status");
@@ -70,6 +104,9 @@ create index if not exists "entries_collection_status_idx"
 create index if not exists "entries_collection_sort_idx"
   on "entries" ("space_id", "collection", "sort");
 
+create index if not exists "entries_parent_idx"
+  on "entries" ("space_id", "collection", "parent_id");
+
 -- v1 reorder (DESIGN.md §3 Manual ordering): rewrite sort 1..N in ONE
 -- statement. Deliberately does not touch updated_at — a drag must not
 -- make the whole collection look freshly edited. Scoped to the current
@@ -95,6 +132,38 @@ create table if not exists "refs" (
   primary key ("source_kind", "source_id", "source_field", "target_id")
 );
 
+-- The URL index (spec 2026-09-05 §4): the refs counterpart for paths.
+-- Derived — the stores rewrite a target's rows on every create, rename,
+-- move and delete — so one primary-key hit resolves any URL in any locale
+-- and no page or entry can share a URL with another in any locale.
+-- Rows exist for drafts too (the editor needs them); the read policy
+-- admits a row only when its target is published.
+create table if not exists "paths" (
+  "space_id" uuid not null default '00000000-0000-0000-0000-000000000000',
+  "locale" text not null,
+  "path" text not null,
+  "kind" text not null check ("kind" in ('page', 'entry')),
+  "target_id" uuid not null,
+  primary key ("space_id", "locale", "path")
+);
+
+create index if not exists "paths_target_idx"
+  on "paths" ("space_id", "kind", "target_id");
+
+-- Replace the targets' rows with the given rows in ONE call: a SQL
+-- function runs in the caller's transaction, so a primary-key collision
+-- rolls the whole rewrite back. Inserted rows get their space from the
+-- a_set_space trigger (the claim, or the default space).
+create or replace function "smoodly_rewrite_paths"(p_targets jsonb, p_rows jsonb) returns void language sql as $$
+  delete from "paths" p
+  using jsonb_to_recordset(p_targets) as t(kind text, id uuid)
+  where p."kind" = t.kind and p."target_id" = t.id
+    and p."space_id" = "smoodly_current_space"();
+  insert into "paths" ("locale", "path", "kind", "target_id")
+  select r.locale, r.path, r.kind, r.id
+  from jsonb_to_recordset(p_rows) as r(locale text, path text, kind text, id uuid);
+$$;
+
 -- RLS on every core table. The service role bypasses it (self-host
 -- adapters untouched). The policy set that follows (space layer) admits
 -- a key to its own space: everything for a write key, published rows for
@@ -108,6 +177,7 @@ alter table "saved_sections" enable row level security;
 alter table "global_sections" enable row level security;
 alter table "entries" enable row level security;
 alter table "refs" enable row level security;
+alter table "paths" enable row level security;
 
 -- ── Cloud state (spec 2026-09-04 §1): three ordinary tables, shipped
 -- for everyone with ONE definition. Self-host fills them by hand or
@@ -234,6 +304,10 @@ drop trigger if exists "smoodly_a_set_space" on "refs";
 create trigger "smoodly_a_set_space" before insert on "refs"
   for each row execute function "smoodly_set_space"();
 
+drop trigger if exists "smoodly_a_set_space" on "paths";
+create trigger "smoodly_a_set_space" before insert on "paths"
+  for each row execute function "smoodly_set_space"();
+
 drop trigger if exists "smoodly_a_set_space" on "editors";
 create trigger "smoodly_a_set_space" before insert on "editors"
   for each row execute function "smoodly_set_space"();
@@ -262,6 +336,10 @@ drop trigger if exists "smoodly_b_row_cap" on "refs";
 create trigger "smoodly_b_row_cap" before insert on "refs"
   for each row execute function "smoodly_enforce_row_cap"();
 
+drop trigger if exists "smoodly_b_row_cap" on "paths";
+create trigger "smoodly_b_row_cap" before insert on "paths"
+  for each row execute function "smoodly_enforce_row_cap"();
+
 drop policy if exists "smoodly_write" on "pages";
 create policy "smoodly_write" on "pages" for all
   using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write')
@@ -308,6 +386,15 @@ create policy "smoodly_write" on "refs" for all
   using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write')
   with check ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
 
+drop policy if exists "smoodly_write" on "paths";
+create policy "smoodly_write" on "paths" for all
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write')
+  with check ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_read" on "paths";
+create policy "smoodly_read" on "paths" for select
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (("kind" = 'page' and exists (select 1 from "pages" p where p."id" = "paths"."target_id" and p."status" = 'published')) or ("kind" = 'entry' and exists (select 1 from "entries" e where e."id" = "paths"."target_id" and e."status" = 'published'))));
+
 drop policy if exists "smoodly_write" on "editors";
 create policy "smoodly_write" on "editors" for all
   using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write')

package/templates/next/tsconfig.json

@@ -17,6 +17,11 @@
     "isolatedModules": true,
     "jsx": "react-jsx",
     "incremental": true,
+    "paths": {
+      "@/*": [
+        "./*"
+      ]
+    },
     "plugins": [
       {
         "name": "next"

package/templates/next-intl/README.md

@@ -0,0 +1,40 @@
+# Smoodly site
+
+Created by `create-smoodly-app`. Content lives in Supabase; the admin is
+mounted at `/admin` from the `smoodly` package.
+
+    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 (`<html lang>`, next-intl's provider); 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).
+- `components/pages/` — the page shapes and entry pages: schema + view, one file each.
+- `components/sections/` — the building blocks editors compose with. Add one, list it in `smoodly/sections.ts`.
+- `smoodly/collections.ts` — structured content (people, articles). Add a collection, then add its view to a new migration with `collectionSQL` from `smoodly`.
+- `smoodly/` — the wiring: `config.ts` (the registry and settings), `collections.ts`, `sections.ts`, `server.ts` (stores, site layer, renderer), `ops.ts` (the admin's one server action), `admin.tsx` (the admin mount).
+- `.env.local` — `SMOODLY_URL`, `SMOODLY_SECRET_KEY`, `SMOODLY_PUBLISHABLE_KEY`.
+
+Translated URLs: a page's slug and title are edited per locale in the
+admin's page settings; a collection's base segment per locale is its
+`path` in `smoodly/collections.ts`. UI strings of your own go through
+next-intl's messages — add `messages` in `i18n/request.ts`:
+https://next-intl.dev/docs/usage/configuration
+
+## 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/next-intl/_gitignore

@@ -0,0 +1,5 @@
+node_modules/
+.next/
+.env.local
+next-env.d.ts
+*.tsbuildinfo

package/templates/next-intl/app/(smoodly)/admin/[[...segments]]/page.tsx

@@ -0,0 +1 @@
+export { AdminPage as default } from "@/smoodly/admin";

package/templates/next-intl/app/(smoodly)/admin/layout.tsx

@@ -0,0 +1,15 @@
+import type { ReactNode } from "react";
+import { AdminLayout } from "@/smoodly/admin";
+
+// The admin's own root layout: the site's is app/[locale]/layout.tsx and
+// the admin sits outside the locale segment (the proxy skips /admin), so
+// Next needs a second <html> here.
+export default function AdminRootLayout({ children }: { children: ReactNode }) {
+  return (
+    <html lang="en">
+      <body>
+        <AdminLayout>{children}</AdminLayout>
+      </body>
+    </html>
+  );
+}

package/templates/next-intl/app/[locale]/[...path]/page.tsx

@@ -0,0 +1,18 @@
+import { renderSmoodlyPath, smoodlyMetadata } from "@/smoodly/server";
+
+type Params = Promise<{ locale: string; path: string[] }>;
+type SearchParams = Promise<Record<string, string | string[] | undefined>>;
+
+// Smoodly: everything else — pages at any depth and collection entries
+// under their `path`, with translated segments per locale. Add
+// app/[locale]/<segment>/page.tsx beside this file and it wins for that
+// exact path; deeper paths still resolve here.
+export async function generateMetadata({ params }: { params: Params }) {
+  const { locale, path } = await params;
+  return smoodlyMetadata(path, { locale });
+}
+
+export default async function Page({ params, searchParams }: { params: Params; searchParams: SearchParams }) {
+  const { locale, path } = await params;
+  return renderSmoodlyPath(path, { locale, searchParams });
+}

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

@@ -0,0 +1,21 @@
+import type { ReactNode } from "react";
+import { notFound } from "next/navigation";
+import { hasLocale, NextIntlClientProvider } from "next-intl";
+import { routing } from "@/i18n/routing";
+
+export const metadata = { title: "Smoodly site" };
+
+// The site's root layout. The admin has its own under app/(smoodly)/admin —
+// two root layouts, a full page load between them, which is fine: they
+// are separate apps in spirit.
+export default async function LocaleLayout({ children, params }: { children: ReactNode; params: Promise<{ locale: string }> }) {
+  const { locale } = await params;
+  if (!hasLocale(routing.locales, locale)) notFound();
+  return (
+    <html lang={locale}>
+      <body>
+        <NextIntlClientProvider>{children}</NextIntlClientProvider>
+      </body>
+    </html>
+  );
+}

package/templates/next-intl/app/[locale]/page.tsx

@@ -0,0 +1,15 @@
+import { renderSmoodlyPath, smoodlyMetadata } from "@/smoodly/server";
+
+type Params = Promise<{ locale: string }>;
+type SearchParams = Promise<Record<string, string | string[] | undefined>>;
+
+// Smoodly: the home page, in the locale next-intl's proxy resolved. Editing
+// this file replaces or wraps the CMS home; the shapes it can render live
+// in components/pages/.
+export async function generateMetadata({ params }: { params: Params }) {
+  return smoodlyMetadata([], { locale: (await params).locale });
+}
+
+export default async function Page({ params, searchParams }: { params: Params; searchParams: SearchParams }) {
+  return renderSmoodlyPath([], { locale: (await params).locale, searchParams });
+}

package/templates/next-intl/components/pages/Article.tsx

@@ -0,0 +1,15 @@
+import { smoodly } from "smoodly";
+import { articles } from "@/smoodly/collections";
+
+// The entry page for `articles`, served at the collection's `path`
+// (/posts/<slug>). Fields only; refs arrive resolved (author is a person).
+export const ArticlePage = smoodly.entryPage(articles, ({ entry, path }) => {
+  const a = entry.fields as { title: string; excerpt?: string; author?: { name: string; role?: string } | null };
+  return (
+    <article data-path={path}>
+      <h1>{a.title}</h1>
+      {a.author && <p>By {a.author.name}{a.author.role ? `, ${a.author.role}` : ""}</p>}
+      {a.excerpt && <p>{a.excerpt}</p>}
+    </article>
+  );
+});

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

@@ -0,0 +1,35 @@
+import { smoodly, z, Zone, type Props } from "smoodly";
+import { Hero } from "../sections/Hero";
+import { ArticleList } from "../sections/ArticleList";
+import { CtaBanner } from "../sections/CtaBanner";
+
+// A page shape: zones declared, <Zone /> placed, one file (DESIGN.md §3).
+// `slug` makes it fixed — one record the editor can neither delete nor
+// duplicate — and the config's homePageSlug maps that record to "/".
+export const homeSchema = smoodly.schema.page({
+  name: "home",
+  title: "Home",
+  slug: "home",
+  zones: {
+    hero: z.sections([Hero]).max(1),
+    body: z.freeform({ sections: [ArticleList] }),
+    // Locked: fields only. One CtaBanner, always there, never movable.
+    prefooter: z.locked(CtaBanner),
+  },
+  meta: { seo: true },
+});
+
+function HomeView({ zones }: Props<typeof homeSchema>) {
+  return (
+    <>
+      <Zone of={zones.hero} />
+      <Zone of={zones.body} />
+      <Zone of={zones.prefooter} />
+      <footer>
+        <p>Hard-coded footer — owned by the developer, invisible to the editor.</p>
+      </footer>
+    </>
+  );
+}
+
+export const HomePage = smoodly.page(homeSchema, HomeView);

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

@@ -0,0 +1,40 @@
+import Link from "next/link";
+import { smoodly, z, Zone, type Props } from "smoodly";
+import { Hero } from "../sections/Hero";
+import { ArticleList } from "../sections/ArticleList";
+import { CtaBanner } from "../sections/CtaBanner";
+
+// Open registration: editors create as many of these as they like, at
+// any depth the config allows. `page` is where this one sits in the tree.
+export const pageSchema = smoodly.schema.page({
+  name: "page",
+  title: "Page",
+  zones: {
+    hero: z.sections([Hero]).max(1),
+    body: z.freeform({ sections: [ArticleList] }),
+    prefooter: z.locked(CtaBanner),
+  },
+  meta: { seo: true },
+});
+
+function PageView({ zones, page }: Props<typeof pageSchema>) {
+  return (
+    <>
+      {page.ancestors.length > 0 && (
+        // `url` is the ancestor's site URL through the app's href seam
+        // (/fi/yritys under next-intl); `path` would be the bare CMS path.
+        <nav aria-label="Breadcrumb">
+          {page.ancestors.map((a) => (
+            <span key={a.path}>{a.hasPage ? <Link href={a.url}>{a.title}</Link> : a.title} / </span>
+          ))}
+          {page.title}
+        </nav>
+      )}
+      <Zone of={zones.hero} />
+      <Zone of={zones.body} />
+      <Zone of={zones.prefooter} />
+    </>
+  );
+}
+
+export const StandardPage = smoodly.page(pageSchema, PageView);

package/templates/next-intl/components/sections/ArticleList.tsx

@@ -0,0 +1,31 @@
+import { f, smoodly, type Props } from "smoodly";
+import { articles } from "@/smoodly/collections";
+
+export const articleListSchema = smoodly.schema.section({
+  name: "articleList",
+  title: "Article list",
+  fields: {
+    title: f.text(),
+    // .resolve("author") — hydrate each article AND follow its author ref
+    // one level (article → person), all in resolveTree's batched pass.
+    items: f.refList(() => articles).resolve("author"),
+  },
+});
+
+function ArticleListView({ title, items, styles }: Props<typeof articleListSchema>) {
+  return (
+    <smoodly.Section styles={styles}>
+      <h2>{title}</h2>
+      <ul>
+        {/* an item demoted/deleted after publish resolves to null — skip it */}
+        {items.filter(Boolean).map((article, i) => (
+          <li key={i}>
+            <strong>{article.title}</strong> — {article.author?.name ?? "unknown author"}
+          </li>
+        ))}
+      </ul>
+    </smoodly.Section>
+  );
+}
+
+export const ArticleList = smoodly.section(articleListSchema, ArticleListView);

package/templates/next-intl/components/sections/CtaBanner.tsx

@@ -0,0 +1,35 @@
+import { f, smoodly, type Props } from "smoodly";
+
+// The locked-zone section: every page renders exactly one of these in its
+// `prefooter` zone. Editors change the words, never the structure — no
+// add, remove, move or duplicate. The editor materializes the node from
+// `sample` the first time it opens a page whose prefooter is empty.
+export const ctaBannerSchema = smoodly.schema.section({
+  name: "ctaBanner",
+  title: "CTA banner",
+  description: "The closing call to action under every page.",
+  fields: {
+    heading: f.text(),
+    buttonLabel: f.text(),
+    buttonHref: f.text(),
+  },
+  styles: {
+    tone: f.select(["light", "dark"]).default("dark"),
+  },
+  sample: {
+    heading: "Ready to try Smoodly?",
+    buttonLabel: "Read the docs",
+    buttonHref: "/docs/intro",
+  },
+});
+
+function CtaBannerView({ heading, buttonLabel, buttonHref, styles }: Props<typeof ctaBannerSchema>) {
+  return (
+    <smoodly.Section styles={styles}>
+      <h2>{heading}</h2>
+      <a href={buttonHref}>{buttonLabel}</a>
+    </smoodly.Section>
+  );
+}
+
+export const CtaBanner = smoodly.section(ctaBannerSchema, CtaBannerView);

package/templates/next-intl/components/sections/Hero.tsx

@@ -0,0 +1,24 @@
+import { f, smoodly, type Props } from "smoodly";
+
+export const heroSchema = smoodly.schema.section({
+  name: "hero",
+  title: "Hero",
+  fields: {
+    heading: f.text(),
+    kicker: f.text().optional(),
+  },
+  styles: {
+    tone: f.select(["light", "dark"]).default("light"),
+  },
+});
+
+function HeroView({ heading, kicker, styles }: Props<typeof heroSchema>) {
+  return (
+    <smoodly.Section styles={styles}>
+      {kicker ? <p>{kicker}</p> : null}
+      <h1>{heading}</h1>
+    </smoodly.Section>
+  );
+}
+
+export const Hero = smoodly.section(heroSchema, HeroView);

package/templates/next-intl/i18n/navigation.ts

@@ -0,0 +1,6 @@
+import { createNavigation } from "next-intl/navigation";
+import { routing } from "./routing";
+
+// Locale-aware Link/redirect/router, and getPathname — the function
+// smoodly/server.ts binds as `href`.
+export const { Link, redirect, usePathname, useRouter, getPathname } = createNavigation(routing);

package/templates/next-intl/i18n/request.ts

@@ -0,0 +1,17 @@
+import { locale as rootLocale } from "next/root-params";
+import { hasLocale } from "next-intl";
+import { getRequestConfig } from "next-intl/server";
+import { routing } from "./routing";
+
+// Runs once per request that touches next-intl. An unknown or absent
+// locale (the admin lives outside app/[locale]) falls back to the default
+// rather than 404ing. The site has no UI strings of its own yet, but
+// NextIntlClientProvider wants a messages object all the same — fill it
+// in when it does: https://next-intl.dev/docs/usage/configuration
+export default getRequestConfig(async ({ locale }) => {
+  const requested = locale ?? (await rootLocale());
+  return {
+    locale: hasLocale(routing.locales, requested) ? requested : routing.defaultLocale,
+    messages: {},
+  };
+});

package/templates/next-intl/i18n/routing.ts

@@ -0,0 +1,17 @@
+import { defineRouting } from "next-intl/routing";
+
+// The one place the locale set is declared. smoodly/config.ts imports it
+// (the proxy runs in the edge runtime and cannot import the config, so it
+// could not go the other way). `alternateLinks: false`: next-intl would
+// derive hreflang from URL patterns, which is wrong once slugs translate —
+// smoodlyMetadata emits alternates from the CMS paths instead.
+// `localeDetection: false` for the same reason — a redirect that keeps the
+// English segments under `/fi/` lands on a 404; the visitor picks a
+// language through the site's own switcher.
+export const routing = defineRouting({
+  locales: ["en", "fi"],
+  defaultLocale: "en",
+  localePrefix: "as-needed",
+  alternateLinks: false,
+  localeDetection: false,
+});

package/templates/next-intl/next.config.ts

@@ -0,0 +1,8 @@
+import type { NextConfig } from "next";
+import createNextIntlPlugin from "next-intl/plugin";
+
+const withNextIntl = createNextIntlPlugin();
+
+const config: NextConfig = {};
+
+export default withNextIntl(config);

package/templates/next-intl/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "smoodly-site",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.113.0",
+    "next": "^16.3.4",
+    "react": "^19",
+    "react-dom": "^19",
+    "smoodly": "0.0.6",
+    "next-intl": "^4.14.2"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.1",
+    "@types/react": "^19",
+    "@types/react-dom": "^19.2.5",
+    "typescript": "^5"
+  }
+}