smoodly 0.0.51 → 0.0.53

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,57 @@ 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 })),
+        // A draft read (DESIGN §1 Content API › Writes): the caller holds the secret key and asks about what it is writing,
+        // and a draft read is never stored at the edge, so a script sees its own create at once.
+        locate: (locale, path) => must(send(`/locate?${new URLSearchParams({ locale, path, draft: "1" })}`)),
+        // 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 +158,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/css.js

@@ -1,7 +1,7 @@
 // The custom-CSS box (spec 2026-09-14 §4): a per-section snippet the
 // wrapper nests under the section's own [data-smd-node] selector. CSS
 // can do two things beyond styling — pull a remote stylesheet and beacon
-// to a host — so those, the two legacy code hooks and the tag-closing
+// to a host — so those, the two old code hooks (`expression()`, `behavior:`) and the tag-closing
 // sequence are refused at save and stripped at render, in that order.
 // The checks run on the snippet with its CSS escapes decoded, so
 // `\75 rl(` cannot spell `url(` past them; and the braces must balance,

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/entry-store.d.ts

@@ -1,9 +1,8 @@
 import type { CollectionSchema, EntryOrder } from "./collections.ts";
 import type { GlobalSchema } from "./global.ts";
 import { type RefEdge, type SectionLike } from "./refs.ts";
