create-smoodly-app 0.0.45 → 0.0.47

package/templates/lorem/smoodly/toolsets.ts

@@ -6,11 +6,11 @@
 // template build, which runs outside the app where the `@/` alias has
 // no mapping.
 import { smoodly } from "smoodly";
-import { Callout } from "../components/elements/Callout";
-import { Cta } from "../components/elements/Cta";
+import { calloutSchema } from "../components/elements/Callout.schema";
+import { ctaSchema } from "../components/elements/Cta.schema";
 
 export const article = smoodly.toolset({
   marks: ["bold", "italic", "link"],
   nodes: ["h2", "h3", "h4", "bulletList", "orderedList", "blockquote", "image"],
-  elements: [Callout, Cta],
+  elements: [calloutSchema, ctaSchema],
 });

package/templates/lorem/smoodly/views.ts

@@ -0,0 +1,33 @@
+// The components that render the registered schemas. A function, not a
+// value: a page component imports smoodly/server.ts, which imports this
+// file, so the list must not be read while those modules are still
+// loading. defineViews names a schema with no component, and a component
+// with no schema, the first time the site renders.
+import { defineViews } from "smoodly/react";
+import { config } from "./config";
+import { RichText } from "./richtext";
+import { Hero } from "@/components/sections/Hero";
+import { PageHero } from "@/components/sections/PageHero";
+import { ImageText } from "@/components/sections/ImageText";
+import { Points } from "@/components/sections/Points";
+import { FavouriteArticles } from "@/components/sections/FavouriteArticles";
+import { People } from "@/components/sections/People";
+import { Quote } from "@/components/sections/Quote";
+import { Header } from "@/components/sections/Header";
+import { Footer } from "@/components/sections/Footer";
+import { Callout } from "@/components/elements/Callout";
+import { Cta } from "@/components/elements/Cta";
+import { HomePage } from "@/components/pages/Home";
+import { ArticlesPage } from "@/components/pages/Articles";
+import { StandardPage } from "@/components/pages/Page";
+import { ArticlePage } from "@/components/pages/Article";
+import { NewsPage } from "@/components/pages/News";
+import { NewsPostPage } from "@/components/pages/NewsPost";
+
+export const views = () =>
+  defineViews(config, {
+    sections: [Hero, PageHero, ImageText, Points, FavouriteArticles, People, Quote, Header, Footer],
+    elements: [Callout, Cta],
+    pages: [HomePage, ArticlesPage, StandardPage, ArticlePage, NewsPage, NewsPostPage],
+    RichText,
+  });

package/templates/lorem/supabase/migrations/20261007120000_smoodly_v8.sql

