smoodly 0.0.44 → 0.0.46

package/dist/cli/import.js

@@ -10,8 +10,9 @@ import { join, resolve } from "node:path";
 import { MEDIA_CACHE_SECONDS } from "../media.js";
 import { CONTENT_TABLES } from "../sql-space.js";
 import { CONFLICT_COLUMNS, FORMAT, ROW_KEY, describeImport, emptyTables, foreignRows, insertPlan, intoSpace, missingRows, notEmptyMessage, rowKey, versionMismatchMessage, } from "../space-transfer.js";
-import { MEDIA_BUCKET, connectFromEnv, isAlreadyExists, readSchemaVersion, readSpaceRows, schemaRefusal, } from "./space-io.js";
+import { MEDIA_BUCKET, connectFromEnv, isAlreadyExists, readSchemaVersion, readSpaceRows, rebuildSpace, rebuiltMessage, schemaRefusal, } from "./space-io.js";
 import { readCurrentSpace } from "../current-space.js";
+import { loadConfig } from "./load-config.js";
 export const BATCH_ROWS = 500;
 export const notAnExport = (dir) => `Refusing: ${dir} is not a Smoodly export (no manifest.json).`;
 export const formatMismatch = (format) => `Refusing: this export's format is ${String(format)}; this smoodly reads format ${FORMAT}. Update smoodly.`;
@@ -57,6 +58,9 @@ export async function runImport(args, out, deps = {}) {
     }
     const newRows = missingRows(target, rows);
     let newFiles = 0;