-import { MemoryRefIndex } from "./ref-index.ts";
-import { type PathHit, type PathIndex } from "./path-index.ts";
-import { type DraftToken } from "./draft-token.ts";
+import type { PathHit, PathIndex } from "./path-index.ts";
+import type { DraftToken } from "./draft-token.ts";
 import { type LocaleSet } from "./paths.ts";
 export type EntryLocale = {
     /** The entry's segment in this locale; null claims no URL. */
@@ -59,8 +58,8 @@ export type Where = Record<string, WhereValue | WhereValue[]>;
  *  adapters read the text form of the whole array, never its elements). */
 export declare const ARRAY_FIELD_TYPES: ReadonlySet<string>;
 /** The memory adapter's and the tests' reading of `where`: a scalar matches an
- *  equal value or an array holding it (JSONB containment); an array is any-of,
- *  compared as text like PostgREST's `->>`. */
+ *  equal value or an array holding it (containment); an array is any-of,
+ *  compared as text (textForm). */
 export declare function matchesWhere(fields: Record<string, unknown>, where: Where): boolean;
 export type ListOptions = {
     /** Equality / any-of on shared fields, executed by the store (spec 2026-09-11 §3). */
@@ -254,96 +253,11 @@ export declare function entryTitleIn(record: EntryRecord, locale: string, schema
  * Sort comparator for one order rule; `seq` breaks ties by creation. A
  * declared order field is SHARED (collection() refuses a localized one),
  * so `e.fields[order.by]` reads the node. Nulls sort last in BOTH
- * directions (the Supabase adapter uses `nullsFirst: false` to match);
+ * directions (the SQLite list compiler sorts nulls last to match);
  * the creation tiebreak follows `direction` for non-manual orders.
  * Declared fields compare numerically when both values are numbers,
- * otherwise as strings via `localeCompare` — the same order Postgres
- * gives the jsonb VALUE (`fields->x`) for one type; see MAINTAINERS.md's
- * follow-ups for the mixed-type and JSON-null edges.
+ * otherwise as strings via `localeCompare` — the order the SQLite store's
+ * `COLLATE NOCASE` gives for one type (ASCII only; see MAINTAINERS.md's
+ * follow-ups for the mixed-type, JSON-null and non-ASCII edges).
  */
 export declare function compareEntries(order: EntryOrder, seq: (e: EntryRecord) => number): (a: EntryRecord, b: EntryRecord) => number;
-/** Comparator for `query`: like compareEntries, but a declared field reads the
- *  merged snapshot, `updatedAt` the locale row's, and an absent, null or empty-string value
- *  sorts last in both directions; ties break by creation order (ascending). */
-export declare function compareSnapshots(order: EntryOrder, locale: string, seq: (id: string) => number): (a: SnapshotRow, b: SnapshotRow) => number;
-export declare class MemoryEntryStore implements EntryStore {
-    private refs;
-    private entries;
-    private versions;
-    /** Insertion order per version — `savedAt` alone can tie within a millisecond. */
-    private versionSeq;
-    private seq;
-    private order;
-    private paths;
-    private locales;
-    private schemas;
-    private elements;
-    constructor(collections: CollectionSchema<any>[], refs?: MemoryRefIndex, options?: EntryStoreOptions);
-    private schema;
-    private row;
-    private must;
-    private byId;
-    private snapshot;
-    private subtree;
-    /** An edit bumps the node and the edited row; `move` and `reorder` never call this. */
-    private bump;
-    /** The draft rule (spec 2026-09-13 history §1) for every collection (spec 2026-09-14 §1):
-     *  the unpublished draft row is rewritten in place and a new one starts only when the
-     *  draft IS the published one. */
-    private recordVersion;
-    /** A published row from before every collection was versioned has no snapshot; give it
-     *  one from what is live BEFORE a write changes the fields, so the site keeps serving it
-     *  and the write lands in a new draft row (spec 2026-09-14 §1). */
-    private ensureLiveSnapshot;
-    private dropVersions;
-    /** Every field set the site can render for this entry: each present
-     *  locale's live view, plus a published snapshot the draft has moved
-     *  past (still rendered by the published site). */
-    private liveFieldSets;
-    private writePaths;
-    private writeRefs;
-    private siblings;
-    /** The friendly pre-check (spec 2026-09-06 §11): a string slug must be
-     *  unique among the siblings PRESENT in that locale; null never
-     *  conflicts. The paths primary key remains the invariant. */
-    private assertSiblingSlug;
-    /** Same collection, within depth. Returns the parent (null at the root). */
-    private assertParent;
-    /** The parent rule: a locale can only be added where the parent has it. */
-    private assertParentHasLocale;
-    create(collection: string, fields: Record<string, unknown>, options: CreateEntryOptions, by?: string): Promise<EntryRecord>;
-    get(collection: string, id: string): Promise<EntryRecord | null>;
-    list(collection: string, options?: ListOptions): Promise<EntryRecord[]>;
-    query(collection: string, q: SnapshotQuery): Promise<SnapshotRow[]>;
-    getMany(collection: string, ids: string[], locale: string, options?: {
-        status?: "published";
-    }): Promise<Record<string, Record<string, unknown>>>;
-    update(collection: string, id: string, locale: string, fields: Record<string, unknown>, by?: string, expected?: DraftToken | null, options?: {
-        redirect?: boolean;
-    }): Promise<EntryRecord>;
-    setStatus(collection: string, id: string, locale: string, status: "draft" | "published", by?: string, expected?: DraftToken | null): Promise<EntryRecord>;
-    discardDraft(collection: string, id: string, locale: string, by?: string, expected?: DraftToken | null): Promise<EntryRecord>;
-    addLocale(collection: string, id: string, locale: string, options: AddEntryLocaleOptions, by?: string): Promise<EntryRecord>;
-    removeLocale(collection: string, id: string, locale: string): Promise<EntryRecord>;
-    scanEntries(): Promise<EntryScan[]>;
-    listVersions(collection: string, id: string, locale: string): Promise<EntryVersion[]>;
-    restore(collection: string, id: string, locale: string, versionId: string, by?: string, expected?: DraftToken | null): Promise<EntryRecord>;
-    getVersion(collection: string, versionId: string): Promise<EntryVersion | null>;
-    move(collection: string, id: string, to: {
-        parentId: string | null;
-        index?: number;
-    }, options?: {
-        redirect?: boolean;
-    }): Promise<EntryRecord>;
-    delete(collection: string, id: string): Promise<void>;
-    reorder(collection: string, orderedIds: string[]): Promise<void>;
-    referencesTo(collection: string, id: string): Promise<EntryUsage[]>;
-    incoming(targetId: string): Promise<{
-        sourceKind: string;
-        sourceId: string;
-    }[]>;
-    resolvePath(locale: string, path: string): Promise<PathHit | null>;
-    pathsIn(collection: string, ids: string[], locale: string): Promise<Record<string, string>>;
-    pathsOf(collection: string, id: string): Promise<{}>;
-    redirectsOf(collection: string, id: string): Promise<Record<string, string[]>>;
-}