smoodly 0.0.51 → 0.0.52

package/dist/astro/static.js

@@ -4,32 +4,19 @@ const param = (site) => {
     const trimmed = site.replace(/^\/+/, "").replace(/\/+$/, "");
     return trimmed === "" ? undefined : trimmed;
 };
-/** Every published page and entry address of every locale, as Astro's getStaticPaths entries. Pages come from
- *  the delivery tree (a node with no path, hidden or under a code address, is not a page); entries from the paths
- *  index's live rows, kept to the entries with a published delivery row — the Supabase delivery store lists entries
- *  with their document only, no path (0.0.48 built no entry page for it), and the index is what visitors reach. */
+/** Every published page and entry address of every locale, as Astro's getStaticPaths entries, each once. */
 export async function staticPaths(deps) {
     const seen = new Set();
     const out = [];
-    const add = (site) => {
-        const p = param(site);
-        if (seen.has(p))
-            return;
-        seen.add(p);
-        out.push({ params: { path: p } });
-    };
-    const collections = (deps.config.registry.collections ?? []).map((c) => c.name);
     for (const locale of deps.config.locales.supported) {
-        for (const row of await deps.published.tree(locale))
-            if (row.path !== null)
-                add(deps.href(row.path, locale));
-        const published = new Set();
-        for (const name of collections)
-            for (const row of await deps.published.entries(name, { locale }))
-                published.add(row.id);
-        for (const row of await deps.pages.listLive(locale))
-            if (row.kind === "entry" && published.has(row.id))
-                add(deps.href(row.path, locale));
+        const { pages, entries } = await deps.delivery.addresses(locale);
+        for (const path of [...pages, ...entries]) {
+            const p = param(deps.href(path, locale));
+            if (seen.has(p))
+                continue;
+            seen.add(p);
+            out.push({ params: { path: p } });
+        }
     }
     return out;
 }