+    // The rebuild after the writes assembles with the app's config: a folder without one is refused before them.
+    const config = deps.config ?? (await loadConfig(cwd));
+    let rebuilt = { pages: 0, entries: 0 };
     try {
         // Media first, so no ready asset row ever points at a missing file.
         for (const asset of rows.assets) {
@@ -84,6 +88,9 @@ export async function runImport(args, out, deps = {}) {
                     throw new Error(`inserting ${table}: ${res.error.message}`);
             }
         }
+        // The delivery tables are derived, never exported: rebuilt from what landed (spec 2026-10-07 delivery model §2).
+        // Also on a run that landed nothing new, so a run stopped here is finished by running it again.
+        rebuilt = await rebuildSpace(db, config);
     }
     catch (e) {
         out(`Import stopped: ${e instanceof Error ? e.message : String(e)}`);
@@ -92,9 +99,11 @@ export async function runImport(args, out, deps = {}) {
     }
     if (newRows === 0 && newFiles === 0) {
         out(nothingNew(space));
+        out(rebuiltMessage(rebuilt));
         return 0;
     }
     out(`Imported ${describeImport(rows)} into space ${space}.`);
+    out(rebuiltMessage(rebuilt));
     if (manifest.members.length > 0) {
         out(MEMBERS_HEADING);
         out(`  ${manifest.members.map((m) => `${m.email ?? "(no email)"} (${m.role})`).join(", ")}`);

package/dist/cli/load-collections.js

@@ -1,9 +1,10 @@
 // packages/smoodly/src/cli/load-collections.ts
 // Loads the app's `smoodly/collections.ts` — TypeScript, through tsx's
 // import API, under the app's own tsconfig so its `@/` alias resolves.
-// The barrel and not `smoodly/config.ts`: the config imports the page
-// shapes and with them React and Next, which a command line has no use
-// for; the barrel is what the config registers in both starters.
+// The barrel and not `smoodly/config.ts`: the collections are all a
+// migration needs, and the barrel is what the config registers in both
+// starters. (Since the registration split the config imports no
+// component either; a command that needs the whole registry may load it.)
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";

package/dist/cli/load-config.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedConfig } from "../config.ts";
+export declare const CONFIG_FILES: string[];
+export declare const noConfig: (cwd: string) => string;
+export declare function loadConfig(cwd: string): Promise<ResolvedConfig>;

package/dist/cli/load-config.js

@@ -0,0 +1,26 @@
+// packages/smoodly/src/cli/load-config.ts
+// Loads the app's whole config — TypeScript, through tsx's import API,
+// under the app's own tsconfig so its `@/` alias resolves — for a command
+// that assembles documents (import's rebuild, spec 2026-10-07 delivery
+// model §2). The config imports no component (the registration split), so
+// it loads outside the app. Astro keeps it at the root, Next under smoodly/.
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { tsImport } from "tsx/esm/api";
+export const CONFIG_FILES = ["smoodly.config.ts", "smoodly/config.ts", "src/smoodly/config.ts"];
+export const noConfig = (cwd) => `smoodly: no ${CONFIG_FILES.join(", ")} in ${cwd} — run this in your app's folder.`;
+export async function loadConfig(cwd) {
+    const file = CONFIG_FILES.map((name) => join(cwd, name)).find((path) => existsSync(path));
+    if (!file)
+        throw new Error(noConfig(cwd));
+    const tsconfig = join(cwd, "tsconfig.json");
+    const mod = (await tsImport(pathToFileURL(file).href, {
+        parentURL: import.meta.url,
+        ...(existsSync(tsconfig) ? { tsconfig } : {}),
+    }));
+    if (!mod.config?.registry) {
+        throw new Error(`smoodly: ${file} must export \`config\`, the result of defineConfig(…).`);
+    }
+    return mod.config;
+}

package/dist/cli/main.d.ts

@@ -2,7 +2,8 @@ import { type MigrateArgs } from "./migrate.ts";
 import { type ExportArgs } from "./export.ts";
 import { type ImportArgs } from "./import.ts";
 import { type AddAdminArgs } from "./add-admin.ts";
-export declare const USAGE = "usage: smoodly <command>\n\n  migrate [--check] [--collections <file>] [--migrations <dir>]\n    Copies the core schema files this package ships that supabase/migrations/\n    lacks, and writes one views file for the collections whose view is new or\n    changed. Prints the push or reset command; never runs it.\n\n    --check              write nothing; exit 1 when anything is pending, or when\n                         SMOODLY_SECRET_KEY (if set) cannot read the database\n    --collections <file> the module exporting `collections` (default smoodly/collections.ts)\n    --migrations <dir>   the app's migration folder (default supabase/migrations)\n\n  export [--out <dir>]\n    Writes the space SMOODLY_SECRET_KEY names \u2014 every content row, history\n    included, and the media files \u2014 into a folder (default\n    smoodly-export-<date>). Reads only.\n\n  import <dir>\n    Writes an export folder into the key's space, which must be empty or hold\n    only this export's rows (an earlier run to continue). Never deletes.\n\n  add-admin <email> [--admin-url <url>]\n    Makes <email> an admin of the key's space: with SMOODLY_ADMIN_PASSWORD\n    set, creates the account with that password; without, mails an invite\n    whose link lands on --admin-url (default: SITE_URL + /admin).";
+import { type RebuildArgs } from "./rebuild.ts";
+export declare const USAGE = "usage: smoodly <command>     (smoodly --version prints the version)\n\n  migrate [--check] [--collections <file>] [--migrations <dir>]\n    Copies the core schema files this package ships that supabase/migrations/\n    lacks, and writes one views file for the collections whose view is new or\n    changed. Prints the push or reset command; never runs it.\n\n    --check              write nothing; exit 1 when anything is pending, or when\n                         SMOODLY_SECRET_KEY (if set) cannot read the database\n    --collections <file> the module exporting `collections` (default\n                         smoodly/collections.ts, or src/smoodly/collections.ts\n                         when only that one exists)\n    --migrations <dir>   the app's migration folder (default supabase/migrations)\n\n  export [--out <dir>]\n    Writes the space SMOODLY_SECRET_KEY names \u2014 every content row, history\n    included, and the media files \u2014 into a folder (default\n    smoodly-export-<date>). Reads only.\n\n  import <dir>\n    Writes an export folder into the key's space, which must be empty or hold\n    only this export's rows (an earlier run to continue). Never deletes. Ends\n    by rebuilding the delivery tables with the app's config (smoodly.config.ts,\n    smoodly/config.ts or src/smoodly/config.ts), so run it in the app's folder.\n\n  rebuild\n    Rewrites the delivery tables of the key's space: the finished document of\n    every published page, entry and global, assembled with the app's config.\n    A publish keeps them current and a document behind the content model is\n    rebuilt by its first visitor; run this after a deploy for a warm start.\n\n  add-admin <email> [--admin-url <url>]\n    Makes <email> an admin of the key's space: with SMOODLY_ADMIN_PASSWORD\n    set, creates the account with that password; without, mails an invite\n    whose link lands on --admin-url (default: SITE_URL + /admin).";
 export type Parsed = {
     command: "migrate";
     args: MigrateArgs;
@@ -15,8 +16,13 @@ export type Parsed = {
 } | {
     command: "add-admin";
     args: AddAdminArgs;
+} | {
+    command: "rebuild";
+    args: RebuildArgs;
 } | {
     command: "help";
+} | {
+    command: "version";
 } | {
     command: "error";
     message: string;

package/dist/cli/main.js

@@ -1,15 +1,17 @@
 // packages/smoodly/src/cli/main.ts
-// `smoodly` — the package's command line. Four subcommands: migrate
+// `smoodly` — the package's command line. Five subcommands: migrate
 // (spec 2026-09-26 §2), export and import (spec 2026-09-28), add-admin
-// (spec 2026-09-30 tester findings §1). Exit codes:
+// (spec 2026-09-30 tester findings §1), rebuild (spec 2026-10-07 delivery model §4). Exit codes:
 // 0 done or nothing to do, 1 pending (--check), refused or failed, 2 usage.
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { runMigrate } from "./migrate.js";
+import { DEFAULT_COLLECTIONS, runMigrate } from "./migrate.js";
 import { runExport } from "./export.js";
 import { runImport } from "./import.js";
 import { runAddAdmin } from "./add-admin.js";
-export const USAGE = `usage: smoodly <command>
+import { runRebuild } from "./rebuild.js";
+import { SMOODLY_VERSION } from "../version.js";
+export const USAGE = `usage: smoodly <command>     (smoodly --version prints the version)
 
   migrate [--check] [--collections <file>] [--migrations <dir>]
     Copies the core schema files this package ships that supabase/migrations/
@@ -18,7 +20,9 @@ export const USAGE = `usage: smoodly <command>
 
     --check              write nothing; exit 1 when anything is pending, or when
                          SMOODLY_SECRET_KEY (if set) cannot read the database
-    --collections <file> the module exporting \`collections\` (default smoodly/collections.ts)
+    --collections <file> the module exporting \`collections\` (default
+                         smoodly/collections.ts, or src/smoodly/collections.ts
+                         when only that one exists)
     --migrations <dir>   the app's migration folder (default supabase/migrations)
 
   export [--out <dir>]
@@ -28,7 +32,15 @@ export const USAGE = `usage: smoodly <command>
 
   import <dir>
     Writes an export folder into the key's space, which must be empty or hold
-    only this export's rows (an earlier run to continue). Never deletes.
+    only this export's rows (an earlier run to continue). Never deletes. Ends
+    by rebuilding the delivery tables with the app's config (smoodly.config.ts,
+    smoodly/config.ts or src/smoodly/config.ts), so run it in the app's folder.
+
+  rebuild
+    Rewrites the delivery tables of the key's space: the finished document of
+    every published page, entry and global, assembled with the app's config.
+    A publish keeps them current and a document behind the content model is
+    rebuilt by its first visitor; run this after a deploy for a warm start.
 
   add-admin <email> [--admin-url <url>]
     Makes <email> an admin of the key's space: with SMOODLY_ADMIN_PASSWORD
@@ -38,6 +50,8 @@ export function parseArgs(argv) {
     const [command, ...rest] = argv;
     if (!command || command === "help" || argv.some((a) => a === "--help" || a === "-h"))
         return { command: "help" };
+    if (command === "--version" || command === "-v")
+        return { command: "version" };
     if (command === "export") {
         const args = { out: null };
         for (let i = 0; i < rest.length; i++) {
@@ -54,6 +68,11 @@ export function parseArgs(argv) {
             return { command: "error", message: "import needs one export folder: smoodly import <dir>" };
         return { command: "import", args: { dir: rest[0] } };
     }
+    if (command === "rebuild") {
+        if (rest.length > 0)
+            return { command: "error", message: `unexpected argument "${rest[0]}"` };
+        return { command: "rebuild", args: {} };
+    }
     if (command === "add-admin") {
         const usage = { command: "error", message: "add-admin needs one email: smoodly add-admin <email> [--admin-url <url>]" };
         const [email, ...flags] = rest;
@@ -67,7 +86,7 @@ export function parseArgs(argv) {
     }
     if (command !== "migrate")
         return { command: "error", message: `unknown command "${command}"` };
-    const args = { check: false, collections: "smoodly/collections.ts", migrations: "supabase/migrations" };
+    const args = { check: false, collections: DEFAULT_COLLECTIONS, migrations: "supabase/migrations" };
     for (let i = 0; i < rest.length; i++) {
         const a = rest[i];
         if (a === "--check")
@@ -87,6 +106,10 @@ export async function main(argv, out = console.log) {
         out(USAGE);
         return 0;
     }
+    if (parsed.command === "version") {
+        out(SMOODLY_VERSION);
+        return 0;
+    }
     if (parsed.command === "error") {
         out(`smoodly: ${parsed.message}\n\n${USAGE}`);
         return 2;
@@ -98,6 +121,8 @@ export async function main(argv, out = console.log) {
             return await runExport(parsed.args, out);
         if (parsed.command === "add-admin")
             return await runAddAdmin(parsed.args, out);
+        if (parsed.command === "rebuild")
+            return await runRebuild(parsed.args, out);
         return await runMigrate(parsed.args, out);
     }
     catch (e) {

package/dist/cli/migrate.d.ts

@@ -6,6 +6,9 @@ export type MigrateArgs = {
     collections: string;
     migrations: string;
 };
+export declare const DEFAULT_COLLECTIONS = "smoodly/collections.ts";
+/** The Astro starter keeps the setup under src/ (plan 2026-10-06 astro adapter 3); the default follows it when the Next path is absent. */
+export declare function collectionsFile(cwd: string, given: string, exists?: (p: string) => boolean): string;
 /** The folder shipped in the package: `../../migrations/` from dist/cli/ and from src/cli/ alike. */
 export declare const PACKAGE_MIGRATIONS_DIR: string;
 export declare const NO_FOLDER: (dir: string) => string;

package/dist/cli/migrate.js

@@ -15,6 +15,13 @@ import { resolveSmoodlyEnv } from "../env.js";
 import { loadAppEnv } from "./space-io.js";
 import { planIsEmpty, planMigrate } from "../migrations.js";
 import { loadCollections } from "./load-collections.js";
+export const DEFAULT_COLLECTIONS = "smoodly/collections.ts";
+/** The Astro starter keeps the setup under src/ (plan 2026-10-06 astro adapter 3); the default follows it when the Next path is absent. */
+export function collectionsFile(cwd, given, exists = existsSync) {
+    if (given !== DEFAULT_COLLECTIONS || exists(resolve(cwd, given)))
+        return given;
+    return exists(resolve(cwd, "src/smoodly/collections.ts")) ? "src/smoodly/collections.ts" : given;
+}
 /** The folder shipped in the package: `../../migrations/` from dist/cli/ and from src/cli/ alike. */
 export const PACKAGE_MIGRATIONS_DIR = fileURLToPath(new URL("../../migrations/", import.meta.url));
 export const NO_FOLDER = (dir) => `No supabase/migrations folder here (${dir}) — nothing to do. Run it in your app's folder, or pass --migrations. (Smoodly Cloud keeps the schema current; a self-host app gets the folder from \`supabase init\`.)`;
@@ -87,7 +94,7 @@ export async function runMigrate(args, out, deps = {}) {
         out(NO_FOLDER(appDir));
         return 0;
     }
-    const collections = await (deps.load ?? loadCollections)(resolve(cwd, args.collections), cwd);
+    const collections = await (deps.load ?? loadCollections)(resolve(cwd, collectionsFile(cwd, args.collections)), cwd);
     const plan = planMigrate({
         packageFiles: await readSqlFiles(PACKAGE_MIGRATIONS_DIR),
         appFiles: await readSqlFiles(appDir),

package/dist/cli/rebuild.d.ts

@@ -0,0 +1,23 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+import type { ResolvedConfig } from "../config.ts";
+import { type SpaceConnection } from "./space-io.ts";
+export type RebuildArgs = Record<string, never>;
+export type RebuildDeps = {
+    cwd?: string;
+    connection?: SpaceConnection;
+    /** The app's config; default: loaded from the folder (load-config.ts). */
+    config?: ResolvedConfig;
+    /** Test seam: the projection; default rebuildSpace. */
+    rebuild?: (db: SupabaseClient, config: ResolvedConfig) => Promise<{
+        pages: number;
+        entries: number;
+        model: string;
+    }>;
+};
+/** The line a rebuild ends with: import's counts, and the model the rows now carry. */
+export declare const rebuildMessage: (r: {
+    pages: number;
+    entries: number;
+    model: string;
+}) => string;
+export declare function runRebuild(_args: RebuildArgs, out: (line: string) => void, deps?: RebuildDeps): Promise<number>;

package/dist/cli/rebuild.js

@@ -0,0 +1,22 @@
+import { schemaBehind, schemaBehindMessage } from "../schema-version.js";
+import { loadConfig } from "./load-config.js";
+import { connectFromEnv, readSchemaVersion, rebuildSpace, rebuiltMessage, schemaRefusal } from "./space-io.js";
+/** The line a rebuild ends with: import's counts, and the model the rows now carry. */
+export const rebuildMessage = (r) => `${rebuiltMessage(r).replace(/\.$/, "")} (model ${r.model}).`;
+export async function runRebuild(_args, out, deps = {}) {
+    const cwd = deps.cwd ?? process.cwd();
+    const { db } = deps.connection ?? connectFromEnv(cwd);
+    const schema = await readSchemaVersion(db);
+    if ("missing" in schema) {
+        out(schemaRefusal(schema.missing, "Rebuild"));
+        return 1;
+    }
+    // A behind schema has no delivery tables (version 8) or reads columns it lacks: refused before any write.
+    if (schemaBehind(schema.version)) {
+        out(schemaBehindMessage(schema.version));
+        return 1;
+    }
+    const config = deps.config ?? (await loadConfig(cwd));
+    out(rebuildMessage(await (deps.rebuild ?? rebuildSpace)(db, config)));
+    return 0;
+}

package/dist/cli/space-io.d.ts

@@ -1,4 +1,5 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
+import type { ResolvedConfig } from "../config.ts";
 import type { ContentTable } from "../sql-space.ts";
 import { type Row } from "../space-transfer.ts";
 export type SpaceConnection = {
@@ -13,7 +14,20 @@ export declare function loadAppEnv(cwd: string, env?: Record<string, string | un
  *  folder, so the error names the folder it looked in. */
 export declare function connectFromEnv(cwd: string, env?: Record<string, string | undefined>): SpaceConnection;
 export { readSchemaVersion } from "../schema-read.ts";
-export declare function schemaRefusal(missing: "key" | "schema", command: "Export" | "Import"): string;
+/** The key's space projected whole into the delivery tables (spec 2026-10-07 delivery model §2): the stores and
+ *  the site built from the config as the app's glue builds them, then every page and entry. */
+export declare function rebuildSpace(db: SupabaseClient, config: ResolvedConfig): Promise<{
+    model: string;
+    pages: number;
+    entries: number;
+    stale: number;
+}>;
+/** The line a rebuild ends with. */
+export declare const rebuiltMessage: (counts: {
+    pages: number;
+    entries: number;
+}) => string;
+export declare function schemaRefusal(missing: "key" | "schema", command: "Export" | "Import" | "Rebuild"): string;
 /** Every row of one table in one space, paged in primary-key order. The space filter is explicit: a service-role key sees every space. */
 export declare function readSpaceRows(db: SupabaseClient, table: ContentTable, space: string, where?: Record<string, string>, columns?: string): Promise<Row[]>;
 type StorageErrorLike = {

package/dist/cli/space-io.js

@@ -7,7 +7,10 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { parseEnv } from "node:util";
+import { createSupabaseStores, siteOptions } from "../bind.js";
 import { createSmoodlyClient } from "../client.js";
+import { projectAll } from "../project.js";
+import { createSmoodlySite } from "../site.js";
 import { resolveSmoodlyEnv } from "../env.js";
 import { ROW_KEY } from "../space-transfer.js";
 export const MEDIA_BUCKET = "media";
@@ -38,6 +41,17 @@ export function connectFromEnv(cwd, env = process.env) {
     return { db: createSmoodlyClient(resolveSmoodlyEnv(env)) };
 }
 export { readSchemaVersion } from "../schema-read.js";
+/** The key's space projected whole into the delivery tables (spec 2026-10-07 delivery model §2): the stores and
+ *  the site built from the config as the app's glue builds them, then every page and entry. */
+export async function rebuildSpace(db, config) {
+    const { pages, entries, assets, published } = createSupabaseStores(db, config);
+    const { projector, cacheKey } = createSmoodlySite(siteOptions(config, () => ({ pages, entries, assets, published })));
+    const names = [...(config.registry.collections ?? []), ...(config.registry.globals ?? [])].map((c) => c.name);
+    // The model fingerprint every row now carries: what a rebuild after a deploy wrote.
+    return { ...(await projectAll({ stores: { pages, entries }, projector, names })), model: cacheKey };
+}
+/** The line a rebuild ends with. */
+export const rebuiltMessage = (counts) => `Rebuilt the delivery tables: ${counts.pages} ${counts.pages === 1 ? "page" : "pages"}, ${counts.entries} ${counts.entries === 1 ? "entry" : "entries"}.`;
 export function schemaRefusal(missing, command) {
     return missing === "key"
         ? `${command} needs SMOODLY_SECRET_KEY — the service-role key, or the cloud's write key. The publishable key reads no content.`

package/dist/client.js

@@ -11,10 +11,15 @@ export function clientOptions(env) {
     // without one (spec 2026-09-30 tester findings §4): a self-host service role is a valid apikey.
     return { url: env.url, key: env.publishableKey || env.secretKey, headers: { Authorization: `Bearer ${env.secretKey}` } };
 }
+/** Where a framework adapter hears each database call (spec 2026-10-07 delivery model): the Astro request
+ *  scope installs it and counts, so a test can hold a live page to one lookup. A global, not an import:
+ *  the client stays free of any adapter. */
+const READ_COUNTER = Symbol.for("smoodly:read-counter");
 /** fetch that names the variable behind two failures supabase-js reports bare: the network
  *  ("TypeError: fetch failed") and PostgREST refusing the key. */
 function namedFetch(url) {
     return async (input, init) => {
+        globalThis[READ_COUNTER]?.();
         let res;
         try {
             res = await fetch(input, init);

package/dist/config.d.ts

@@ -5,28 +5,28 @@ import { type Addresses } from "./addresses.ts";
 import type { Anchors } from "./anchors.ts";
 import { type StyleValues, type StyleValuesInput } from "./styles.ts";
 import { type CustomConfigInput, type ResolvedCustom } from "./custom/index.ts";
-type Registered = {
-    schema: {
-        kind: string;
-        name: string;
-        slug?: string | Record<string, string>;
-        collection?: string;
-        fields?: Record<string, Descriptor>;
-        settings?: Record<string, Descriptor>;
-        /** The section's toggles on Smoodly's styles set and the CSS box (spec 2026-09-14 §2, §4). */
-        styles?: false | {
-            omit: string[];
-        };
-        css?: false;
+/** A section, element or page schema as the config reads it. */
+export type RegisteredSchema = {
+    kind: string;
+    name: string;
+    title?: string;
+    slug?: string | Record<string, string>;
+    collection?: string;
+    fields?: Record<string, Descriptor>;
+    settings?: Record<string, Descriptor>;
+    /** The section's toggles on Smoodly's styles set and the CSS box (spec 2026-09-14 §2, §4). */
+    styles?: false | {
+        omit: string[];
     };
+    css?: false;
 };
 export type SmoodlyConfig = {
     registry: {
-        sections?: Registered[];
-        elements?: Registered[];
+        sections?: RegisteredSchema[];
+        elements?: RegisteredSchema[];
         collections?: CollectionSchema<any>[];
-        /** Page shapes and entry pages alike — everything that renders a URL. */
-        pages?: Registered[];
+        /** Page types. Entry pages are views: they go to defineViews. */
+        pages?: RegisteredSchema[];
         /** Global content: code-declared singletons (spec 2026-09-07). */
         globals?: GlobalSchema[];
     };
@@ -49,7 +49,7 @@ export type SmoodlyConfig = {
     styles?: StyleValuesInput;
     /** The custom-CSS box (spec 2026-09-14 §4): off unless true. */
     css?: boolean;
-    /** The custom section (spec 2026-09-14 §6): the columns' toolset, the stacking breakpoint, the project's bound RichText. */
+    /** The custom section (spec 2026-09-14 §6): the columns' toolset and the stacking breakpoint. The bound RichText is a view: defineViews takes it. */
     custom?: CustomConfigInput;
     /** Slug of the page record the site root serves. The admin maps this
      * slug to "/" (canvas URL, Pages list) and every other slug to
@@ -69,7 +69,16 @@ export type SmoodlyConfig = {
         path?: string;
     };
 };
-export type ResolvedConfig = Omit<SmoodlyConfig, "styles" | "custom" | "admin"> & {
+/** The registry as defineConfig resolves it: schemas, and page types only under `pages`. */
+export type Registry = {
+    sections: RegisteredSchema[];
+    elements: RegisteredSchema[];
+    collections: CollectionSchema<any>[];
+    globals: GlobalSchema[];
+    pages: RegisteredSchema[];
+};
+export type ResolvedConfig = Omit<SmoodlyConfig, "styles" | "custom" | "admin" | "registry"> & {
+    registry: Registry;
     homePageSlug: string;
     /** How deep editors may nest pages in the tree. Default 1 (flat). */
     pageDepth: number;
@@ -98,4 +107,3 @@ export type ResolvedConfig = Omit<SmoodlyConfig, "styles" | "custom" | "admin">
  *  target of every media edge; `media`: the admin's Media screen route. */
 export declare const RESERVED_NAMES: readonly string[];
 export declare function defineConfig(config: SmoodlyConfig): ResolvedConfig;
-export {};