@@ -0,0 +1,154 @@
+-- Smoodly core schema, version 8 (docs/superpowers/specs/2026-10-07-delivery-model-design.md).
+-- Shipped in the smoodly package; `npx smoodly migrate` copies it into supabase/migrations/.
+-- Never edit a published file: the next change is the next file.
+-- The delta over version 7: the delivery model's two derived tables,
+-- published_pages and published_entries, with the space trigger and the
+-- write-key-only policies every content table has (no row cap: they are
+-- derived), smoodly_list_published over the raw published snapshot, and
+-- the published_routes view, one lookup for any address.
+
+set client_min_messages = warning;
+
+-- The delivery model (spec 2026-10-07): Publish writes the finished document of a page, an entry
+-- or a global here; a live read is one lookup. Derived and rebuildable from the editing tables.
+create table if not exists "published_pages" (
+  "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,
+  "parent_id" uuid,
+  "sort" numeric,
+  "path" text,
+  "title" text not null,
+  "has_page" boolean not null,
+  "link_fields" jsonb not null default '{}'::jsonb,
+  "document" jsonb,
+  "tags" text[] not null default '{}',
+  "model" text not null,
+  "stale" boolean not null default false,
+  "published_at" timestamptz not null default now(),
+  primary key ("page_id", "locale")
+);
+create unique index if not exists "published_pages_address_idx"
+  on "published_pages" ("space_id", "locale", "path") where "path" is not null;
+create index if not exists "published_pages_tree_idx"
+  on "published_pages" ("space_id", "locale", "parent_id", "sort");
+
+create table if not exists "published_entries" (
+  "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,
+  "collection" text not null,
+  "parent_id" uuid,
+  "sort" numeric,
+  "slug" text,
+  "path" text,
+  "created_at" timestamptz not null,
+  "updated_at" timestamptz not null,
+  "fields" jsonb not null,
+  "document" jsonb not null,
+  "tags" text[] not null default '{}',
+  "model" text not null,
+  "stale" boolean not null default false,
+  "published_at" timestamptz not null default now(),
+  primary key ("entry_id", "locale")
+);
+create index if not exists "published_entries_list_idx"
+  on "published_entries" ("space_id", "collection", "locale");
+create unique index if not exists "published_entries_address_idx"
+  on "published_entries" ("space_id", "locale", "path") where "path" is not null;
+create index if not exists "published_entries_fields_idx"
+  on "published_entries" using gin ("fields");
+
+alter table "published_pages" enable row level security;
+alter table "published_entries" enable row level security;
+
+-- smoodly_list_entries without the draft branch, over the delivery table (spec 2026-10-07 §3):
+-- `where` and `order` read the raw published snapshot, the row answers with its document.
+-- Invoker rights, so RLS decides what a key sees.
+create or replace function "smoodly_list_published"(
+  p_collection text, p_locale text, p_where jsonb, p_order jsonb,
+  p_limit integer, p_parent uuid, p_has_parent boolean, p_ids uuid[]
+) returns table ("id" uuid, "document" jsonb, "model" text, "stale" boolean) language sql stable set search_path = public as $$
+  with shown as (
+    select p."entry_id" as "id", p."sort", p."created_at", p."updated_at", p."fields", p."document", p."model", p."stale"
+    from "published_entries" p
+    where p."collection" = p_collection and p."locale" = p_locale
+      and (not p_has_parent or p."parent_id" is not distinct from p_parent)
+      and (p_ids is null or p."entry_id" = any(p_ids))
+  )
+  select s."id", s."document", s."model", s."stale" from shown s
+  where not exists (
+    select 1 from jsonb_each(coalesce(p_where, '{}'::jsonb)) w
+    where not (case when w.value ? 'in'
+                    then (s."fields" ->> w.key) = any (select jsonb_array_elements_text(w.value -> 'in'))
+                    else s."fields" @> jsonb_build_object(w.key, w.value -> 'contains') end))
+  order by
+    case when p_order ->> 'by' = 'manual' then s."sort" end asc nulls last,
+    case when p_order ->> 'direction' = 'asc' then
+      case p_order ->> 'by' when 'createdAt' then to_jsonb(s."created_at") when 'updatedAt' then to_jsonb(s."updated_at")
+           when 'manual' then null else nullif(nullif(s."fields" -> (p_order ->> 'by'), 'null'::jsonb), '""'::jsonb) end end asc nulls last,
+    case when p_order ->> 'direction' = 'desc' then
+      case p_order ->> 'by' when 'createdAt' then to_jsonb(s."created_at") when 'updatedAt' then to_jsonb(s."updated_at")
+           when 'manual' then null else nullif(nullif(s."fields" -> (p_order ->> 'by'), 'null'::jsonb), '""'::jsonb) end end desc nulls last,
+    s."created_at" asc, s."id" asc
+  limit p_limit;
+$$;
+
+-- One lookup for any address (spec 2026-10-07 §3): a page or an entry, under the caller's own policies.
+create or replace view "published_routes" with (security_invoker = true) as
+  select "space_id", "locale", "path", 'page' as "kind", "page_id" as "id", "document", "model", "stale", "tags", null::text as "collection"
+  from "published_pages" where "path" is not null and "has_page"
+  union all
+  select "space_id", "locale", "path", 'entry' as "kind", "entry_id" as "id", "document", "model", "stale", "tags", "collection"
+  from "published_entries" where "path" is not null;
+
+-- Stamped with the caller's space on insert, as every content table.
+drop trigger if exists "smoodly_a_set_space" on "published_pages";
+create trigger "smoodly_a_set_space" before insert on "published_pages"
+  for each row execute function "smoodly_set_space"();
+
+drop trigger if exists "smoodly_a_set_space" on "published_entries";
+create trigger "smoodly_a_set_space" before insert on "published_entries"
+  for each row execute function "smoodly_set_space"();
+
+-- A write key reads and writes its own space; no other key reads (spec 2026-09-29 content API contract §8).
+drop policy if exists "smoodly_write" on "published_pages";
+
+drop policy if exists "smoodly_insert" on "published_pages";
+create policy "smoodly_insert" on "published_pages" for insert
+  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_update" on "published_pages";
+create policy "smoodly_update" on "published_pages" for update
+  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_delete" on "published_pages";
+create policy "smoodly_delete" on "published_pages" for delete
+  using ("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 "published_pages";
+create policy "smoodly_read" on "published_pages" for select
+  using ("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 "published_entries";
+
+drop policy if exists "smoodly_insert" on "published_entries";
+create policy "smoodly_insert" on "published_entries" for insert
+  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_update" on "published_entries";
+create policy "smoodly_update" on "published_entries" for update
+  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_delete" on "published_entries";
+create policy "smoodly_delete" on "published_entries" for delete
+  using ("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 "published_entries";
+create policy "smoodly_read" on "published_entries" for select
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+insert into "smoodly_meta" ("key", "value") values ('schema_version', '8')
+  on conflict ("key") do update set "value" = excluded."value";

package/templates/lorem/supabase/migrations/20261007200000_smoodly_v9.sql

@@ -0,0 +1,30 @@
+-- Smoodly core schema, version 9 (packages/smoodly/MAINTAINERS.md, register 2026-10-07: what the delivery model left).
+-- Shipped in the smoodly package; `npx smoodly migrate` copies it into supabase/migrations/.
+-- Never edit a published file: the next change is the next file.
+-- The delta over version 8: smoodly_lookup_address, the route row and the
+-- locale's global items in one call, so a live page is one database call
+-- instead of the page then its layout's globals.
+
+set client_min_messages = warning;
+
+-- The address and the locale's global items in one call (schema v9; register 2026-10-07: a miss was two
+-- rounds, the page then the layout's globals). The route row first, kind 'page' or 'entry'; then one row per
+-- named global, kind 'global', the collection its name. A miss answers nothing: the globals ride with a page
+-- only. Invoker rights, so RLS decides what a key sees.
+create or replace function "smoodly_lookup_address"(p_locale text, p_path text, p_globals text[])
+returns table ("kind" text, "id" uuid, "collection" text, "document" jsonb, "model" text, "stale" boolean, "tags" text[])
+language sql stable set search_path = public as $$
+  with route as (
+    select r."kind", r."id", r."collection", r."document", r."model", r."stale", r."tags"
+    from "published_routes" r where r."locale" = p_locale and r."path" = p_path limit 1
+  )
+  select * from route
+  union all
+  select 'global' as "kind", e."entry_id", e."collection", e."document", e."model", e."stale", e."tags"
+  from "published_entries" e
+  where e."locale" = p_locale and e."collection" = any(coalesce(p_globals, '{}'::text[]))
+    and exists (select 1 from route);
+$$;
+
+insert into "smoodly_meta" ("key", "value") values ('schema_version', '9')
+  on conflict ("key") do update set "value" = excluded."value";

package/templates/lorem/supabase/migrations/20261008120000_smoodly_v10.sql

@@ -0,0 +1,47 @@
+-- Smoodly core schema, version 10 (DESIGN §3, the document stamp, decided 2026-10-08).
+-- Shipped in the smoodly package; `npx smoodly migrate` copies it into supabase/migrations/.
+-- Never edit a published file: the next change is the next file.
+-- The delta over version 9: published_models, one row per space holding the
+-- document stamp the space recorded as current, so only the deployment at that
+-- stamp rewrites delivery rows (a preview deployment on a newer package serves
+-- assembled documents and writes nothing). Additive: no function changes.
+
+set client_min_messages = warning;
+
+-- The document stamp a space recorded as current: set by `npx smoodly rebuild` and by the first writer
+-- into an empty record; only a reader at this stamp rewrites published_pages and published_entries.
+create table if not exists "published_models" (
+  "space_id" uuid primary key default '00000000-0000-0000-0000-000000000000',
+  "model" text not null,
+  "recorded_at" timestamptz not null default now()
+);
+
+alter table "published_models" enable row level security;
+
+-- Stamped with the caller's space on insert, as every content table.
+drop trigger if exists "smoodly_a_set_space" on "published_models";
+create trigger "smoodly_a_set_space" before insert on "published_models"
+  for each row execute function "smoodly_set_space"();
+
+-- A write key reads and writes its own space's record; no other key reads (spec 2026-09-29 content API contract §8).
+drop policy if exists "smoodly_write" on "published_models";
+
+drop policy if exists "smoodly_insert" on "published_models";
+create policy "smoodly_insert" on "published_models" for insert
+  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_update" on "published_models";
+create policy "smoodly_update" on "published_models" for update
+  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_delete" on "published_models";
+create policy "smoodly_delete" on "published_models" for delete
+  using ("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 "published_models";
+create policy "smoodly_read" on "published_models" for select
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+insert into "smoodly_meta" ("key", "value") values ('schema_version', '10')
+  on conflict ("key") do update set "value" = excluded."value";

package/templates/lorem/supabase/migrations/20261008120100_smoodly_views.sql

@@ -0,0 +1,58 @@
+-- Smoodly: read views for this app's collections, written by `npx smoodly migrate`
+-- (2026-10-08T12:01:00.000Z). One block per collection; the marker's hash is the block's SQL, compared on the next run.
+-- Never edit a written file: change the collection and run migrate again.
+
+-- smoodly:collection people sha256:929798ebb4fa2bb6
+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",
+  coalesce(v."fields", e."fields" || l."fields")->>'name' as "name",
+  coalesce(v."fields", e."fields" || l."fields")->>'role' as "role"
+from "entries" e
+join "entry_locales" l on l."entry_id" = e."id"
+left join "entry_versions" v on v."id" = l."published_version_id"
+where e."collection" = 'people' and l."status" = 'published';
+
+-- smoodly:collection articles sha256:dcbe071d70e13943
+create or replace view "articles" with (security_invoker = true) as
+select
+  e."id",
+  l."locale",
+  l."slug",
+  e."sort",
+  e."created_at",
+  l."updated_at",
+  coalesce(v."fields", e."fields" || l."fields")->>'title' as "title",
+  coalesce(v."fields", e."fields" || l."fields")->'image' as "image",
+  (coalesce(v."fields", e."fields" || l."fields")->>'date')::timestamptz as "date",
+  coalesce(v."fields", e."fields" || l."fields")->>'author' as "author",
+  coalesce(v."fields", e."fields" || l."fields")->>'excerpt' as "excerpt",
+  coalesce(v."fields", e."fields" || l."fields")->'body' as "body",
+  coalesce(v."fields", e."fields" || l."fields")->'tags' as "tags"
+from "entries" e
+join "entry_locales" l on l."entry_id" = e."id"
+left join "entry_versions" v on v."id" = l."published_version_id"
+where e."collection" = 'articles' and l."status" = 'published';
+
+-- smoodly:collection news sha256:03a94ad5ba35ffe4
+create or replace view "news" with (security_invoker = true) as
+select
+  e."id",
+  l."locale",
+  l."slug",
+  e."sort",
+  e."created_at",
+  l."updated_at",
+  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")->>'excerpt' as "excerpt",
+  coalesce(v."fields", e."fields" || l."fields")->'body' as "body"
+from "entries" e
+join "entry_locales" l on l."entry_id" = e."id"
+left join "entry_versions" v on v."id" = l."published_version_id"
+where e."collection" = 'news' and l."status" = 'published';

package/templates/lorem-intl/AGENTS.md

@@ -7,11 +7,19 @@ where things are.
 
 ## Rules
 
-- **Register everything in `smoodly/`.** Every section, element,
-  collection and global item is listed in its barrel (`sections.ts`,
-  `elements.ts`, `collections.ts`, `globals.ts`) and `smoodly/config.ts`
-  is the one registry. A component that is not registered does not exist
-  for the admin.
+- **Register schemas in the config, components in `smoodly/views.ts`.**
+  Every section, element and page type is two files: `Name.schema.ts`
+  and `Name.tsx`. The schema is listed in its barrel (`sections.ts`,
+  `elements.ts`, the config's `pages`; collections and global items in
+  `collections.ts`, `globals.ts`) and `smoodly/config.ts` is the one
+  registry. The component is listed in `smoodly/views.ts`, an element's
+  also in `smoodly/richtext.tsx`; an entry page is listed only in
+  `smoodly/views.ts`. A schema with no component, or a component with
+  no schema, is a named error on the first render.
+- **A `.schema.ts` file imports no component** and nothing from
+  `smoodly/server.ts` or `smoodly/richtext.tsx`. Zones, toolsets, global
+  items and `node()` take schemas (`z.locked(heroSchema)`), never
+  components.
 - **After a new collection or a `smoodly` upgrade, run `npx smoodly migrate`**
   and apply what it writes (`supabase db push` hosted, `supabase migration up`
   local). It copies the core schema files the package ships and writes a
@@ -23,16 +31,15 @@ where things are.
   the admin's own operations, so validation and publish checks apply and
   a failure throws. Never write rows or call the stores directly. The
   seed is idempotent; run it with `npm run seed`.
-- **Never import the admin into the site.** Nothing under `app/(site)`,
-  `app/[locale]` or `components/`, and nothing they import
-  (`smoodly/server.ts` included), may import `@/smoodly/admin` or
-  `smoodly/admin/next`: Next ships every client module a route imports,
-  rendered or not, and the admin's chunk must not reach visitors. The
-  package's `smoodly/admin` entry has no client code; server-side
-  admin glue such as `supabaseAdminAuth` comes from there.
-- **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`.
+- **The admin is one route.** `app/(smoodly)/admin/[[...segments]]/route.ts`
+  serves the admin's page, its files and its operations from the
+  `smoodly` package; the folder name must match `admin.path` in the
+  config. The admin is prebuilt: nothing of it is compiled into the
+  site, and it takes no layout. Server-side pieces such as
+  `supabaseAdminAuth` and the content API come from `smoodly/admin`.
+- **One root layout.** The site's layout lives in its route group or
+  locale segment. Do not add an `app/layout.tsx`: it would wrap that
+  layout in a second `<html>`.
 - **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
@@ -45,7 +52,7 @@ where things are.
 - **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
+- **Fixed versus open pages.** A page type with a `slug` is fixed: one
   record, created for you, never deleted. Without one it is open: editors
   create as many as they like.
 

package/templates/lorem-intl/README.md

@@ -10,16 +10,16 @@ for an agent (or a person) building the site.
 
 - `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: fonts, `app/globals.css`, the footer from global content; the admin has its own under `app/(smoodly)/admin/`.
+- `app/[locale]/layout.tsx` — the site's root layout: fonts, `app/globals.css`, the footer from global content. The admin is one route, `app/(smoodly)/admin/[[...segments]]/route.ts`, and takes no layout.
 - `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 the entry page: `Home` (locked hero, freeform body), `Articles` (a fixed page at the collection's path — its index — with a code-fetched grid), `Page` (open; About lives here), `Article` (the entry page), `News` and `NewsPost` (a collection at the nested address `company/news`, its index and entry page).
 - `components/PageFrame.tsx` — the header and `<main>` every page view renders (a layout cannot know which page is on screen); with more than one locale, the language links from the page's `locales` map — the same page in the other language, or its home when there is no translation.
-- `components/sections/` — the building blocks editors compose with, and the header, footer and quote behind the global items. Add one, list it in `smoodly/sections.ts`.
+- `components/sections/` — the building blocks editors compose with, and the header, footer and quote behind the global items. Each is two files: `Name.schema.ts` (the schema) and `Name.tsx` (the component). Add one, list its schema in `smoodly/sections.ts` and its component in `smoodly/views.ts`.
 - `components/strings.ts`, `messages/` — the site's own UI strings and the request locale, one seam.
 - `public/images/` — the starter's photos; image fields hold URLs like `/images/hero_image.jpg`.
 - `scripts/seed.ts` — the starter content, written through the content API (`content()`). `npm run seed` is idempotent.
 - `smoodly/collections.ts` — structured content (people, articles, news). Add a collection, run `npx smoodly migrate`, apply the file it writes.
-- `smoodly/` — the wiring: `config.ts` (the registry and settings), `collections.ts`, `sections.ts`, `server.ts` (site layer, renderer, the content API `content()`), `ops.ts` (the admin's one server action), `admin.tsx` (the admin mount).
+- `smoodly/` — the wiring: `config.ts` (the registry of schemas and the settings; it imports no component), `collections.ts`, `sections.ts` and `elements.ts` (the schemas the config registers), `views.ts` (the components that render them), `server.ts` (site layer, renderer, the content API `content()`).
 - `.env.local` — `SMOODLY_URL`, `SMOODLY_SECRET_KEY`, `SMOODLY_PUBLISHABLE_KEY`.
 
 Translated URLs: a page's slug and title are edited per locale in the

package/templates/lorem-intl/app/(smoodly)/admin/[[...segments]]/route.ts

@@ -0,0 +1,8 @@
+// The admin: its page, the package's files and the operations endpoint, all from this one route. The
+// admin is prebuilt in the `smoodly` package; nothing of it is compiled into the site. The folder name
+// must match `admin.path` in smoodly/config.ts.
+import { createAdminRoute } from "smoodly/next";
+import { config } from "@/smoodly/config";
+import { adminDeps, presence, publicAuth } from "@/smoodly/server";
+
+export const { GET, POST } = createAdminRoute(() => ({ config, ...adminDeps(), signIn: publicAuth(), presence }));

package/templates/lorem-intl/components/elements/Callout.schema.ts

@@ -0,0 +1,24 @@
+import { f, smoodly } from "smoodly";
+
+// An Element: a small registered block editors insert inside an article
+// body (the `richtext` context). Its body is richtext too — marks only —
+// rendered by the package's pure RichText (a schema file imports no view:
+// the view imports this file, and an import back would cycle).
+export const calloutSchema = smoodly.schema.element({
+  name: "callout",
+  title: "Callout",
+  icon: "!",
+  description: "A highlighted note inside the text.",
+  contexts: ["richtext"],
+  fields: {
+    title: f.text().max(80),
+    body: f.richtext({ toolset: smoodly.toolset({ marks: ["bold", "italic", "link"] }) }),
+  },
+  settings: {
+    tone: f.select([{ value: "info", label: "Info" }, { value: "success", label: "Success" }, { value: "warning", label: "Warning" }]).default("info"),
+  },
+  sample: {
+    title: "Good to know",
+    body: { type: "doc", content: [{ type: "paragraph", content: [{ type: "text", text: "Lorem ipsum dolor sit amet, consectetur adipiscing elit." }] }] },
+  },
+});

package/templates/lorem-intl/components/elements/Callout.tsx

@@ -1,27 +1,5 @@
-import { f, RichText, smoodly, type Props } from "smoodly";
-
-// An Element: a small registered block editors insert inside an article
-// body (the `richtext` context). Its body is richtext too — marks only —
-// rendered by the package's pure RichText (never the project's bound one:
-// smoodly/richtext.tsx imports this file, and an import back would cycle).
-export const calloutSchema = smoodly.schema.element({
-  name: "callout",
-  title: "Callout",
-  icon: "!",
-  description: "A highlighted note inside the text.",
-  contexts: ["richtext"],
-  fields: {
-    title: f.text().max(80),
-    body: f.richtext({ toolset: smoodly.toolset({ marks: ["bold", "italic", "link"] }) }),
-  },
-  settings: {
-    tone: f.select([{ value: "info", label: "Info" }, { value: "success", label: "Success" }, { value: "warning", label: "Warning" }]).default("info"),
-  },
-  sample: {
-    title: "Good to know",
-    body: { type: "doc", content: [{ type: "paragraph", content: [{ type: "text", text: "Lorem ipsum dolor sit amet, consectetur adipiscing elit." }] }] },
-  },
-});
+import { RichText, smoodly, type Props } from "smoodly/react";
+import { calloutSchema } from "./Callout.schema";
 
 function CalloutView({ title, body, settings }: Props<typeof calloutSchema>) {
   return (

package/templates/lorem-intl/components/elements/Cta.schema.ts

@@ -0,0 +1,21 @@
+import { f, smoodly } from "smoodly";
+
+// A call to action inside an article body: heading, a line of text and
+// one button. `variant` is a style — never translated.
+export const ctaSchema = smoodly.schema.element({
+  name: "cta",
+  title: "Call to action",
+  icon: "→",
+  description: "A heading, a line and a button.",
+  contexts: ["richtext"],
+  fields: {
+    heading: f.text().max(80),
+    text: f.text().max(200).optional(),
+    label: f.text().max(40),
+    href: f.link(),
+  },
+  settings: {
+    variant: f.select([{ value: "primary", label: "Primary" }, { value: "outline", label: "Outline" }]).default("primary"),
+  },
+  sample: { heading: "Ready to start?", text: "Sed ut perspiciatis unde omnis iste natus.", label: "Get in touch", href: "/company/about-us" },
+});

package/templates/lorem-intl/components/elements/Cta.tsx

@@ -1,24 +1,5 @@
-import { f, smoodly, type Props } from "smoodly";
-
-// A call to action inside an article body: heading, a line of text and
-// one button. `variant` is a style — never translated.
-export const ctaSchema = smoodly.schema.element({
-  name: "cta",
-  title: "Call to action",
-  icon: "→",
-  description: "A heading, a line and a button.",
-  contexts: ["richtext"],
-  fields: {
-    heading: f.text().max(80),
-    text: f.text().max(200).optional(),
-    label: f.text().max(40),
-    href: f.link(),
-  },
-  settings: {
-    variant: f.select([{ value: "primary", label: "Primary" }, { value: "outline", label: "Outline" }]).default("primary"),
-  },
-  sample: { heading: "Ready to start?", text: "Sed ut perspiciatis unde omnis iste natus.", label: "Get in touch", href: "/company/about-us" },
-});
+import { smoodly, type Props } from "smoodly/react";
+import { ctaSchema } from "./Cta.schema";
 
 function CtaView({ heading, text, label, href, settings }: Props<typeof ctaSchema>) {
   return (

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

@@ -1,4 +1,4 @@
-import { smoodly } from "smoodly";
+import { smoodly } from "smoodly/react";
 import { RichText } from "@/smoodly/richtext";
 import { SmoodlyImage } from "smoodly/image";
 import { articles } from "@/smoodly/collections";

package/templates/lorem-intl/components/pages/Articles.schema.ts

@@ -0,0 +1,20 @@
+import { smoodly, z } from "smoodly";
+import { pageHeroSchema } from "../sections/PageHero.schema";
+
+// The Articles index: a fixed page whose slugs are the collection's own
+// segments (smoodly/collections.ts), which makes it the collection's
+// index page — the mount in the Pages list opens this page's editor. The
+// editor owns the hero; the grid below is developer JSX that reads the
+// articles through `q`, newest first (the collection's `order`), cached
+// under the collection's tag. In the editor canvas the site runs in draft
+// mode, so the grid reads the live rows too: an unpublished article shows
+// there as it will (spec 2026-09-11 §2).
+export const articlesSchema = smoodly.schema.page({
+  name: "articlesIndex",
+  title: "Articles",
+  slug: { en: "posts", fi: "artikkelit" },
+  zones: {
+    hero: z.locked(pageHeroSchema),
+  },
+  seo: true,
+});

package/templates/lorem-intl/components/pages/Articles.tsx

@@ -1,27 +1,9 @@
-import { smoodly, z, Zone, type Props } from "smoodly";
-import { PageHero } from "../sections/PageHero";
+import { smoodly, Zone, type Props } from "smoodly/react";
 import { ArticleCard } from "../ArticleCard";
 import { PageFrame } from "../PageFrame";
 import { ui } from "../strings";
 import { q } from "@/smoodly/server";
-
-// The Articles index: a fixed page whose slugs are the collection's own
-// segments (smoodly/collections.ts), which makes it the collection's
-// index page — the mount in the Pages list opens this page's editor. The
-// editor owns the hero; the grid below is developer JSX that reads the
-// articles through `q`, newest first (the collection's `order`), cached
-// under the collection's tag. In the editor canvas the site runs in draft
-// mode, so the grid reads the live rows too: an unpublished article shows
-// there as it will (spec 2026-09-11 §2).
-export const articlesSchema = smoodly.schema.page({
-  name: "articlesIndex",
-  title: "Articles",
-  slug: { en: "posts", fi: "artikkelit" },
-  zones: {
-    hero: z.locked(PageHero),
-  },
-  seo: true,
-});
+import { articlesSchema } from "./Articles.schema";
 
 async function ArticlesView({ zones, page }: Props<typeof articlesSchema>) {
   const { locale, url } = await ui();