smoodly 0.0.50 → 0.0.52

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,25 @@ 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>>;
+    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 +85,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>;

package/dist/content/content-api.js

@@ -2,13 +2,11 @@
 // 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";
+// One surface over a transport (spec 2026-10-14 §1): the content API with the
+// secret key for a seed or a script, the stores in one process for the service.
+import { makeClientOps } from "../admin/client-ops.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@]+$/;
+import { mimeOf } from "./mime.js";
 export class SmoodlyContentError extends Error {
     constructor(error) {
         const list = (error.fields ?? []).map((f) => `\n  ${f.field}: ${f.message}`).join("");
@@ -24,42 +22,55 @@ async function must(result) {
         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." });
+/** 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 function apiTransport(options) {
+    const apiUrl = options.apiUrl.replace(/\/+$/, "");
+    const base = `${apiUrl}/v1/spaces/${encodeURIComponent(options.spaceId)}`;
+    const doFetch = options.fetch ?? fetch;
+    async function send(path, init = {}) {
+        let res;
+        try {
+            res = await doFetch(`${base}${path}`, { ...init, headers: { ...init.headers, authorization: `Bearer ${options.key}`, accept: "application/json" } });
         }
-        if (options.password !== undefined) {
-            await members.createAccount({ email, password: options.password, role: "admin" });
-            return { email, invited: false };
+        catch (e) {
+            throw new SmoodlyContentError({ code: "internal", message: `smoodly: can't reach SMOODLY_API_URL (${apiUrl}): ${e instanceof Error ? e.message : String(e)}` });
         }
-        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) });
+        const body = (await res.json().catch(() => null));
+        if (!body || typeof body.ok !== "boolean") {
+            return { ok: false, code: "internal", message: `smoodly: SMOODLY_API_URL (${apiUrl}) answered ${res.status} with no message.` };
+        }
+        return body;
     }
+    const json = (body) => ({ method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
+    return {
+        op: (call) => send("/op", json({ path: call.path, args: call.args })),
+        locate: (locale, path) => must(send(`/locate?${new URLSearchParams({ locale, path })}`)),
+        // The bytes as the body with their length, the rest in the query (spec 2026-10-18 media on R2 and Images §4).
+        async upload(bytes, filename, mime, meta) {
+            const type = mime ?? mimeOf(filename);
+            const params = { name: filename, mime: type };
+            const dims = imageDimensions(bytes);
+            if (dims) {
+                params.width = String(dims.width);
+                params.height = String(dims.height);
+            }
+            for (const key of ["title", "alt", "caption", "credit"])
+                if (meta[key] !== undefined)
+                    params[key] = meta[key];
+            const record = await must(send(`/media?${new URLSearchParams(params)}`, { method: "PUT", headers: { "content-type": type }, body: bytes }));
+            return { asset: record.id, ...(meta.alt !== undefined ? { alt: meta.alt } : {}) };
+        },
+    };
 }
 export function createSmoodlyContent(deps) {
-    const ops = createAdminOps(deps);
+    const { transport } = deps;
+    const ops = makeClientOps((call) => transport.op(call));
     const def = deps.config.locales.default;
     async function findPage(locale, path) {
-        const hit = await deps.pages.resolvePath(locale, path);
+        const hit = await transport.locate(locale, path);
         if (hit?.kind === "page" && !hit.redirect)
-            return deps.pages.getPage(hit.id);
+            return (await must(ops.pages.get(hit.id, locale))).record;
         return null;
     }
     async function updateEntry(collection, id, locale, fields) {
@@ -145,32 +156,11 @@ export function createSmoodlyContent(deps) {
         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 } : {}) };
+                return transport.upload(bytes, filename, meta.mime, meta);
             },
         },
-        members: {
-            addAdmin: (email, options = {}) => addAdmin(deps.members, email, options),
-        },
     };
 }

package/dist/content/mime.d.ts

@@ -0,0 +1 @@
+export declare const mimeOf: (filename: string) => string;

package/dist/content/mime.js

@@ -0,0 +1,6 @@
+// A file's type from its extension, for an upload that names none (a script's file path, bytes with a filename).
+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",
+};
+export const mimeOf = (filename) => MIME[filename.split(".").pop().toLowerCase()] ?? "application/octet-stream";

package/dist/deploy-store.d.ts

@@ -0,0 +1,19 @@
+export interface DeployStore {
+    /** The latest published_at over pages and entries (ms); null when nothing is published. The static build's watermark. */
+    newestPublishedAt(): Promise<number | null>;
+    /** Locale rows published strictly after `since` (ms), pages plus entries: the tile's "changes waiting". */
+    countPublishedAfter(since: number): Promise<number>;
+    /** The space's last Deploy press; null until the first. */
+    deployRequest(): Promise<{
+        at: number;
+        by: string | null;
+    } | null>;
+    requestDeploy(by: string | null, at?: number): Promise<void>;
+    /** When a published row last went (an unpublish, a delete): a change the count of newer rows cannot see. */
+    lastRemovalAt(): Promise<number | null>;
+    /** Written by the operations on an unpublish or a delete of a published row. */
+    recordRemoval(at?: number): Promise<void>;
+    /** Written by the operations on every publish: the SQLite store ignores it (the locale row carries published_at),
+     *  the memory one counts it. */
+    recordPublish(at?: number): Promise<void>;
+}

package/dist/deploy-store.js

@@ -0,0 +1 @@
+export {};