smoodly 0.0.51 → 0.0.53

package/dist/cli/import.js

@@ -1,25 +1,39 @@
 // packages/smoodly/src/cli/import.ts
-// `smoodly import <dir>` (spec 2026-09-28 export/import §9–§10): an
-// export folder into the key's space. Every check runs before the first
-// write; nothing is overwritten or deleted; a run that stops midway is
-// finished by running it again, since the target may hold only this
-// export's rows and both writes skip what already landed.
+// `smoodly import <dir>` (spec 2026-09-28 export/import §9–§10; over the API
+// since plan 2026-10-14 the service holds the stores): an export folder into
+// the key's space. Every check runs before the first write; nothing is
+// overwritten or deleted; a run that stops midway is finished by running it
+// again, since the target may hold only this export's rows and both writes
+// skip what already landed. The service writes each row into its own space;
+// a read assembles from what landed, so nothing is rebuilt after.
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 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, 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.`;
+import { CONTENT_TABLES } from "../space-transfer.js";
+import { FORMAT, describeImport, emptyTables, foreignRows, insertPlan, missingRows, notEmptyMessage, rowKey, versionMismatchMessage, } from "../space-transfer.js";
+import { connectApi } from "./api.js";
+import { mediaUrl, readTable, transferHead } from "./export.js";
+const BATCH_ROWS = 500;
+/** A batch's JSON stays under the API's 4 MB request cap with room for the envelope. */
+const MAX_BATCH_BYTES = 3500000;
+const notAnExport = (dir) => `Refusing: ${dir} is not a Smoodly export (no manifest.json).`;
+const formatMismatch = (format) => `Refusing: this export's format is ${String(format)}; this smoodly reads format ${FORMAT}. Update smoodly.`;
 export const RUN_AGAIN = "Run the same command again to continue: rows and files that landed are skipped.";
-export const MEMBERS_HEADING = "Members in the source — invite them in Settings › Members:";
-export const nothingNew = (space) => `Nothing new: space ${space} already holds everything in this export.`;
+export const MEMBERS_HEADING = "Members in the source — add them to the space's members in the project at smoodly.io:";
+export const nothingNew = () => "Nothing new: the space already holds everything in this export.";
 export const CACHE_NOTE = "Restart or redeploy the app: it may have cached pages from while the space was empty.";
