smoodly 0.0.36 → 0.0.38

package/dist/admin/fixed-nodes.d.ts

@@ -8,7 +8,7 @@ export declare function fixedNodeOf(record: {
     fixed?: string | null;
 }, config: ResolvedConfig): FixedNode | null;
 /** Create every code-owned record that has none yet and give each the
- *  locales it lacks, then list. Code wins an address (spec 2026-09-29
+ *  locales it lacks, publishing what it creates, then list. Code wins an address (spec 2026-09-29
  *  anchored paths §4): an editor's page already there changes nothing
  *  here — the index serves the record, the Pages list flags the page. */
 export declare function ensureFixedNodes(pages: PageStore, config: ResolvedConfig): Promise<PageRecord[]>;

package/dist/admin/fixed-nodes.js

@@ -4,8 +4,31 @@ export const fixedNodeSpecs = (config) => codeAddresses({ locales: config.locale
 export function fixedNodeOf(record, config) {
     return record.fixed ? fixedNodeSpecs(config).find((s) => s.key === record.fixed) ?? null : null;
 }
+/** Publish a row this call just created (spec 2026-09-30 tester findings §2): the site served the address
+ *  from code until now, so the empty page goes live as it was. A row that already existed is never
+ *  published here — an editor's unpublish stands. A folder has no tree to publish. */
+async function publishCreated(pages, record, locale, address) {
+    if (record.template === null)
+        return record;
+    try {
+        // A locale added to an older record starts as a copy of the default locale's DRAFT. What goes live
+        // is the empty page code was serving; the copy stays the new locale's draft, for an editor to publish.
+        const copy = await pages.getDraftTree(record.id, locale);
+        const empty = !copy || (Object.values(copy.zones).every((nodes) => nodes.length === 0) && !copy.fields && !copy.meta);
+        if (empty)
+            return await pages.publish(record.id, locale);
+        await pages.saveDraft(record.id, locale, { zones: {} });
+        await pages.publish(record.id, locale);
+        await pages.saveDraft(record.id, locale, copy);
+        return (await pages.getPage(record.id)) ?? record;
+    }
+    catch (e) {
+        console.warn(`smoodly: could not publish "${address}" in "${locale}": ${e instanceof Error ? e.message : String(e)}`);
+        return record;
+    }
+}
 /** Create every code-owned record that has none yet and give each the
- *  locales it lacks, then list. Code wins an address (spec 2026-09-29
+ *  locales it lacks, publishing what it creates, then list. Code wins an address (spec 2026-09-29
  *  anchored paths §4): an editor's page already there changes nothing
  *  here — the index serves the record, the Pages list flags the page. */
 export async function ensureFixedNodes(pages, config) {
@@ -28,6 +51,7 @@ export async function ensureFixedNodes(pages, config) {
                     console.warn(`smoodly: could not materialize "${defAddress}": ${message}`);
                 continue;
             }
+            record = await publishCreated(pages, record, def, defAddress);
         }
         else if (record.template === null && spec.template !== null) {
             // The collection gained its index page. A racing admin's hasTemplate is that admin winning.
@@ -48,6 +72,7 @@ export async function ensureFixedNodes(pages, config) {
             wrote = true;
             try {
                 record = await pages.addLocale(record.id, locale, { from: def, slug: lastPart(address) });
+                record = await publishCreated(pages, record, locale, address);
             }
             catch (e) {
                 // Only a concurrent add of the SAME locale is a race; it skips silently.

package/dist/admin/index.d.ts

@@ -12,3 +12,4 @@ export { serializeAdminConfig } from "./serialize.ts";
 export type { AdminRegistry, AdminSection, AdminCollection, AdminPageTemplate, AdminGlobal, AdminField } from "./serialize.ts";
 export * from "./tree-ops.ts";
 export { validateFields, type FieldError } from "./validate.ts";
+export { createSmoodlyContent, SmoodlyContentError, type SmoodlyContent, type ContentDeps } from "../content/content-api.ts";

package/dist/admin/index.js

@@ -7,3 +7,4 @@ export { supabaseAdminAuth } from "./supabase-auth.js";
 export { serializeAdminConfig } from "./serialize.js";
 export * from "./tree-ops.js";
 export { validateFields } from "./validate.js";
+export { createSmoodlyContent, SmoodlyContentError } from "../content/content-api.js";

package/dist/admin/ops-impl.js

@@ -1,7 +1,7 @@
 import { entryErrors, entryFieldsIn, entryTitleIn } from "../entry-store.js";
 import { chainOf, isSegment, pagePathIn } from "../paths.js";
 import { servedAnchor } from "../anchors.js";
-import { distinctTags } from "../tags.js";
+import { canonicalTags, distinctTags } from "../tags.js";
 import { can, isMemberRole, normalizeRole } from "../permissions.js";
 import { ASSET_COLLECTION } from "../media.js";
 import { adminHref, adminSlugTaken, isAdminSlug } from "../admin-path.js";
@@ -117,6 +117,23 @@ export function createAdminOps(deps) {
     const href = deps.href ?? ((path) => path);
     const by = deps.actor?.email ?? undefined;
     const collectionFields = (name) => config.registry.collections?.find((c) => c.name === name)?.fields ?? null;
+    /** The distinct tags a field holds across the collection: a localized field reads `locale`'s rows, a shared one every entry. */
+    const tagsIn = (records, field, localized, locale, except) => distinctTags(localized
+        ? records.flatMap((r) => (r.id !== except && r.locales[locale] ? [r.locales[locale].fields[field]] : []))
+        : records.flatMap((r) => (r.id !== except ? [r.fields[field]] : [])));
+    /** Every f.tags() value takes the collection's existing spelling (spec 2026-09-30 tester findings §5).
+     *  `except` is the entry being saved: its own old spelling is not a precedent. */
+    async function foldTags(collection, locale, fields, descriptors, except) {
+        const tagKeys = Object.entries(descriptors).filter(([key, d]) => d.type === "tags" && Array.isArray(fields[key]));
+        if (tagKeys.length === 0)
+            return fields;
+        const records = await entries.list(collection);
+        const out = { ...fields };
+        for (const [key, d] of tagKeys) {
+            out[key] = canonicalTags(out[key], tagsIn(records, key, d.localized === true, locale, except));
+        }
+        return out;
+    }
     // Element nodes inside richtext validate against these (spec 2026-09-08 block nodes §2).
     // The serialized registry drift walks (spec 2026-09-27 editor safety §2) — the admin client's shape.
     let adminRegistryMemo = null;
@@ -739,11 +756,7 @@ export function createAdminOps(deps) {
                 const d = descriptors[field];
                 if (d?.type !== "tags")
                     return err("validation", `smoodly: "${field}" is not a tags field of "${collection}".`);
-                const records = await entries.list(collection);
-                const values = d.localized === true
-                    ? records.flatMap((r) => (r.locales[locale] ? [r.locales[locale].fields[field]] : []))
-                    : records.map((r) => r.fields[field]);
-                return ok(distinctTags(values));
+                return ok(tagsIn(await entries.list(collection), field, d.localized === true, locale));
             }),
             get: (collection, id, locale) => guard(async () => {
                 const unsupported = supportedLocale(locale);
@@ -770,7 +783,7 @@ export function createAdminOps(deps) {
                 const descriptors = collectionFields(collection);
                 if (!descriptors)
                     return err("not_found", `smoodly: no collection named "${collection}".`);
-                const created = await entries.create(collection, withDefaults(input.fields, descriptors), { locale: input.locale, parentId: input.parentId ?? null }, by);
+                const created = await entries.create(collection, withDefaults(await foldTags(collection, input.locale, input.fields, descriptors), descriptors), { locale: input.locale, parentId: input.parentId ?? null }, by);
                 expireCollection(collection);
                 return ok(created);
             }),
@@ -796,7 +809,7 @@ export function createAdminOps(deps) {
                 }
                 let entry;
                 try {
-                    entry = await entries.update(collection, id, locale, fields, by, token, { redirect: options?.redirect ?? true });
+                    entry = await entries.update(collection, id, locale, await foldTags(collection, locale, fields, descriptors, id), by, token, { redirect: options?.redirect ?? true });
                 }
                 catch (e) {
                     // A sibling's slug is the slug field's problem, not the whole draft's (spec 2026-09-28 ASCII slugs §5).

package/dist/admin/shell/SchemaNotice.js

@@ -1,4 +1,4 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 export function SchemaNotice({ status }) {
-    return (_jsx("div", { style: { height: "100vh", display: "grid", placeItems: "center", padding: 24, color: "var(--text)" }, children: _jsxs("div", { style: { maxWidth: 520, display: "grid", gap: 12 }, children: [_jsx("h1", { className: "sm-title", style: { fontSize: 22, margin: 0 }, children: "The database needs an update" }), _jsxs("p", { style: { margin: 0 }, children: ["The database schema is at version ", status.database ?? "none", ". This version of Smoodly needs version ", status.required, "."] }), _jsx("p", { style: { margin: 0 }, children: "From the site's folder:" }), _jsx("pre", { className: "sm-code", children: _jsx("code", { children: "npx smoodly migrate" }) }), _jsx("p", { style: { margin: 0 }, children: "then apply it:" }), _jsx("pre", { className: "sm-code", children: _jsx("code", { children: "supabase db push" }) }), _jsxs("p", { style: { margin: 0, color: "var(--text-muted)" }, children: ["That is for a hosted project; for the local stack run ", _jsx("code", { children: "supabase db reset" }), ". Reload this page afterwards."] })] }) }));
+    return (_jsx("div", { style: { height: "100vh", display: "grid", placeItems: "center", padding: 24, color: "var(--text)" }, children: _jsxs("div", { style: { maxWidth: 520, display: "grid", gap: 12 }, children: [_jsx("h1", { className: "sm-title", style: { fontSize: 22, margin: 0 }, children: "The database needs an update" }), _jsxs("p", { style: { margin: 0 }, children: ["The database schema is at version ", status.database ?? "none", ". This version of Smoodly needs version ", status.required, "."] }), _jsx("p", { style: { margin: 0 }, children: "From the site's folder:" }), _jsx("pre", { className: "sm-code", children: _jsx("code", { children: "npx smoodly migrate" }) }), _jsx("p", { style: { margin: 0 }, children: "then apply it:" }), _jsx("pre", { className: "sm-code", children: _jsx("code", { children: "supabase db push" }) }), _jsxs("p", { style: { margin: 0, color: "var(--text-muted)" }, children: ["That is for a hosted project; for the local stack run ", _jsx("code", { children: "supabase migration up" }), ", which keeps the content. Reload this page afterwards."] })] }) }));
 }

package/dist/admin/supabase-auth.js

@@ -6,12 +6,18 @@
 // has one space.
 import { createClient } from "@supabase/supabase-js";
 export function supabaseAdminAuth(input) {
-    const auth = createClient(input.authUrl, input.authKey, {
-        auth: { persistSession: false, autoRefreshToken: false },
-    });
+    // Built on the first sign-in check, not here: a live page constructs the glue with no publishable
+    // key and never verifies anyone (spec 2026-09-30 tester findings §4).
+    let client = null;
+    const auth = () => {
+        if (!input.authKey) {
+            throw new Error("smoodly: set SMOODLY_PUBLISHABLE_KEY in .env.local — the admin signs in with it (Deploying: https://smoodly.io/docs/getting-started/deploying).");
+        }
+        return (client ?? (client = createClient(input.authUrl, input.authKey, { auth: { persistSession: false, autoRefreshToken: false } })));
+    };
     return {
         async verify(token) {
-            const res = await auth.auth.getUser(token);
+            const res = await auth().auth.getUser(token);
             return res.data.user ? { userId: res.data.user.id, email: res.data.user.email ?? null } : null;
         },
         async memberOf(userId) {

package/dist/cli/add-admin.d.ts

@@ -0,0 +1,11 @@
+import type { MemberStore } from "../member-store.ts";
+/** `adminUrl`: where an invite link lands — the site's admin address. */
+export type AddAdminArgs = {
+    email: string;
+    adminUrl?: string;
+};
+export declare function runAddAdmin(args: AddAdminArgs, out: (line: string) => void, deps?: {
+    cwd?: string;
+    members?: MemberStore;
+    env?: Record<string, string | undefined>;
+}): Promise<number>;

package/dist/cli/add-admin.js

@@ -0,0 +1,25 @@
+// `smoodly add-admin <email>` (spec 2026-09-30 tester findings §1): the first
+// admin of a project the installer did not make — after an import, say.
+import { SupabaseMemberStore } from "../supabase-member-store.js";
+import { addAdmin } from "../content/content-api.js";
+import { connectFromEnv } from "./space-io.js";
+export async function runAddAdmin(args, out, deps = {}) {
+    const members = deps.members ?? new SupabaseMemberStore(connectFromEnv(deps.cwd ?? process.cwd()).db);
+    // Read after connectFromEnv: it loads the app's .env files.
+    const password = (deps.env ?? process.env).SMOODLY_ADMIN_PASSWORD;
+    // An invite link has to land on the admin, which finishes the sign-in: --admin-url, else SITE_URL's /admin.
+    const siteUrl = (deps.env ?? process.env).SITE_URL;
+    const redirectTo = args.adminUrl ?? (siteUrl ? `${siteUrl.replace(/\/+$/, "")}/admin` : undefined);
+    const { invited } = await addAdmin(members, args.email, password !== undefined ? { password } : { redirectTo });
+    if (password !== undefined)
+        out(`${args.email} is an admin. Sign in at your admin address with that password (an account that already existed keeps its own).`);
+    else if (invited) {
+        out(`Invited ${args.email} as an admin: the mail has the sign-in link.`);
+        out(redirectTo
+            ? `The link lands on ${redirectTo}, which must be in the Auth project's redirect URLs.`
+            : "No --admin-url and no SITE_URL: the link lands on the Auth project's Site URL. If that is not the admin, run it again with --admin-url <the admin's address>, or set SMOODLY_ADMIN_PASSWORD.");
+    }
+    else
+        out(`${args.email} already had an account and is now an admin.`);
+    return 0;
+}

package/dist/cli/main.d.ts

@@ -1,7 +1,8 @@
 import { type MigrateArgs } from "./migrate.ts";
 import { type ExportArgs } from "./export.ts";
 import { type ImportArgs } from "./import.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\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.";
+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\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).";
 export type Parsed = {
     command: "migrate";
     args: MigrateArgs;
@@ -11,6 +12,9 @@ export type Parsed = {
 } | {
     command: "import";
     args: ImportArgs;
+} | {
+    command: "add-admin";
+    args: AddAdminArgs;
 } | {
     command: "help";
 } | {

package/dist/cli/main.js

@@ -1,12 +1,14 @@
 // packages/smoodly/src/cli/main.ts
-// `smoodly` — the package's command line. Three subcommands: migrate
-// (spec 2026-09-26 §2), export and import (spec 2026-09-28). Exit codes:
+// `smoodly` — the package's command line. Four 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:
 // 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 { runExport } from "./export.js";
 import { runImport } from "./import.js";
+import { runAddAdmin } from "./add-admin.js";
 export const USAGE = `usage: smoodly <command>
 
   migrate [--check] [--collections <file>] [--migrations <dir>]
@@ -25,7 +27,12 @@ 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.
+
+  add-admin <email> [--admin-url <url>]
+    Makes <email> an admin of the key's space: with SMOODLY_ADMIN_PASSWORD
+    set, creates the account with that password; without, mails an invite
+    whose link lands on --admin-url (default: SITE_URL + /admin).`;
 export function parseArgs(argv) {
     const [command, ...rest] = argv;
     if (!command || command === "--help" || command === "-h" || command === "help")
@@ -46,6 +53,17 @@ 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 === "add-admin") {
+        const usage = { command: "error", message: "add-admin needs one email: smoodly add-admin <email> [--admin-url <url>]" };
+        const [email, ...flags] = rest;
+        if (!email || email.startsWith("-"))
+            return usage;
+        if (flags.length === 0)
+            return { command: "add-admin", args: { email } };
+        if (flags.length !== 2 || flags[0] !== "--admin-url" || flags[1].startsWith("-"))
+            return usage;
+        return { command: "add-admin", args: { email, adminUrl: flags[1] } };
+    }
     if (command !== "migrate")
         return { command: "error", message: `unknown command "${command}"` };
     const args = { check: false, collections: "smoodly/collections.ts", migrations: "supabase/migrations" };
@@ -77,6 +95,8 @@ export async function main(argv, out = console.log) {
             return await runImport(parsed.args, out);
         if (parsed.command === "export")
             return await runExport(parsed.args, out);
+        if (parsed.command === "add-admin")
+            return await runAddAdmin(parsed.args, out);
         return await runMigrate(parsed.args, out);
     }
     catch (e) {

package/dist/cli/migrate.d.ts

@@ -8,7 +8,7 @@ export type MigrateArgs = {
 /** 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 = "No supabase/migrations folder here \u2014 nothing to do. (Smoodly Cloud keeps the schema current; a self-host app gets the folder from `supabase init`.)";
-export declare const NEXT_STEP = "Next: apply it \u2014 `supabase db push` (hosted) or `supabase db reset` (local).";
+export declare const NEXT_STEP = "Next: apply it \u2014 `supabase db push` (hosted) or `supabase migration up` (local).";
 export declare const upToDate: (version: number, n: number) => string;
 export declare const modifiedMessage: (name: string) => string;
 export declare function readSqlFiles(dir: string): Promise<MigrationFile[]>;

package/dist/cli/migrate.js

@@ -14,7 +14,7 @@ import { loadCollections } from "./load-collections.js";
 /** 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 = "No supabase/migrations folder here — nothing to do. (Smoodly Cloud keeps the schema current; a self-host app gets the folder from `supabase init`.)";
-export const NEXT_STEP = "Next: apply it — `supabase db push` (hosted) or `supabase db reset` (local).";
+export const NEXT_STEP = "Next: apply it — `supabase db push` (hosted) or `supabase migration up` (local).";
 export const upToDate = (version, n) => `Up to date: core schema v${version}, every collection's view is current (${n} ${n === 1 ? "collection" : "collections"}).`;
 export const modifiedMessage = (name) => `Refusing: ${name} differs from the package's copy. A published migration is never edited — restore it from the package, or move your change to a new file.`;
 export async function readSqlFiles(dir) {
@@ -38,6 +38,11 @@ export async function runMigrate(args, out, deps = {}) {
     const cwd = deps.cwd ?? process.cwd();
     const appDir = resolve(cwd, args.migrations);
     if (!existsSync(appDir)) {
+        // A build that runs the check must not pass one it never made (spec 2026-09-30 tester findings §5).
+        if (args.check) {
+            out(`smoodly: no supabase/migrations here (${appDir}) — run the check in the app's folder, or pass --migrations.`);
+            return 1;
+        }
         out(NO_FOLDER);
         return 0;
     }

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

@@ -11,12 +11,7 @@ export declare const PAGE_ROWS = 1000;
 export declare function loadAppEnv(cwd: string, env?: Record<string, string | undefined>): void;
 /** The app's content client, from its env. */
 export declare function connectFromEnv(cwd: string): SpaceConnection;
-/** The policies show `smoodly_meta` to a write key only, so no visible row means the key is not a secret key (spec §5). */
-export declare function readSchemaVersion(db: SupabaseClient): Promise<{
-    version: number;
-} | {
-    missing: "key" | "schema";
-}>;
+export { readSchemaVersion } from "../schema-read.ts";
 export declare function schemaRefusal(missing: "key" | "schema", command: "Export" | "Import"): 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[]>;
@@ -29,4 +24,3 @@ export declare const isNotFound: (e: StorageErrorLike) => boolean;
 export declare const isAlreadyExists: (e: StorageErrorLike) => boolean;
 /** The installed package's version for the manifest: `../../package.json` from src/cli/ and dist/cli/ alike. */
 export declare function packageVersion(): string;
-export {};

package/dist/cli/space-io.js

@@ -9,7 +9,6 @@ import { join } from "node:path";
 import { parseEnv } from "node:util";
 import { createSmoodlyClient } from "../client.js";
 import { resolveSmoodlyEnv } from "../env.js";
-import { SCHEMA_VERSION_KEY } from "../schema-version.js";
 import { ROW_KEY } from "../space-transfer.js";
 export const MEDIA_BUCKET = "media";
 /** Rows per request. A host may cap below it, so a read stops at the first empty page, not the first short one. */
@@ -31,24 +30,11 @@ export function connectFromEnv(cwd) {
     loadAppEnv(cwd);
     return { db: createSmoodlyClient(resolveSmoodlyEnv(process.env)) };
 }
-/** The policies show `smoodly_meta` to a write key only, so no visible row means the key is not a secret key (spec §5). */
-export async function readSchemaVersion(db) {
-    const res = await db.from("smoodly_meta").select("value").eq("key", SCHEMA_VERSION_KEY).maybeSingle();
-    if (res.error) {
-        // PGRST205: not in PostgREST's schema cache; 42P01: undefined table; 42501: no grant.
-        if (res.error.code === "PGRST205" || res.error.code === "42P01")
-            return { missing: "schema" };
-        if (res.error.code === "42501")
-            return { missing: "key" };
-        throw new Error(`smoodly: reading the schema version: ${res.error.message}`);
-    }
-    const n = Number(res.data?.value);
-    return res.data && Number.isInteger(n) ? { version: n } : { missing: "key" };
-}
+export { readSchemaVersion } from "../schema-read.js";
 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.`
-        : "This database has no Smoodly schema. Run `npx smoodly migrate`, then `supabase db push` (hosted) or `supabase db reset` (local).";
+        : "This database has no Smoodly schema. Run `npx smoodly migrate`, then `supabase db push` (hosted) or `supabase migration up` (local).";
 }
 /** 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 async function readSpaceRows(db, table, space, where = {}, columns = "*") {

package/dist/client.js

@@ -7,7 +7,9 @@ export function clientOptions(env) {
     if (env.secretKey.startsWith("sb_secret_")) {
         return { url: env.url, key: env.secretKey, headers: {} };
     }
-    return { url: env.url, key: env.publishableKey, headers: { Authorization: `Bearer ${env.secretKey}` } };
+    // The gateway's apikey is the publishable key, or the secret itself when the site runs
+    // 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}` } };
 }
 /** The server-side client the stores are built on. */
 export function createSmoodlyClient(env) {

package/dist/content/content-api.d.ts

@@ -0,0 +1,80 @@
+import { createAdminOps } from "../admin/ops-impl.ts";
+import type { EntryCreateInput, OpError, PageCreateInput } from "../admin/ops.ts";
+import type { FieldError } from "../admin/validate.ts";
+import type { EntryRecord } from "../entry-store.ts";
+import type { PageRecord } from "../store.ts";
+import type { PageTree } from "../render.tsx";
+import type { ImageValue } from "../media.ts";
+import type { MemberStore } from "../member-store.ts";
+export type UploadMeta = {
+    filename?: string;
+    mime?: string;
+    alt?: string;
+    title?: string;
+    caption?: string;
+    credit?: string;
+};
+export declare class SmoodlyContentError extends Error {
+    readonly code: OpError["code"];
+    readonly fields: FieldError[];
+    constructor(error: Pick<OpError, "code" | "message" | "fields">);
+}
+export type ContentDeps = Omit<Parameters<typeof createAdminOps>[0], "actor">;
+/** With a password: the account is created (or an existing one kept) and made an admin. Without: an invite mail,
+ *  whose link goes to `redirectTo` or the Auth project's Site URL. Running it again changes nothing.
+ *  Its own function because `smoodly add-admin` has a member store and no config. */
+export declare function addAdmin(members: MemberStore | undefined, email: string, options?: {
+    password?: string;
+    redirectTo?: string;
+}): Promise<{
+    email: string;
+    invited: boolean;
+}>;
+export declare function createSmoodlyContent(deps: ContentDeps): {
+    pages: {
+        create: (input: PageCreateInput) => Promise<PageRecord>;
+        setTree(id: string, locale: string, tree: PageTree): Promise<void>;
+        /** The locale's draft tree — what `setTree` replaces; null for a folder or a locale the page lacks.
+         *  A seed reads it to tell a code-owned page nobody has filled yet. */
+        getTree(id: string, locale: string): Promise<PageTree | null>;
+        addLocale(id: string, locale: string, options: {
+            from: string;
+            slug?: string;
+            title?: string;
+        }): Promise<PageRecord>;
+        publish: (id: string, locale: string) => Promise<PageRecord>;
+        /** A code-owned address with no record gets it created the way the admin's Pages list does (spec §2). */
+        find(locale: string, path: string): Promise<PageRecord | null>;
+    };
+    entries: {
+        create: (collection: string, input: EntryCreateInput) => Promise<EntryRecord>;
+        update: (collection: string, id: string, locale: string, fields: Record<string, unknown>) => Promise<EntryRecord>;
+        addLocale(collection: string, id: string, locale: string, options: {
+            from: string;
+            fields?: Record<string, unknown>;
+        }): Promise<EntryRecord>;
+        publish: (collection: string, id: string, locale: string) => Promise<EntryRecord>;
+        find(collection: string, match: {
+            slug: string;
+            locale?: string;
+        }): Promise<EntryRecord | null>;
+    };
+    globals: {
+        set(name: string, locale: string, fields: Record<string, unknown>): Promise<EntryRecord>;
+        publish: (name: string, locale: string) => Promise<EntryRecord>;
+    };
+    media: {
+        /** A file path or bytes in, a ready asset and the value an image field stores out. */
+        upload(file: string | Uint8Array, meta?: UploadMeta): Promise<ImageValue>;
+    };
+    members: {
+        addAdmin: (email: string, options?: {
+            password?: string;
+            redirectTo?: string;
+        }) => Promise<{
+            email: string;
+            invited: boolean;
+        }>;
+    };
+};
+export type SmoodlyContent = ReturnType<typeof createSmoodlyContent>;

package/dist/content/content-api.js

@@ -0,0 +1,152 @@
+// The content API (spec 2026-09-30 tester findings §1): the admin's
+// operations with no signed-in editor, as a few verbs that throw. Scripts
+// and route handlers write content through this, never through the stores,
+// so validation, the code-owned address guards and publish checks apply.
+import { createAdminOps } from "../admin/ops-impl.js";
+import { imageDimensions } from "../image-dimensions.js";
+const MIME = {
+    jpg: "image/jpeg", jpeg: "image/jpeg", png: "image/png", webp: "image/webp", gif: "image/gif", avif: "image/avif",
+    svg: "image/svg+xml", mp4: "video/mp4", webm: "video/webm", pdf: "application/pdf",
+};
+const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+export class SmoodlyContentError extends Error {
+    constructor(error) {
+        const list = (error.fields ?? []).map((f) => `\n  ${f.field}: ${f.message}`).join("");
+        super(error.message + list);
+        this.name = "SmoodlyContentError";
+        this.code = error.code;
+        this.fields = error.fields ?? [];
+    }
+}
+async function must(result) {
+    const r = await result;
+    if (!r.ok)
+        throw new SmoodlyContentError(r);
+    return r.data;
+}
+/** With a password: the account is created (or an existing one kept) and made an admin. Without: an invite mail,
+ *  whose link goes to `redirectTo` or the Auth project's Site URL. Running it again changes nothing.
+ *  Its own function because `smoodly add-admin` has a member store and no config. */
+export async function addAdmin(members, email, options = {}) {
+    if (!members)
+        throw new SmoodlyContentError({ code: "internal", message: "smoodly: no member store — pass `members` to createSmoodlyContent." });
+    if (!EMAIL.test(email))
+        throw new SmoodlyContentError({ code: "validation", message: `smoodly: "${email}" is not an email address.` });
+    if (options.password !== undefined && options.password.length < 8) {
+        throw new SmoodlyContentError({ code: "validation", message: "smoodly: the password needs at least 8 characters." });
+    }
+    try {
+        // Where smoodly.io manages the members, nothing here writes them — as the admin's Members page refuses.
+        if ((await members.consoleUrl()) !== null) {
+            throw new SmoodlyContentError({ code: "blocked", message: "smoodly: this site's members are managed at smoodly.io." });
+        }
+        if (options.password !== undefined) {
+            await members.createAccount({ email, password: options.password, role: "admin" });
+            return { email, invited: false };
+        }
+        const { invited } = await members.invite({ email, role: "admin", redirectTo: options.redirectTo ?? "" });
+        return { email, invited };
+    }
+    catch (e) {
+        if (e instanceof SmoodlyContentError)
+            throw e;
+        throw new SmoodlyContentError({ code: "internal", message: e instanceof Error ? e.message : String(e) });
+    }
+}
+export function createSmoodlyContent(deps) {
+    const ops = createAdminOps(deps);
+    const def = deps.config.locales.default;
+    async function findPage(locale, path) {
+        const hit = await deps.pages.resolvePath(locale, path);
+        if (hit?.kind === "page" && !hit.redirect)
+            return deps.pages.getPage(hit.id);
+        return null;
+    }
+    async function updateEntry(collection, id, locale, fields) {
+        return must(ops.entries.save(collection, id, locale, fields));
+    }
+    return {
+        pages: {
+            create: (input) => must(ops.pages.create(input)),
+            async setTree(id, locale, tree) {
+                await must(ops.pages.saveDraft(id, locale, tree));
+            },
+            /** The locale's draft tree — what `setTree` replaces; null for a folder or a locale the page lacks.
+             *  A seed reads it to tell a code-owned page nobody has filled yet. */
+            async getTree(id, locale) {
+                return (await must(ops.pages.get(id, locale))).draft;
+            },
+            async addLocale(id, locale, options) {
+                const added = await must(ops.pages.addLocale(id, locale, { from: options.from }));
+                if (options.slug === undefined && options.title === undefined)
+                    return added;
+                return must(ops.pages.rename(id, {
+                    locale,
+                    ...(options.slug !== undefined ? { slug: options.slug } : {}),
+                    ...(options.title !== undefined ? { title: options.title } : {}),
+                    redirect: false,
+                }));
+            },
+            publish: (id, locale) => must(ops.pages.publish(id, locale)),
+            /** A code-owned address with no record gets it created the way the admin's Pages list does (spec §2). */
+            async find(locale, path) {
+                const found = await findPage(locale, path);
+                if (found)
+                    return found;
+                await must(ops.pages.list());
+                return findPage(locale, path);
+            },
+        },
+        entries: {
+            create: (collection, input) => must(ops.entries.create(collection, input)),
+            update: updateEntry,
+            async addLocale(collection, id, locale, options) {
+                const added = await must(ops.entries.addLocale(collection, id, locale, { from: options.from }));
+                return options.fields ? updateEntry(collection, id, locale, options.fields) : added;
+            },
+            publish: (collection, id, locale) => must(ops.entries.setStatus(collection, id, locale, "published")),
+            async find(collection, match) {
+                const locale = match.locale ?? def;
+                const all = await must(ops.entries.list(collection));
+                return all.find((e) => e.locales[locale]?.slug === match.slug) ?? null;
+            },
+        },
+        globals: {
+            async set(name, locale, fields) {
+                await must(ops.globals.list()); // materializes the item (ensureGlobalItems), as opening Globals does
+                return must(ops.globals.save(name, locale, fields));
+            },
+            publish: (name, locale) => must(ops.globals.setStatus(name, locale, "published")),
+        },
+        media: {
+            /** A file path or bytes in, a ready asset and the value an image field stores out. */
+            async upload(file, meta = {}) {
+                if (!deps.assets)
+                    throw new SmoodlyContentError({ code: "internal", message: "smoodly: no media store — pass `assets` to createSmoodlyContent." });
+                // Loaded here, not at the top: this module is reachable from `smoodly/admin`, which a bundler may walk.
+                const bytes = typeof file === "string" ? new Uint8Array(await (await import("node:fs/promises")).readFile(file)) : file;
+                const filename = meta.filename ?? (typeof file === "string" ? file.split(/[\\/]/).pop() : "upload");
+                const mime = meta.mime ?? MIME[filename.split(".").pop().toLowerCase()] ?? "application/octet-stream";
+                // The media library's own rules, as the admin's upload applies them (config.media).
+                const { accept, maxSize } = deps.config.media;
+                if (!accept.includes(mime))
+                    throw new SmoodlyContentError({ code: "validation", message: `smoodly: "${filename}" is ${mime}, not an accepted file type.` });
+                if (bytes.byteLength > maxSize) {
+                    throw new SmoodlyContentError({ code: "validation", message: `smoodly: "${filename}" is larger than ${Math.round(maxSize / 1024 / 1024)} MB.` });
+                }
+                const { alt, title, caption, credit } = meta;
+                let asset;
+                try {
+                    asset = await deps.assets.create({ filename, mime, size: bytes.byteLength, bytes, alt, title, caption, credit, ...(imageDimensions(bytes) ?? {}) });
+                }
+                catch (e) {
+                    throw new SmoodlyContentError({ code: "internal", message: e instanceof Error ? e.message : String(e) });
+                }
+                return { asset: asset.id, ...(alt !== undefined ? { alt } : {}) };
+            },
+        },
+        members: {
+            addAdmin: (email, options = {}) => addAdmin(deps.members, email, options),
+        },
+    };
+}

package/dist/content/node.d.ts

@@ -0,0 +1,7 @@
+import type { BuilderMap, SectionSchema, StoredValues } from "../schema.ts";
+import type { PairedComponent } from "../pairing.tsx";
+import type { TreeNode } from "../render.tsx";
+export declare function node<F extends BuilderMap, St extends BuilderMap>(section: PairedComponent<SectionSchema<F, St>, F, St>, fields: Partial<StoredValues<F>>, options?: {
+    settings?: Partial<StoredValues<St>>;
+    id?: string;
+}): TreeNode;