create-smoodly-app 0.0.37 → 0.0.39

package/templates/lorem-intl/scripts/seed.ts

@@ -1,6 +1,7 @@
-// The starter's content, through the stores (never raw inserts — the
-// refs index and publish integrity must be exercised, that's the point).
-// Content only; it ships in the template and create-smoodly-app runs
+// The starter's content, written through the content API (`content()`
+// from smoodly/server.ts): the admin's own operations, so validation and
+// the publish checks apply and a failure throws. This file is also the
+// example of writing content from code. Content only; it ships in the template and create-smoodly-app runs
 // `npm run seed` after the first editor. (The example repo's demo
 // editor account is a separate, example-only script.)
 // Run: npm run seed  (needs .env.local and a Supabase stack).
@@ -13,24 +14,32 @@
 // `fi` default lands the index on `artikkelit`. Body copy is Latin in
 // both; what a reader perceives as language (nav, headings, tags,
 // roles, footer titles) is translated. Idempotent: exits once the home
-// page exists.
-import { readFile } from "node:fs/promises";
+// page has content.
 import next from "@next/env";
-import { imageDimensions, lastPart, type PageTree } from "smoodly";
+import type { PageTree, TreeNode } from "smoodly";
 const { loadEnvConfig } = next;
 
 loadEnvConfig(process.cwd());
 
 const { config } = await import("../smoodly/config");
 const { articles, news } = await import("../smoodly/collections");
-const { href, stores } = await import("../smoodly/server");
-const { pages, entries, assets } = stores();
+const { content, href, node } = await import("../smoodly/server");
+const { Hero } = await import("../components/sections/Hero");
+const { PageHero } = await import("../components/sections/PageHero");
+const { ImageText } = await import("../components/sections/ImageText");
+const { Points } = await import("../components/sections/Points");
+const { FavouriteArticles } = await import("../components/sections/FavouriteArticles");
+const { People } = await import("../components/sections/People");
+const c = content();
 
 const EN = config.locales.default;
 const FI = config.locales.supported.includes("fi") && EN !== "fi" ? "fi" : null;
 