@@ -37,16 +24,13 @@ export async function staticPaths(deps) {
  *  some hosts. A stored path with any of them would redirect more than itself, so it is a literal address or nothing. */
 const literalAddress = (path) => !/[[\]*:]/.test(path);
 /** The redirect rows as Astro's `redirects` config: old address → the target's current address, 308 (spec
- *  2026-09-26 redirects §7 at the host). A target with no live path in the locale is left out: a 404 as on demand. */
+ *  2026-09-26 redirects §7 at the host). The service leaves out a target with no live path in the locale. */
 export async function redirectEntries(deps) {
     const out = {};
     for (const locale of deps.config.locales.supported) {
-        for (const row of await deps.pages.listRedirects(locale)) {
-            if (!literalAddress(row.path))
-                continue;
-            const current = (await deps.pages.targetPaths({ kind: row.kind, id: row.id }))[locale];
-            if (current && literalAddress(current))
-                out[deps.href(row.path, locale)] = { status: 308, destination: deps.href(current, locale) };
+        for (const row of (await deps.delivery.addresses(locale)).redirects) {
+            if (literalAddress(row.from) && literalAddress(row.to))
+                out[deps.href(row.from, locale)] = { status: 308, destination: deps.href(row.to, locale) };
         }
     }
     return out;

package/dist/canvas-marker.d.ts

@@ -0,0 +1,14 @@
+export type CanvasFlags = {
+    editor: true;
+} | {
+    version: string;
+};
+/** `path` with the marker as its last segment, before any query or hash. */
+export declare function markCanvasPath(path: string, flags: CanvasFlags): string;
+export type CanvasMarker = {
+    segments: string[];
+    editor: boolean;
+    version?: string;
+};
+/** The marker taken off a catch-all's segments, which a host may hand over encoded or not. */
+export declare function readCanvasMarker(segments: string[]): CanvasMarker;

package/dist/canvas-marker.js

@@ -0,0 +1,36 @@
+// The canvas marker: where the editor's canvas and History's frame say what they want of a draft render when the
+// host strips the query. Vercel keeps only a prerendered route's own params in the query, draft mode included, so
+// on Next the flags ride the path's last segment: `~editor` (mount the editor bridge) or `~version~<id>` (render a
+// stored version). The admin writes it (admin/editor/canvas-address.ts), the Next renderer reads it inside draft
+// mode only; outside draft mode a marked address is an ordinary miss. A slug never starts with `~`.
+const EDITOR = "~editor";
+const VERSION = "~version~";
+/** `path` with the marker as its last segment, before any query or hash. */
+export function markCanvasPath(path, flags) {
+    const cut = path.search(/[?#]/);
+    const [pathname, rest] = cut === -1 ? [path, ""] : [path.slice(0, cut), path.slice(cut)];
+    const segment = "editor" in flags ? EDITOR : VERSION + encodeURIComponent(flags.version);
+    return `${pathname.replace(/\/+$/, "")}/${segment}${rest}`;
+}
+/** The marker taken off a catch-all's segments, which a host may hand over encoded or not. */
+export function readCanvasMarker(segments) {
+    const last = segments.length > 0 ? safeDecode(segments[segments.length - 1]) : "";
+    const rest = segments.slice(0, -1);
+    if (last === EDITOR)
+        return { segments: rest, editor: true };
+    if (last.startsWith(VERSION) && last.length > VERSION.length) {
+        const raw = segments[segments.length - 1];
+        // The id was encoded once when the marker was written; a host that decoded the segment already handed it over plain.
+        const id = raw.startsWith(VERSION) ? safeDecode(raw.slice(VERSION.length)) : last.slice(VERSION.length);
+        return { segments: rest, editor: false, version: id };
+    }
+    return { segments, editor: false };
+}
+function safeDecode(segment) {
+    try {
+        return decodeURIComponent(segment);
+    }
+    catch {
+        return segment;
+    }
+}

package/dist/cli/api.d.ts

@@ -0,0 +1,14 @@
+export type CliApi = {
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body: unknown): Promise<T>;
+    /** The bytes, or null when the API answers 404. */
+    getBytes(path: string): Promise<Uint8Array | null>;
+    postBytes<T>(path: string, bytes: Uint8Array, mime: string): Promise<T>;
+};
+/** The API refused: its status, its code and its message, as the content API words them. */
+export declare class CliApiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string, message: string);
+}
+export declare function connectApi(cwd: string, env?: Record<string, string | undefined>, doFetch?: typeof fetch): CliApi;

package/dist/cli/api.js

@@ -0,0 +1,48 @@
+// The CLI's door to Smoodly's API (plan 2026-10-14 the service holds the stores): the site's env — SMOODLY_API_URL,
+// SMOODLY_SPACE_ID, SMOODLY_SECRET_KEY, from the app's env files — and the content API's envelope `{ ok, data }`.
+import { apiEnv } from "../env.js";
+import { loadAppEnv } from "./app-env.js";
+/** The API refused: its status, its code and its message, as the content API words them. */
+export class CliApiError extends Error {
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "CliApiError";
+    }
+}
+export function connectApi(cwd, env = process.env, doFetch = fetch) {
+    const read = loadAppEnv(cwd, env);
+    if (read.length === 0 && !env.SMOODLY_API_URL && !env.SMOODLY_SECRET_KEY) {
+        throw new Error(`smoodly: no .env.local or .env in ${cwd} — run this in your app's folder.`);
+    }
+    const { apiUrl, spaceId, key } = apiEnv(env);
+    const base = `${apiUrl}/v1/spaces/${encodeURIComponent(spaceId)}`;
+    async function call(path, init = {}) {
+        try {
+            return await doFetch(`${base}${path}`, { ...init, headers: { ...init.headers, authorization: `Bearer ${key}` } });
+        }
+        catch (e) {
+            throw new Error(`smoodly: can't reach SMOODLY_API_URL (${apiUrl}): ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    async function data(res) {
+        const body = (await res.json().catch(() => null));
+        if (body?.ok === true)
+            return body.data;
+        throw new CliApiError(res.status, typeof body?.code === "string" ? body.code : "internal", typeof body?.message === "string" ? body.message : `smoodly: SMOODLY_API_URL (${apiUrl}) answered ${res.status} with no message.`);
+    }
+    return {
+        get: async (path) => data(await call(path)),
+        post: async (path, body) => data(await call(path, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) })),
+        async getBytes(path) {
+            const res = await call(path);
+            if (res.status === 404)
+                return null;
+            if (!res.ok)
+                return data(res);
+            return new Uint8Array(await res.arrayBuffer());
+        },
+        postBytes: async (path, bytes, mime) => data(await call(path, { method: "POST", headers: { "content-type": mime }, body: bytes })),
+    };
+}

package/dist/cli/app-env.d.ts

@@ -0,0 +1,2 @@
+/** `.env.local`, then `.env`, as Next reads them; a variable already set wins (spec §5). Returns the files it read. */
+export declare function loadAppEnv(cwd: string, env?: Record<string, string | undefined>): string[];

package/dist/cli/app-env.js

@@ -0,0 +1,20 @@
+// The app's env files as the CLI reads them (spec 2026-09-28 export/import §5): `.env.local`, then `.env`, as Next
+// reads them; a variable already set wins.
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseEnv } from "node:util";
+/** `.env.local`, then `.env`, as Next reads them; a variable already set wins (spec §5). Returns the files it read. */
+export function loadAppEnv(cwd, env = process.env) {
+    const read = [];
+    for (const name of [".env.local", ".env"]) {
+        const file = join(cwd, name);
+        if (!existsSync(file))
+            continue;
+        read.push(name);
+        for (const [key, value] of Object.entries(parseEnv(readFileSync(file, "utf8")))) {
+            if (env[key] === undefined)
+                env[key] = value;
+        }
+    }
+    return read;
+}

package/dist/cli/export.d.ts

@@ -1,14 +1,28 @@
-import { type SpaceConnection } from "./space-io.ts";
+import { type ContentTable } from "../space-transfer.ts";
+import { type ExportMember, type Row } from "../space-transfer.ts";
+import { type CliApi } from "./api.ts";
 export type ExportArgs = {
     out: string | null;
 };
 export type ExportDeps = {
     cwd?: string;
-    connection?: SpaceConnection;
+    api?: CliApi;
     now?: () => Date;
+    /** Where SMOODLY_SPACE_ID is read, after connectApi loaded the app's env files into it; default process.env. */
+    env?: Record<string, string | undefined>;
+};
+/** What a transfer starts from (the service's GET /transfer). */
+export type TransferHead = {
+    schemaVersion: number;
+    members: ExportMember[];
 };
 export declare const defaultExportDir: (now: Date) => string;
 export declare const folderExists: (dir: string) => string;
 export declare const CHANGED_DURING_EXPORT = "Content changed during export \u2014 run it again.";
 export declare const missingFile: (path: string) => string;
+/** The transfer's head, or null after printing the API's refusal of a database without the schema. */
+export declare function transferHead(api: CliApi, out: (line: string) => void): Promise<TransferHead | null>;
+/** Every page of one table, as the service answers it: `keys` reads only the key columns. */
+export declare function readTable(api: CliApi, table: ContentTable, keys?: boolean): Promise<Row[]>;
+export declare const mediaUrl: (path: string) => string;
 export declare function runExport(args: ExportArgs, out: (line: string) => void, deps?: ExportDeps): Promise<number>;

package/dist/cli/export.js

@@ -1,21 +1,50 @@
 // packages/smoodly/src/cli/export.ts
-// `smoodly export` (spec 2026-09-28 export/import §8): the key's space —
-// every content row, history included, and the media files — into a
-// folder. Reads only; the folder appears whole or not at all (written as
-// <dir>.partial, renamed last). The message strings are what the guide
-// quotes.
-import { existsSync } from "node:fs";
+// `smoodly export` (spec 2026-09-28 export/import §8; over the API since plan
+// 2026-10-14 the service holds the stores): the key's space — every content
+// row, history included, and the media files — into a folder. The service
+// pipes the rows without their space; the consistency check runs here, over
+// the whole export. Reads only; the folder appears whole or not at all
+// (written as <dir>.partial, renamed last). The message strings are what the
+// guide quotes.
+import { existsSync, readFileSync } from "node:fs";
 import { mkdir, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { schemaBehind, schemaBehindMessage } from "../schema-version.js";
-import { CONTENT_TABLES } from "../sql-space.js";
-import { FORMAT, brokenReferences, countRows, describeExport, emptyTables, fromSpace, sortRows, } from "../space-transfer.js";
-import { MEDIA_BUCKET, connectFromEnv, isNotFound, packageVersion, readSchemaVersion, readSpaceRows, schemaRefusal, } from "./space-io.js";
-import { readCurrentSpace } from "../current-space.js";
+import { fileURLToPath } from "node:url";
+import { CONTENT_TABLES } from "../space-transfer.js";
+import { FORMAT, brokenReferences, countRows, describeExport, emptyTables, sortRows, } from "../space-transfer.js";
+import { CliApiError, connectApi } from "./api.js";
 export const defaultExportDir = (now) => `smoodly-export-${now.toISOString().slice(0, 10)}`;
 export const folderExists = (dir) => `Refusing: ${dir} already exists. Remove it, or pass --out <dir>.`;
 export const CHANGED_DURING_EXPORT = "Content changed during export — run it again.";
 export const missingFile = (path) => `Warning: ${path} is missing from the media bucket (already broken on the site); its asset row is exported without a file.`;
+/** The installed package's version for the manifest: `../../package.json` from src/cli/ and dist/cli/ alike. */
+function packageVersion() {
+    return JSON.parse(readFileSync(fileURLToPath(new URL("../../package.json", import.meta.url).href), "utf8")).version;
+}
+/** The transfer's head, or null after printing the API's refusal of a database without the schema. */
+export async function transferHead(api, out) {
+    try {
+        return await api.get("/transfer");
+    }
+    catch (e) {
+        if (e instanceof CliApiError && e.code === "validation") {
+            out(e.message);
+            return null;
+        }
+        throw e;
+    }
+}
+/** Every page of one table, as the service answers it: `keys` reads only the key columns. */
+export async function readTable(api, table, keys = false) {
+    const rows = [];
+    for (let offset = 0; offset !== null;) {
+        const page = await api.get(`/transfer/rows/${table}?offset=${offset}${keys ? "&keys=1" : ""}`);
+        rows.push(...page.rows);
+        offset = page.next;
+    }
+    return rows;
+}
+export const mediaUrl = (path) => `/transfer/media?path=${encodeURIComponent(path)}`;
 export async function runExport(args, out, deps = {}) {
     const cwd = deps.cwd ?? process.cwd();
     const now = (deps.now ?? (() => new Date()))();
@@ -27,22 +56,16 @@ export async function runExport(args, out, deps = {}) {
         out(folderExists(shown));
         return 1;
     }
-    const { db } = deps.connection ?? connectFromEnv(cwd);
-    const schema = await readSchemaVersion(db);
-    if ("missing" in schema) {
-        out(schemaRefusal(schema.missing, "Export"));
-        return 1;
-    }
-    const space = await readCurrentSpace(db);
-    if (schemaBehind(schema.version)) {
-        out(schemaBehindMessage(schema.version));
+    const env = deps.env ?? process.env;
+    const api = deps.api ?? connectApi(cwd, env);
+    // Read after connectApi: it loads the app's .env files. The space's public id; the service knows its database's.
+    const space = env.SMOODLY_SPACE_ID ?? "";
+    const head = await transferHead(api, out);
+    if (!head)
         return 1;
-    }
     const rows = emptyTables();
-    for (const table of CONTENT_TABLES) {
-        const read = await readSpaceRows(db, table, space, table === "assets" ? { status: "ready" } : {});
-        rows[table] = sortRows(table, read.map((row) => fromSpace(table, row, space)));
-    }
+    for (const table of CONTENT_TABLES)
+        rows[table] = sortRows(table, await readTable(api, table));
     const broken = brokenReferences(rows);
     if (broken.length > 0) {
         out(CHANGED_DURING_EXPORT);
@@ -50,9 +73,6 @@ export async function runExport(args, out, deps = {}) {
             out(`  ${line}`);
         return 1;
     }
-    const members = await db.from("members").select("email, role").eq("space_id", space).order("email");
-    if (members.error)
-        throw new Error(`smoodly: reading members: ${members.error.message}`);
     const partial = `${dir}.partial`;
     await rm(partial, { recursive: true, force: true });
     await mkdir(join(partial, "rows"), { recursive: true });
@@ -62,15 +82,12 @@ export async function runExport(args, out, deps = {}) {
     let bytes = 0;
     for (const asset of rows.assets) {
         const path = String(asset.path);
-        const got = await db.storage.from(MEDIA_BUCKET).download(`${space}/${path}`);
-        if (got.error) {
-            if (!isNotFound(got.error))
-                throw new Error(`smoodly: downloading ${path}: ${got.error.message}`);
+        const data = await api.getBytes(mediaUrl(path));
+        if (!data) {
             missing.push(path);
             out(missingFile(path));
             continue;
         }
-        const data = new Uint8Array(await got.data.arrayBuffer());
         const file = join(partial, "media", path);
         await mkdir(dirname(file), { recursive: true });
         await writeFile(file, data);
@@ -82,13 +99,13 @@ export async function runExport(args, out, deps = {}) {
     }
     const manifest = {
         format: FORMAT,
-        schemaVersion: schema.version,
+        schemaVersion: head.schemaVersion,
         smoodlyVersion: packageVersion(),
         exportedAt: now.toISOString(),
         sourceSpace: space,
         counts: countRows(rows),
         media: { files, bytes, missing },
-        members: (members.data ?? []),
+        members: head.members,
     };
     await writeFile(join(partial, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`);
     await rename(partial, dir);

package/dist/cli/import.d.ts

@@ -1,23 +1,19 @@
-import { type ContentTable } from "../sql-space.ts";
-import { type SpaceConnection } from "./space-io.ts";
-import type { ResolvedConfig } from "../config.ts";
+import { type ContentTable } from "../space-transfer.ts";
+import { type CliApi } from "./api.ts";
 export type ImportArgs = {
     dir: string;
 };
 export type ImportDeps = {
     cwd?: string;
-    connection?: SpaceConnection;
-    /** The app's config, which the closing rebuild assembles with; default: loaded from the folder (load-config.ts). */
-    config?: ResolvedConfig;
+    api?: CliApi;
     batchSize?: number;
     /** Test seam: runs before each batch; a throw stops the import there. */
     beforeBatch?: (table: ContentTable, index: number) => void;
+    /** Where SMOODLY_SPACE_ID is read, after connectApi loaded the app's env files into it; default process.env. */
+    env?: Record<string, string | undefined>;
 };
-export declare const BATCH_ROWS = 500;
-export declare const notAnExport: (dir: string) => string;
-export declare const formatMismatch: (format: unknown) => string;
 export declare const RUN_AGAIN = "Run the same command again to continue: rows and files that landed are skipped.";
-export declare const MEMBERS_HEADING = "Members in the source \u2014 invite them in Settings \u203A Members:";
-export declare const nothingNew: (space: string) => string;
+export declare const MEMBERS_HEADING = "Members in the source \u2014 add them to the space's members in the project at smoodly.io:";
+export declare const nothingNew: () => string;
 export declare const CACHE_NOTE = "Restart or redeploy the app: it may have cached pages from while the space was empty.";
 export declare function runImport(args: ImportArgs, out: (line: string) => void, deps?: ImportDeps): Promise<number>;

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";
 } | {