+/** `list` cut into batches of at most `size` rows, each halved while its JSON is over MAX_BATCH_BYTES. */
+function batches(list, size) {
+    const out = [];
+    for (let i = 0; i < list.length;) {
+        let take = Math.min(size, list.length - i);
+        while (take > 1 && Buffer.byteLength(JSON.stringify({ rows: list.slice(i, i + take) })) > MAX_BATCH_BYTES)
+            take = Math.ceil(take / 2);
+        out.push(list.slice(i, i + take));
+        i += take;
+    }
+    return out;
+}
 export async function runImport(args, out, deps = {}) {
     const cwd = deps.cwd ?? process.cwd();
     const dir = resolve(cwd, args.dir);
@@ -33,64 +47,48 @@ export async function runImport(args, out, deps = {}) {
         out(formatMismatch(manifest.format));
         return 1;
     }
-    const { db } = deps.connection ?? connectFromEnv(cwd);
-    const schema = await readSchemaVersion(db);
-    if ("missing" in schema) {
-        out(schemaRefusal(schema.missing, "Import"));
+    const env = deps.env ?? process.env;
+    const api = deps.api ?? connectApi(cwd, env);
+    // Read after connectApi: it loads the app's .env files.
+    const space = env.SMOODLY_SPACE_ID ?? "";
+    const head = await transferHead(api, out);
+    if (!head)
         return 1;
-    }
-    const space = await readCurrentSpace(db);
-    if (schema.version !== manifest.schemaVersion) {
-        out(versionMismatchMessage(schema.version, manifest.schemaVersion));
+    if (head.schemaVersion !== manifest.schemaVersion) {
+        out(versionMismatchMessage(head.schemaVersion, manifest.schemaVersion));
         return 1;
     }
     const rows = emptyTables();
     for (const table of CONTENT_TABLES)
         rows[table] = JSON.parse(await readFile(join(dir, "rows", `${table}.json`), "utf8"));
     const target = {};
-    for (const table of CONTENT_TABLES) {
-        target[table] = (await readSpaceRows(db, table, space, {}, ROW_KEY[table].join(","))).map((row) => rowKey(table, row));
-    }
+    for (const table of CONTENT_TABLES)
+        target[table] = (await readTable(api, table, true)).map((row) => rowKey(table, row));
     const foreign = foreignRows(target, rows);
     if (CONTENT_TABLES.some((t) => foreign[t] > 0)) {
         out(notEmptyMessage(foreign));
         return 1;
     }
+    // The files that travel (a file missing in the source as well is in manifest.media.missing), each sent whole with its
+    // length: the service streams it into the bucket (spec 2026-10-18 media on R2 and Images §4).
+    const files = rows.assets.map((asset) => ({ path: String(asset.path), mime: String(asset.mime), file: join(dir, "media", String(asset.path)) }))
+        .filter((m) => existsSync(m.file));
     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) {
-            const path = String(asset.path);
-            const file = join(dir, "media", path);
-            if (!existsSync(file))
-                continue; // missing in the source as well (manifest.media.missing)
-            const up = await db.storage.from(MEDIA_BUCKET).upload(`${space}/${path}`, await readFile(file), {
-                contentType: String(asset.mime),
-                upsert: false,
-                cacheControl: String(MEDIA_CACHE_SECONDS),
-            });
-            if (up.error && !isAlreadyExists(up.error))
-                throw new Error(`uploading ${path}: ${up.error.message}`);
-            if (!up.error)
+        for (const m of files) {
+            const up = await api.postBytes(mediaUrl(m.path), new Uint8Array(await readFile(m.file)), m.mime);
+            if (up.created)
                 newFiles++;
         }
         const size = deps.batchSize ?? BATCH_ROWS;
         for (const { table, rows: list } of insertPlan(rows)) {
-            for (let i = 0; i * size < list.length; i++) {
+            for (const [i, batch] of batches(list, size).entries()) {
                 deps.beforeBatch?.(table, i);
-                const batch = list.slice(i * size, (i + 1) * size).map((row) => intoSpace(table, row, space));
-                const res = await db.from(table).upsert(batch, { onConflict: CONFLICT_COLUMNS[table], ignoreDuplicates: true });
-                if (res.error)
-                    throw new Error(`inserting ${table}: ${res.error.message}`);
+                await api.post(`/transfer/rows/${table}`, { rows: batch });
             }
         }
-        // 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)}`);
@@ -98,12 +96,10 @@ export async function runImport(args, out, deps = {}) {
         return 1;
     }
     if (newRows === 0 && newFiles === 0) {
-        out(nothingNew(space));
-        out(rebuiltMessage(rebuilt));
+        out(nothingNew());
         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-config.d.ts

@@ -1,5 +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>;
 /** One named config file (the Astro integration's `config` option names it): the project's tsconfig beside `cwd`

package/dist/cli/load-config.js

@@ -8,7 +8,7 @@ import { existsSync } from "node:fs";
 import { dirname, 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"];
+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));

package/dist/cli/main.d.ts

@@ -1,24 +1,16 @@
-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";
-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).";
+import { type PushArgs } from "./push.ts";
+export declare const USAGE = "usage: smoodly <command>     (smoodly --version prints the version)\nEvery command reads SMOODLY_API_URL, SMOODLY_SPACE_ID and SMOODLY_SECRET_KEY from the app's .env.local or .env.\n\n  push\n    Sends the app's registry (its smoodly config), its address (SITE_URL) and\n    the package version to the space. A Next site's prebuild runs it, Astro's\n    build and both dev servers push on their own; run it from CI or a script.\n    SMOODLY_STATIC=1 marks a static site. As a prebuild it never fails the build.\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.";
 export type Parsed = {
-    command: "migrate";
-    args: MigrateArgs;
-} | {
     command: "export";
     args: ExportArgs;
 } | {
     command: "import";
     args: ImportArgs;
 } | {
-    command: "add-admin";
-    args: AddAdminArgs;
-} | {
-    command: "rebuild";
-    args: RebuildArgs;
+    command: "push";
+    args: PushArgs;
 } | {
     command: "help";
 } | {

package/dist/cli/main.js

@@ -1,29 +1,25 @@
 // packages/smoodly/src/cli/main.ts
-// `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), rebuild (spec 2026-10-07 delivery model §4). Exit codes:
-// 0 done or nothing to do, 1 pending (--check), refused or failed, 2 usage.
+// `smoodly` — the package's command line. Three subcommands: push (spec
+// 2026-10-16 the control plane §4), export and import (spec 2026-09-28). A
+// space's schema lives in its object, sent there by the push, so there is
+// nothing to migrate or rebuild;
+// its members are set by smoodly.io (spec 2026-10-16 the control plane §5),
+// so there is no add-admin. Exit codes: 0 done or nothing to do,
+// 1 refused or failed, 2 usage.
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { DEFAULT_COLLECTIONS, runMigrate } from "./migrate.js";
 import { runExport } from "./export.js";
 import { runImport } from "./import.js";
-import { runAddAdmin } from "./add-admin.js";
-import { runRebuild } from "./rebuild.js";
+import { runPush } from "./push.js";
 import { SMOODLY_VERSION } from "../version.js";
 export const USAGE = `usage: smoodly <command>     (smoodly --version prints the version)
+Every command reads SMOODLY_API_URL, SMOODLY_SPACE_ID and SMOODLY_SECRET_KEY from the app's .env.local or .env.
 
-  migrate [--check] [--collections <file>] [--migrations <dir>]
-    Copies the core schema files this package ships that supabase/migrations/
-    lacks, and writes one views file for the collections whose view is new or
-    changed. Prints the push or reset command; never runs it.
-
-    --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, or src/smoodly/collections.ts
-                         when only that one exists)
-    --migrations <dir>   the app's migration folder (default supabase/migrations)
+  push
+    Sends the app's registry (its smoodly config), its address (SITE_URL) and
+    the package version to the space. A Next site's prebuild runs it, Astro's
+    build and both dev servers push on their own; run it from CI or a script.
+    SMOODLY_STATIC=1 marks a static site. As a prebuild it never fails the build.
 
   export [--out <dir>]
     Writes the space SMOODLY_SECRET_KEY names — every content row, history
@@ -32,20 +28,7 @@ export const USAGE = `usage: smoodly <command>     (smoodly --version prints the
 
   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. 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
-    set, creates the account with that password; without, mails an invite
-    whose link lands on --admin-url (default: SITE_URL + /admin).`;
+    only this export's rows (an earlier run to continue). Never deletes.`;
 export function parseArgs(argv) {
     const [command, ...rest] = argv;
     if (!command || command === "help" || argv.some((a) => a === "--help" || a === "-h"))
@@ -63,42 +46,17 @@ export function parseArgs(argv) {
         }
         return { command: "export", args };
     }
+    if (command === "push") {
+        if (rest.length > 0)
+            return { command: "error", message: `unexpected argument "${rest[0]}"` };
+        return { command: "push", args: {} };
+    }
     if (command === "import") {
         if (rest.length !== 1 || rest[0].startsWith("-"))
             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;
-        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: DEFAULT_COLLECTIONS, migrations: "supabase/migrations" };
-    for (let i = 0; i < rest.length; i++) {
-        const a = rest[i];
-        if (a === "--check")
-            args.check = true;
-        else if (a === "--collections" && rest[i + 1] !== undefined)
-            args.collections = rest[++i];
-        else if (a === "--migrations" && rest[i + 1] !== undefined)
-            args.migrations = rest[++i];
-        else
-            return { command: "error", message: `unexpected argument "${a}"` };
-    }
-    return { command: "migrate", args };
+    return { command: "error", message: `unknown command "${command}"` };
 }
 export async function main(argv, out = console.log) {
     const parsed = parseArgs(argv);
@@ -115,23 +73,19 @@ export async function main(argv, out = console.log) {
         return 2;
     }
     try {
+        if (parsed.command === "push")
+            return await runPush(parsed.args, out);
         if (parsed.command === "import")
             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);
-        if (parsed.command === "rebuild")
-            return await runRebuild(parsed.args, out);
-        return await runMigrate(parsed.args, out);
+        return await runExport(parsed.args, out);
     }
     catch (e) {
         out(e instanceof Error ? e.message : String(e));
         return 1;
     }
 }
-// Run when this file is the entry (`tsx src/cli/main.ts …`, the repo's
-// `npm run db:migrate`); the published bin imports `main` and runs it itself.
+// Run when this file is the entry (`tsx src/cli/main.ts …`); the published bin
+// imports `main` and runs it itself.
 if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(new URL(import.meta.url))) {
     void main(process.argv.slice(2)).then((code) => {
         process.exitCode = code;

package/dist/cli/push.d.ts

@@ -0,0 +1,6 @@
+export type PushArgs = Record<string, never>;
+export declare function runPush(_args: PushArgs, out: (line: string) => void, deps?: {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    fetch?: typeof fetch;
+}): Promise<number>;

package/dist/cli/push.js

@@ -0,0 +1,31 @@
+// `smoodly push` (spec 2026-10-16 the control plane §4): the app's registry, its address (SITE_URL) and the package
+// version to the space SMOODLY_SECRET_KEY names. The Next templates' prebuild runs it; Astro's build hook and the API
+// client in development push the same body themselves. Static mode when SMOODLY_STATIC=1, else live. A refusal exits 1,
+// except when npm runs the command as a build's `prebuild`: a push never fails a build (the spec's rule), so there it
+// says what failed and exits 0, and the site runs against the schema the space has.
+import { apiEnv } from "../env.js";
+import { pushBody, pushSchema } from "../push.js";
+import { loadAppEnv } from "./app-env.js";
+import { loadConfig } from "./load-config.js";
+export async function runPush(_args, out, deps = {}) {
+    const cwd = deps.cwd ?? process.cwd();
+    const env = deps.env ?? process.env;
+    loadAppEnv(cwd, env);
+    try {
+        const config = await loadConfig(cwd);
+        const { apiUrl, spaceId, key } = apiEnv(env);
+        const body = pushBody(config, env, env.SMOODLY_STATIC === "1" ? "static" : "live");
+        const { version, changed } = await pushSchema({ apiUrl, spaceId, key, fetch: deps.fetch }, body);
+        out(changed ? `Pushed schema version ${version} to ${spaceId}.` : `Schema unchanged (version ${version}).`);
+        return 0;
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        if (env.npm_lifecycle_event === "prebuild") {
+            out(`smoodly: the schema push failed — ${message}; the site runs against the schema the space has.`);
+            return 0;
+        }
+        out(message);
+        return 1;
+    }
+}

package/dist/collections.d.ts

@@ -8,7 +8,6 @@ export type EntryOrder = "manual" | {
     direction: "asc" | "desc";
 };
 export declare const DEFAULT_ORDER: EntryOrder;
-export declare const BUILT_IN_ORDER_FIELDS: readonly ["createdAt", "updatedAt"];
 export type CollectionSchema<F extends BuilderMap = BuilderMap, N extends string = string> = {
     /** "global" marks a code-declared singleton (spec 2026-09-07 decision
      *  4): a global item IS a collection with one entry, so both entry

package/dist/collections.js

@@ -1,6 +1,6 @@
 import { SEO_DESCRIPTOR, SEO_KEY, validateCollectionSeo } from "./seo.js";
 export const DEFAULT_ORDER = { by: "createdAt", direction: "desc" };
-export const BUILT_IN_ORDER_FIELDS = ["createdAt", "updatedAt"];
+const BUILT_IN_ORDER_FIELDS = ["createdAt", "updatedAt"];
 export const collectionOrder = (c) => c.order ?? DEFAULT_ORDER;
 export const collectionDepth = (c) => c.tree?.depth ?? 1;
 export function collection(input) {

package/dist/config.d.ts

@@ -3,8 +3,10 @@ import type { CollectionSchema } from "./collections.ts";
 import type { GlobalSchema } from "./global.ts";
 import { type Addresses } from "./addresses.ts";
 import type { Anchors } from "./anchors.ts";
+import { type ImageQuality } from "./media-cut.ts";
 import { type StyleValues, type StyleValuesInput } from "./styles.ts";
 import { type CustomConfigInput, type ResolvedCustom } from "./custom/index.ts";
+import type { LocaleRouting } from "./astro/locale-paths.ts";
 /** A section, element or page schema as the config reads it. */
 export type RegisteredSchema = {
     kind: string;
@@ -58,16 +60,24 @@ export type SmoodlyConfig = {
     database?: {
         provider: string;
     };
-    /** Upload limits (spec 2026-09-08 media §10): bytes per file and the accepted mime types. */
+    /** Upload limits (spec 2026-09-08 media §10): bytes per file and the accepted mime types. The project's image
+     *  quality and srcset cap (spec 2026-10-18 image quality and max width §1), under a field's and a view's own. */
     media?: {
         maxSize?: number;
         accept?: string[];
+        quality?: ImageQuality;
+        maxWidth?: number;
     };
     /** Where the admin is mounted (spec 2026-09-17): must match the route
      *  folder under app/(smoodly)/. Default "/admin". */
     admin?: {
         path?: string;
     };
+    /** Where the default locale's pages live (spec 2026-10-16 the control plane §4): at the root (default), or under
+     *  its code like every other locale. Astro's integration holds it equal to astro.config's i18n. */
+    routing?: {
+        prefixDefaultLocale: boolean;
+    };
 };
 /** The registry as defineConfig resolves it: schemas, and page types only under `pages`. */
 export type Registry = {
@@ -77,7 +87,7 @@ export type Registry = {
     globals: GlobalSchema[];
     pages: RegisteredSchema[];
 };
-export type ResolvedConfig = Omit<SmoodlyConfig, "styles" | "custom" | "admin" | "registry"> & {
+export type ResolvedConfig = Omit<SmoodlyConfig, "styles" | "custom" | "admin" | "registry" | "routing"> & {
     registry: Registry;
     homePageSlug: string;
     /** How deep editors may nest pages in the tree. Default 1 (flat). */
@@ -93,17 +103,22 @@ export type ResolvedConfig = Omit<SmoodlyConfig, "styles" | "custom" | "admin" |
     media: {
         maxSize: number;
         accept: string[];
+        quality?: ImageQuality;
+        maxWidth?: number;
     };
     /** The admin's mount path, always present. */
     admin: {
         path: string;
     };
+    /** Where the default locale's pages live; `prefixDefaultLocale` is false unless the config says otherwise. */
+    routing: {
+        prefixDefaultLocale: boolean;
+    };
     /** Code-owned addresses by owner key (spec 2026-09-29 nested paths §3). */
     addresses: Addresses;
     /** The path index's view of the code-owned addresses (spec 2026-09-29 anchored paths §2): pass it to the index. */
     anchors: Anchors;
 };
-/** `global`: the placement node type and an admin route; `asset`: the refs
- *  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;
+/** The address rule the config's routing asks for: a prefixed default locale, whose bare root goes to its home. */
+export declare const configRouting: (config: Pick<ResolvedConfig, "routing">) => LocaleRouting;

package/dist/config.js

@@ -1,6 +1,7 @@
 import { assertSegment, fixedPageSegments } from "./paths.js";
 import { addressMap, assertAddress, codeAddresses, lastPart } from "./addresses.js";
 import { DEFAULT_MEDIA } from "./media.js";
+import { isImageQuality, isMaxWidth, qualityError } from "./media-cut.js";
 import { DEFAULT_ADMIN_PATH, assertAdminPath, isAdminSlug } from "./admin-path.js";
 import { resolveStyleValues, styleDescriptors } from "./styles.js";
 import { resolveCustom } from "./custom/index.js";
@@ -8,7 +9,7 @@ import { isValidZone } from "./time-zone.js";
 import { schemaOnly } from "./registration.js";
 /** `global`: the placement node type and an admin route; `asset`: the refs
  *  target of every media edge; `media`: the admin's Media screen route. */
-export const RESERVED_NAMES = ["global", "asset", "media"];
+const RESERVED_NAMES = ["global", "asset", "media"];
 const isReserved = (name) => RESERVED_NAMES.includes(name);
 function normalizeRegistry(config) {
     const collections = config.registry.collections ?? [];
@@ -234,13 +235,23 @@ export function defineConfig(config) {
     const styles = resolveStyleValues(config.styles);
     const custom = resolveCustom(config.custom);
     const byName = new Map(registry.sections.map((s) => [s.name, s]));
+    const quality = config.media?.quality, maxWidth = config.media?.maxWidth;
     const media = {
         maxSize: config.media?.maxSize ?? DEFAULT_MEDIA.maxSize,
         accept: config.media?.accept ? [...config.media.accept] : [...DEFAULT_MEDIA.accept],
+        ...(quality !== undefined ? { quality } : {}),
+        ...(maxWidth !== undefined ? { maxWidth } : {}),
     };
     if (!Number.isInteger(media.maxSize) || media.maxSize <= 0) {
         throw new Error("smoodly: media.maxSize must be a positive integer of bytes.");
     }
+    if (quality !== undefined && !isImageQuality(quality))
+        throw new Error(qualityError(quality, "media.quality"));
+    if (maxWidth !== undefined && !isMaxWidth(maxWidth))
+        throw new Error("smoodly: media.maxWidth must be a positive whole number of pixels.");
+    const prefixDefaultLocale = config.routing?.prefixDefaultLocale ?? false;
+    if (typeof prefixDefaultLocale !== "boolean")
+        throw new Error("smoodly: routing.prefixDefaultLocale must be true or false.");
     const addresses = addressMap(codeAddresses({ locales: config.locales, pages: registry.pages, collections: registry.collections }));
     return {
         ...config,
@@ -249,6 +260,7 @@ export function defineConfig(config) {
         pageDepth: depth,
         media,
         admin: { path: adminPath },
+        routing: { prefixDefaultLocale },
         addresses,
         anchors: { addresses, homePageSlug, defaultLocale: config.locales.default },
         styles,
@@ -264,3 +276,8 @@ export function defineConfig(config) {
         },
     };
 }
+/** The address rule the config's routing asks for: a prefixed default locale, whose bare root goes to its home. */
+export const configRouting = (config) => ({
+    prefixDefault: config.routing.prefixDefaultLocale,
+    redirectToDefault: config.routing.prefixDefaultLocale,
+});

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

@@ -1,11 +1,11 @@
-import { createAdminOps } from "../admin/ops-impl.ts";
-import type { EntryCreateInput, OpError, PageCreateInput } from "../admin/ops.ts";
+import type { AdminOpCall, EntryCreateInput, OpError, OpResult, PageCreateInput } from "../admin/ops.ts";
+import type { PathHit } from "../path-index.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 "../page-context.ts";
 import type { ImageValue } from "../media.ts";
-import type { MemberStore } from "../member-store.ts";
+import type { ResolvedConfig } from "../config.ts";
 export type UploadMeta = {
     filename?: string;
     mime?: string;
@@ -19,17 +19,26 @@ export declare class SmoodlyContentError extends Error {
     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;
-}>;
+/** What content() writes through: the operations, the paths index's lookup, an upload. */
+export type ContentTransport = {
+    op(call: AdminOpCall): Promise<OpResult<unknown>>;
+    /** The target at an address, as a draft read: what the script is writing, never an edge copy. */
+    locate(locale: string, path: string): Promise<PathHit | null>;
+    upload(bytes: Uint8Array, filename: string, mime: string | undefined, meta: UploadMeta): Promise<ImageValue>;
+};
+export type ContentDeps = {
+    config: ResolvedConfig;
+    href?: (path: string, locale: string) => string;
+    transport: ContentTransport;
+};
+/** Over the content API with the secret key (a seed, a script, the installer). A refusal throws SmoodlyContentError
+ *  with the service's code and message; a network failure names SMOODLY_API_URL. */
+export declare function apiTransport(options: {
+    apiUrl: string;
+    spaceId: string;
+    key: string;
+    fetch?: typeof fetch;
+}): ContentTransport;
 export declare function createSmoodlyContent(deps: ContentDeps): {
     pages: {
         create: (input: PageCreateInput) => Promise<PageRecord>;
@@ -77,14 +86,5 @@ export declare function createSmoodlyContent(deps: ContentDeps): {
         /** 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>;