-if (await pages.resolvePath(EN, "/")) {
-  console.log(`Already seeded — "home" exists in "${EN}".`);
+// The home page is code-owned: `find` returns its record, creating it when
+// the database is new. It is seeded once somebody has given it sections.
+const home = (await c.pages.find(EN, "/"))!;
+if (Object.values((await c.pages.getTree(home.id, EN))?.zones ?? {}).some((nodes) => nodes.length > 0)) {
+  console.log(`Already seeded — the home page has content in "${EN}".`);
   process.exit(0);
 }
 
@@ -53,20 +62,11 @@ const cta = (heading: string, text: string, label: string, href: string): Node =
   ({ type: "element", attrs: { name: "cta", fields: { heading, text, label, href }, settings: { variant: "primary" } } });
 const doc = (...content: Node[]) => ({ type: "doc", content });
 
-// The starter's photos become assets: each file is uploaded once through
-// the store (rows in `assets`, bytes in the `media` bucket), and a field
-// value is `{ asset: <id> }` — the alt lives on the asset (spec 2026-09-08).
-const uploaded = new Map<string, string>();
-async function image(name: string, alt: string): Promise<{ asset: string }> {
-  let id = uploaded.get(name);
-  if (!id) {
-    const bytes = new Uint8Array(await readFile(`public/images/${name}.jpg`));
-    const dims = imageDimensions(bytes) ?? {};
-    id = (await assets.create({ filename: `${name}.jpg`, mime: "image/jpeg", size: bytes.byteLength, bytes, alt, title: alt, ...dims })).id;
-    uploaded.set(name, id);
-  }
-  return { asset: id };
-}
+// The starter's photos become assets: each file is uploaded once (a row
+// in `assets`, the bytes in the `media` bucket), and a field value is
+// `{ asset: <id> }` — the alt lives on the asset (spec 2026-09-08).
+const image = async (name: string, alt: string): Promise<{ asset: string }> =>
+  ({ asset: (await c.media.upload(`public/images/${name}.jpg`, { alt, title: alt })).asset });
 const img = {
   article: await image("article_photo", "Notebook on a desk"),
   home2: await image("home_section_2", "Team working"),
@@ -92,53 +92,73 @@ const paths = (locale: string) => ({
   about: href(locale === FI ? "/yritys/tietoa-meista" : "/company/about-us", locale),
 });
 
-/** Create an entry (a collection's or a global item's) in EN, add the FI
- *  row when there is one, and publish both — every entry is published in
- *  every locale it has BEFORE any page, because publish integrity is per
- *  locale and would (rightly) block a page whose tree references an entry
- *  that is a draft, or absent, in that locale. `fi` holds the localized
- *  fields; shared ones are repeated from `en`. */
+/** Create an entry in EN, add the FI row when there is one, and publish
+ *  both — every entry is published in every locale it has BEFORE any
+ *  page, because publish integrity is per locale and would (rightly)
+ *  block a page whose tree references an entry that is a draft, or
+ *  absent, in that locale. `fi` holds the localized fields; shared ones
+ *  are repeated from `en`. */
 async function seedEntry(collection: string, en: Fields, fi?: Fields) {
-  const row = await entries.create(collection, en, { locale: EN });
-  await entries.setStatus(collection, row.id, EN, "published");
+  const row = await c.entries.create(collection, { locale: EN, fields: en });
+  await c.entries.publish(collection, row.id, EN);
   if (FI && fi) {
-    await entries.addLocale(collection, row.id, FI, { from: EN });
-    await entries.update(collection, row.id, FI, { ...en, ...fi });
-    await entries.setStatus(collection, row.id, FI, "published");
+    await c.entries.addLocale(collection, row.id, FI, { from: EN, fields: { ...en, ...fi } });
+    await c.entries.publish(collection, row.id, FI);
+  }
+  return row;
+}
+
+/** A global item exists in every locale from the start: set and publish each. */
+async function seedGlobal(name: string, en: Fields, fi?: Fields) {
+  const row = await c.globals.set(name, EN, en);
+  await c.globals.publish(name, EN);
+  if (FI) {
+    await c.globals.set(name, FI, { ...en, ...fi });
+    await c.globals.publish(name, FI);
   }
   return row;
 }
 
-type Tree = { zones: Record<string, Node[]>; fields?: Record<string, unknown>; meta?: Record<string, unknown> };
+type Tree = PageTree;
+type Trees = { en: Tree; fi?: Tree };
 
 /** Create a page (or a folder: `template: null`) in EN with its tree,
  *  publish it, then the FI row with its own tree — a locale's tree is
  *  its own (spec 2026-09-06); the Finnish page is copied from the
  *  English draft, then overwritten with the Finnish tree. */
 async function seedPage(
-  input: { slug: string; title: string; template: string | null; parentId?: string; fixed?: string; fi?: { slug?: string; title: string } },
-  trees?: { en: Tree; fi?: Tree },
+  input: { slug: string; title: string; template: string | null; parentId?: string; fi?: { slug?: string; title: string } },
+  trees?: Trees,
 ) {
-  const page = await pages.createPage({
-    locale: EN, slug: input.slug, title: input.title, template: input.template,
-    ...(input.parentId ? { parentId: input.parentId } : {}),
-    // A code-owned record names its owner (spec 2026-09-29 nested paths §3).
-    ...(input.fixed ? { fixed: input.fixed } : {}),
-  });
+  const page = await c.pages.create({ parentId: input.parentId ?? null, locale: EN, slug: input.slug, title: input.title, template: input.template });
   if (trees) {
-    await pages.saveDraft(page.id, EN, trees.en as unknown as PageTree);
-    await pages.publish(page.id, EN);
+    await c.pages.setTree(page.id, EN, trees.en);
+    await c.pages.publish(page.id, EN);
   }
   if (FI && input.fi) {
-    await pages.addLocale(page.id, FI, { from: EN, title: input.fi.title, ...(input.fi.slug ? { slug: input.fi.slug } : {}) });
+    await c.pages.addLocale(page.id, FI, { from: EN, ...input.fi });
     if (trees?.fi) {
-      await pages.saveDraft(page.id, FI, trees.fi as unknown as PageTree);
-      await pages.publish(page.id, FI);
+      await c.pages.setTree(page.id, FI, trees.fi);
+      await c.pages.publish(page.id, FI);
     }
   }
   return page;
 }
 
+/** A code-owned page (the home page, a collection's index): its address,
+ *  title and locales come from the registration, so there is nothing to
+ *  create — `find` returns the record, and the trees are written to it. */
+async function seedCodePage(path: string, trees: Trees) {
+  const page = (await c.pages.find(EN, path))!;
+  await c.pages.setTree(page.id, EN, trees.en);
+  await c.pages.publish(page.id, EN);
+  if (FI && trees.fi) {
+    await c.pages.setTree(page.id, FI, trees.fi);
+    await c.pages.publish(page.id, FI);
+  }
+  return page;
+}
+
 // --- people ---------------------------------------------------------
 
 const jane = await seedEntry("people", { name: "Jane Doe", role: "Founder" }, { role: "Perustaja" });
@@ -208,12 +228,12 @@ const nav = (locale: string, labels: [string, string]) => {
     { label: labels[1], href: links.about },
   ];
 };
-await seedEntry("header",
+await seedGlobal("header",
   { brand: "Lorem Co.", nav: nav(EN, ["Articles", "About"]) },
   FI ? { nav: nav(FI, ["Artikkelit", "Tietoa meistä"]) } : undefined,
 );
 
-await seedEntry("footer", {
+await seedGlobal("footer", {
   tagline: "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
   company: { title: "Company", links: [{ label: "About", href: paths(EN).about }, { label: "Articles", href: paths(EN).articles }, { label: "News", href: paths(EN).news }] },
   legal: { title: "Legal", links: [{ label: "Privacy", href: "#" }, { label: "Terms", href: "#" }] },
@@ -226,26 +246,23 @@ await seedEntry("footer", {
   social: { title: "Some", links: [{ label: "Instagram", href: "#" }, { label: "LinkedIn", href: "#" }] },
 } : undefined);
 
-await seedEntry("contact",
+await seedGlobal("contact",
   { email: "hello@lorem.co", phone: "+358 40 123 4567", address: "Lorem Street 1, 00100 Helsinki" },
   { address: "Loremkatu 1, 00100 Helsinki" },
 );
 
 // A visual global item's settings ride the row under the reserved
 // `$settings` key (spec 2026-09-13 §1): the quote is the site's one dark band.
-const quoteRow = await seedEntry("quote",
+const quoteRow = await seedGlobal("quote",
   { text: "Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores.", attribution: "Jane Doe, Founder", $settings: { background: "ink" } },
   { attribution: "Jane Doe, perustaja" },
 );
 // A placement: the quote as a linked node, the same row wherever it sits.
-const quote: Node = { id: "node-quote", type: "global", fields: { item: "quote", ref: quoteRow.id } };
+const quote: TreeNode = { id: "node-quote", type: "global", fields: { item: "quote", ref: quoteRow.id } };
 
 // --- pages ----------------------------------------------------------
 
-const imageText = (locale: string, linkLabel: string): Node => ({
-  id: "node-intro",
-  type: "imageText",
-  fields: {
+const imageText = (locale: string, linkLabel: string) => node(ImageText, {
     image: img.home2,
     heading: "Duis aute irure dolor in reprehenderit",
     text: doc(
@@ -253,34 +270,27 @@ const imageText = (locale: string, linkLabel: string): Node => ({
       p("Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium."),
     ),
     link: { label: linkLabel, href: paths(locale).about },
-  },
-  settings: { imageSide: "left" },
-});
+  }, { id: "node-intro", settings: { imageSide: "left" } });
 
-const points: Node = {
-  id: "node-points",
-  type: "points",
-  fields: {
+const points: TreeNode = {
+  ...node(Points, {
     heading: "Quis autem vel eum",
     points: [
       { icon: "circle", heading: "Iure reprehenderit", text: "Qui in ea voluptate velit esse quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat." },
       { icon: "square", heading: "Quo voluptas nulla", text: "At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis praesentium voluptatum." },
       { icon: "diamond", heading: "Pariatur deleniti", text: "Similique sunt in culpa qui officia deserunt mollitia animi, id est laborum et dolorum fuga." },
     ],
-  },
+  }, { id: "node-points" }),
   // One Spacing & layout step stored (spec 2026-09-14 §2); the rest are Default and store nothing.
   styles: { spacingBottom: "lg" },
 };
 
-const favourites = (heading: string): Node => ({
-  id: "node-favourites",
-  type: "favouriteArticles",
-  fields: { heading, items: [article.id] },
-});
+const favourites = (heading: string) => node(FavouriteArticles, { heading, items: [article.id] }, { id: "node-favourites" });
 
 // The custom section (spec 2026-09-14 §6): the editor's own rows of
 // richtext columns, widths in twelfths; Smoodly renders its layout CSS.
-const customSection = (locale: string): Node => ({
+// Not a registered section, so it is a plain node object.
+const customSection = (locale: string): TreeNode => ({
   id: "node-custom",
   type: "custom",
   fields: { rows: [
@@ -299,93 +309,70 @@ const homeTree = (locale: string, t: { kicker: string; buttons: [string, string]
   zones: {
     // The locked hero's one node. Pages created in the admin get theirs
     // from the editor (fillLockedZones on load); a seeded tree brings its own.
-    hero: [{
-      id: "node-hero",
-      type: "hero",
-      fields: {
-        kicker: t.kicker,
-        heading: "Consectetur adipiscing elit sed do eiusmod",
-        text: "Tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip.",
-        buttons: [
-          { label: t.buttons[0], href: paths(locale).about },
-          { label: t.buttons[1], href: paths(locale).articles },
-        ],
-        image: img.hero,
-      },
-    }],
+    hero: [node(Hero, {
+      kicker: t.kicker,
+      heading: "Consectetur adipiscing elit sed do eiusmod",
+      text: "Tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip.",
+      buttons: [
+        { label: t.buttons[0], href: paths(locale).about },
+        { label: t.buttons[1], href: paths(locale).articles },
+      ],
+      image: img.hero,
+    }, { id: "node-hero" })],
     body: [imageText(locale, t.link), quote, points, customSection(locale), favourites(t.favourites)],
   },
 });
 
-await seedPage(
-  { slug: "home", title: "Home", template: "home", fixed: "page:home", fi: { title: "Etusivu" } },
-  {
+await seedCodePage("/", {
     en: homeTree(EN, { kicker: "Lorem ipsum dolor", buttons: ["About us", "Read articles"], link: "About Lorem Co. →", favourites: "From the journal" }),
-    fi: FI ? homeTree(FI, { kicker: "Lorem ipsum dolor", buttons: ["Tietoa meistä", "Lue artikkelit"], link: "Tietoa Lorem Co:sta →", favourites: "Ajankohtaista" }) : undefined,
-  },
-);
+  fi: FI ? homeTree(FI, { kicker: "Lorem ipsum dolor", buttons: ["Tietoa meistä", "Lue artikkelit"], link: "Tietoa Lorem Co:sta →", favourites: "Ajankohtaista" }) : undefined,
+});
 
 // The Articles index: the fixed page at the collection's own segments,
 // so the mount in the Pages list opens this page. Only a hero; the grid
 // is the view's own fetch.
 const articlesHero = (heading: string, text: string): Tree => ({
-  zones: { hero: [{ id: "node-articles-hero", type: "pageHero", fields: { heading, text } }] },
+  zones: { hero: [node(PageHero, { heading, text }, { id: "node-articles-hero" })] },
+});
+await seedCodePage(`/${articlesSegment(EN)}`, {
+  en: articlesHero("Articles", "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt."),
+  fi: articlesHero("Artikkelit", "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt."),
 });
-await seedPage(
-  { slug: articlesSegment(EN), title: "Articles", template: "articlesIndex", fixed: "collection:articles", fi: { slug: articlesSegment(FI ?? EN), title: "Artikkelit" } },
-  {
-    en: articlesHero("Articles", "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt."),
-    fi: articlesHero("Artikkelit", "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt."),
-  },
-);
 
 // A folder and a page under it: the tree the admin lists, and the
 // breadcrumb the Page shape renders from the `page` prop. Each exists in
 // both locales with its own slug and title.
 const company = await seedPage({ slug: "company", title: "Company", template: null, fi: { slug: "yritys", title: "Yritys" } });
 
-// The News index: the fixed page on the news collection's nested address.
-// Code owns the whole address, so it is a root record holding the last
-// part as its slug (spec 2026-09-29 nested paths §3) — it shows under
-// Company in URL only; renaming Company never moves it.
-await seedPage(
-  { slug: lastPart(newsAddress(EN)), title: "News", template: "newsIndex", fixed: "collection:news", fi: { slug: lastPart(newsAddress(FI ?? EN)), title: "Uutiset" } },
-  {
-    en: { zones: { hero: [{ id: "node-news-hero", type: "pageHero", fields: { heading: "News", text: "Lorem ipsum dolor sit amet — what is new at Lorem Co." } }] } },
-    fi: { zones: { hero: [{ id: "node-news-hero", type: "pageHero", fields: { heading: "Uutiset", text: "Lorem ipsum dolor sit amet — mitä Lorem Co:lle kuuluu." } }] } },
-  },
-);
+// The News index: the code-owned page on the news collection's nested
+// address (spec 2026-09-29 nested paths §3) — it shows under Company in
+// URL only; renaming Company never moves it.
+await seedCodePage(`/${newsAddress(EN)}`, {
+  en: { zones: { hero: [node(PageHero, { heading: "News", text: "Lorem ipsum dolor sit amet — what is new at Lorem Co." }, { id: "node-news-hero" })] } },
+  fi: { zones: { hero: [node(PageHero, { heading: "Uutiset", text: "Lorem ipsum dolor sit amet — mitä Lorem Co:lle kuuluu." }, { id: "node-news-hero" })] } },
+});
 
 const aboutTree = (t: { kicker: string; people: string; description: string }): Tree => ({
   fields: { showInNavigation: true },
   meta: { description: t.description },
   zones: {
-    hero: [{
-      id: "node-about-hero",
-      type: "pageHero",
-      fields: {
-        kicker: t.kicker,
-        heading: "Lorem ipsum dolor sit amet, consectetur adipiscing elit",
-        text: "Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris.",
-        image: img.about,
-      },
-    }],
+    hero: [node(PageHero, {
+      kicker: t.kicker,
+      heading: "Lorem ipsum dolor sit amet, consectetur adipiscing elit",
+      text: "Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris.",
+      image: img.about,
+    }, { id: "node-about-hero" })],
     body: [
-      {
-        id: "node-about-text",
-        type: "imageText",
-        settings: { imageSide: "left" },
-        fields: {
+      node(ImageText, {
           heading: "Duis aute irure dolor in reprehenderit",
           text: doc(
             p("In voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."),
             p("Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis."),
             p("Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt."),
           ),
-        },
-      },
+      }, { id: "node-about-text", settings: { imageSide: "left" } }),
       quote,
-      { id: "node-people", type: "peopleSection", fields: { heading: t.people, people: [jane.id, john.id, anna.id, mark.id] } },
+      node(People, { heading: t.people, people: [jane.id, john.id, anna.id, mark.id] }, { id: "node-people" }),
     ],
   },
 });
@@ -403,8 +390,8 @@ const teamTree = (t: { heading: string; text: string; people: string }): Tree =>
   fields: { showInNavigation: true },
   meta: { description: t.text },
   zones: {
-    hero: [{ id: "node-team-hero", type: "pageHero", fields: { kicker: t.heading, heading: t.heading, text: t.text, image: img.about } }],
-    body: [{ id: "node-team-people", type: "peopleSection", fields: { heading: t.people, people: [jane.id, john.id, anna.id, mark.id] } }],
+    hero: [node(PageHero, { kicker: t.heading, heading: t.heading, text: t.text, image: img.about }, { id: "node-team-hero" })],
+    body: [node(People, { heading: t.people, people: [jane.id, john.id, anna.id, mark.id] }, { id: "node-team-people" })],
   },
 });
 await seedPage(

package/templates/lorem-intl/smoodly/ops.ts

@@ -4,8 +4,8 @@
 // async functions — hence the shape.)
 import { createAdminOpHandler, type AdminOpCall } from "smoodly/admin/next";
 import { config } from "./config";
-import { adminAuth, href, stores } from "./server";
+import { adminDeps } from "./server";
 
 export async function smoodlyOp(call: AdminOpCall) {
-  return createAdminOpHandler({ config, ...stores(), auth: adminAuth(), href })(call);
+  return createAdminOpHandler({ config, ...adminDeps() })(call);
 }

package/templates/lorem-intl/smoodly/server.ts

@@ -1,6 +1,8 @@
 // Server-only glue: the client, the 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
+// import time. The env shape is the package's (SMOODLY_*): the live site
+// needs SMOODLY_URL and SMOODLY_SECRET_KEY, the admin also
+// SMOODLY_PUBLISHABLE_KEY (the `smoodlyEnv("admin")` calls below); whether the
 // secret is a service-role key or a cloud write key is invisible here.
 //
 // Lazy on purpose, the site and renderer included: config.ts imports the
@@ -14,7 +16,7 @@ import {
 // The admin gate from `smoodly/admin`, which holds no client code: the site
 // routes import this file, and `smoodly/admin/next` would put the admin
 // shell in every live page's JavaScript.
-import { supabaseAdminAuth, type AdminAuth, type AuthConfig } from "smoodly/admin";
+import { createSmoodlyContent, supabaseAdminAuth, type AdminAuth, type AuthConfig, type SmoodlyContent } from "smoodly/admin";
 import { createPageRenderer, createSmoodlyQueries, type PageRegistration } from "smoodly/next";
 import type { SupabaseClient } from "@supabase/supabase-js";
 import { getPathname } from "@/i18n/navigation";
@@ -51,8 +53,7 @@ function bound(): Bound {
   // The admission table, read by the Members page (spec 2026-09-25 §4).
   const members = new SupabaseMemberStore(db);
   const auth = supabaseAdminAuth({ authUrl: env.authUrl, authKey: env.authKey, db });
-  // Shadows the exported `stores` below on purpose: `createSmoodlySite`
-  // takes this local closure, not the export, so it never re-enters `bound()`.
+  // The site layer's own view of the stores; nothing outside this file reads them.
   const stores = () => ({ pages, entries, assets });
   // The site layer: (locale, path) → page or entry, and the content API
   // `q` wraps below. Not exported — the app reads through `q`, which adds
@@ -71,27 +72,37 @@ function bound(): Bound {
   return cached;
 }
 
-export function stores() {
+/** The admin's wiring, for `smoodly/ops.ts` only. Scripts write through `content()`. */
+export function adminDeps() {
+  smoodlyEnv("admin"); // the admin signs in with the publishable key: a missing one is named here, not on a live page
+  const { pages, entries, assets, members, auth } = bound();
+  return { pages, entries, assets, members, auth, href };
+}
+
+/** Write content from code — seeds, migrations, route handlers (spec 2026-09-30 tester findings §1).
+ *  The admin's own operations with no signed-in editor: validation and publish checks apply, a failure
+ *  throws `SmoodlyContentError`. `content().pages.create(…)`, `.entries.create(…)`, `.globals.set(…)`,
+ *  `.media.upload(…)`; build tree nodes with `node(Section, fields)`. */
+export function content(): SmoodlyContent {
   const { pages, entries, assets, members } = bound();
-  return { pages, entries, assets, members };
+  return createSmoodlyContent({ config, pages, entries, assets, members, href });
 }
 
+export { node } from "smoodly";
+
 /** 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();
+  const env = smoodlyEnv("admin");
   return { url: env.authUrl, key: env.authKey };
 }
 
 /** What the browser needs to join the editing-presence channel — public values only (spec 2026-09-26 concurrency §5).
  * The space is asked of the database once per process. */
 export function presence(): Promise<PresenceConfig> {
-  return presenceConfig(smoodlyEnv());
+  return presenceConfig(smoodlyEnv("admin"));
 }
 
 /** Locale-relative CMS path → site URL: the one seam for the renderer