smoodly 0.0.46 → 0.0.48

package/dist/supabase-published-store.d.ts

@@ -1,6 +1,6 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
 import type { CollectionSchema } from "./collections.ts";
-import type { PublishedEntryRow, PublishedKey, PublishedPageRow, PublishedQuery, PublishedRoute, PublishedStore, PublishedTreeRow } from "./published.ts";
+import type { PublishedEntryRow, PublishedKey, PublishedPageRow, PublishedQuery, PublishedRoute, PublishedStore, PublishedTreeRow, PutOptions } from "./published.ts";
 export declare class SupabasePublishedStore implements PublishedStore {
     private db;
     private schemas;
@@ -8,8 +8,8 @@ export declare class SupabasePublishedStore implements PublishedStore {
     /** `collections` encode a `where` on an array field as containment, as SupabaseEntryStore.query does. */
     constructor(db: SupabaseClient, collections?: CollectionSchema<any>[]);
     private fail;
-    putPages(rows: PublishedPageRow[]): Promise<void>;
-    putEntries(rows: PublishedEntryRow[]): Promise<void>;
+    putPages(rows: PublishedPageRow[], options?: PutOptions): Promise<void>;
+    putEntries(rows: PublishedEntryRow[], options?: PutOptions): Promise<void>;
     /** The space this client writes in (the service role's is the default): a path delete must not reach past it,
      *  since the service role passes every policy. Cached for the life of the client; a failed lookup is not. */
     private space;
@@ -20,6 +20,27 @@ export declare class SupabasePublishedStore implements PublishedStore {
     /** One request per kind and locale filter: the keys without a locale go in one in(). */
     private eachGroup;
     remove(keys: PublishedKey[]): Promise<void>;
+    lastRemovalAt(): Promise<number | null>;
+    /** The space's recorded stamp (DESIGN §3): one row per space in published_models; the key's space, or the
+     *  service role's default one. */
+    recordedModel(): Promise<string | null>;
+    recordModel(model: string): Promise<void>;
+    /** Four head counts (no rows travel): each table's rows, and its rows at another stamp. The policies scope a
+     *  write key to its space; the service role counts the default space's rows by the explicit filter. */
+    countBehind(model: string): Promise<{
+        behind: number;
+        total: number;
+    }>;
+    /** The static build's watermark (spec 2026-10-09 static mode §5): the newest published_at over both tables. */
+    newestPublishedAt(): Promise<number | null>;
+    /** Rows published strictly after `since`: the Deploy tile's "changes waiting". Two head counts. */
+    countPublishedAfter(since: number): Promise<number>;
+    /** The space's last Deploy press, one row in space_deploys (schema v11). */
+    deployRequest(): Promise<{
+        at: number;
+        by: string | null;
+    } | null>;
+    requestDeploy(by: string | null, at?: number): Promise<void>;
     markStale(keys: PublishedKey[]): Promise<void>;
     /** A route row is for serving, not for the tree: a page route carries the
      *  document, model, stale flag and tags; its tree columns are empty, and an

package/dist/supabase-published-store.js

@@ -13,6 +13,13 @@ const fromPage = (r) => ({
     id: r.page_id, locale: r.locale, parentId: r.parent_id, sort: num(r.sort), path: r.path, title: r.title, hasPage: r.has_page,
     linkFields: r.link_fields, document: r.document, tags: r.tags, model: r.model, stale: r.stale, publishedAt: Date.parse(r.published_at),
 });
+/** `keep` strips published_at from an upsert's payload (PutOptions): the row keeps its own, a new row is dated by the default. */
+function keeping(row, options) {
+    if (!options?.keep)
+        return row;
+    const { published_at: _at, ...rest } = row;
+    return rest;
+}
 const toPage = (r) => ({
     page_id: r.id, locale: r.locale, parent_id: r.parentId, sort: r.sort, path: r.path, title: r.title, has_page: r.hasPage,
     link_fields: r.linkFields, document: r.document, tags: r.tags, model: r.model, stale: r.stale, published_at: iso(r.publishedAt),
@@ -36,20 +43,21 @@ export class SupabasePublishedStore {
     fail(message) {
         throw new Error(`smoodly: published store: ${message}`);
     }
-    async putPages(rows) {
+    async putPages(rows, options) {
         for (let i = 0; i < rows.length; i += CHUNK) {
             const chunk = rows.slice(i, i + CHUNK);
             await this.vacate("published_pages", "page_id", chunk);
-            const res = await this.db.from("published_pages").upsert(chunk.map(toPage), { onConflict: "page_id,locale" });
+            // `keep`: published_at leaves the payload, so an updated row keeps its own and an inserted one takes the default (now).
+            const res = await this.db.from("published_pages").upsert(chunk.map((r) => keeping(toPage(r), options)), { onConflict: "page_id,locale" });
             if (res.error)
                 this.fail(res.error.message);
         }
     }
-    async putEntries(rows) {
+    async putEntries(rows, options) {
         for (let i = 0; i < rows.length; i += CHUNK) {
             const chunk = rows.slice(i, i + CHUNK);
             await this.vacate("published_entries", "entry_id", chunk);
-            const res = await this.db.from("published_entries").upsert(chunk.map(toEntry), { onConflict: "entry_id,locale" });
+            const res = await this.db.from("published_entries").upsert(chunk.map((r) => keeping(toEntry(r), options)), { onConflict: "entry_id,locale" });
             if (res.error)
                 this.fail(res.error.message);
         }
@@ -108,14 +116,105 @@ export class SupabasePublishedStore {
         }
     }
     async remove(keys) {
+        if (keys.length === 0)
+            return;
+        let deleted = 0;
         await this.eachGroup(keys, async (table, column, ids, locale) => {
-            let q = this.db.from(table).delete().in(column, ids);
+            let q = this.db.from(table).delete({ count: "exact" }).in(column, ids);
             if (locale !== undefined)
                 q = q.eq("locale", locale);
             const res = await q;
             if (res.error)
                 this.fail(res.error.message);
+            deleted += res.count ?? 0;
         });
+        // A row that went is a change the count of newer rows cannot see (spec 2026-10-09 static mode §5): the space's
+        // row keeps when one last happened. A key with no row (a publish vacating a locale that never had one) is no
+        // change. The press's columns are absent from the payload, so they stay as they are.
+        if (deleted === 0)
+            return;
+        const res = await this.db.from("space_deploys").upsert({ space_id: await this.space(), removed_at: new Date().toISOString() }, { onConflict: "space_id" });
+        if (res.error)
+            this.fail(res.error.message);
+    }
+    async lastRemovalAt() {
+        const res = await this.db.from("space_deploys").select("removed_at").eq("space_id", await this.space()).maybeSingle();
+        if (res.error)
+            this.fail(res.error.message);
+        const at = res.data?.removed_at;
+        return at ? Date.parse(at) : null;
+    }
+    /** The space's recorded stamp (DESIGN §3): one row per space in published_models; the key's space, or the
+     *  service role's default one. */
+    async recordedModel() {
+        const res = await this.db.from("published_models").select("model").eq("space_id", await this.space()).maybeSingle();
+        if (res.error)
+            this.fail(res.error.message);
+        return res.data?.model ?? null;
+    }
+    async recordModel(model) {
+        const res = await this.db.from("published_models")
+            .upsert({ space_id: await this.space(), model, recorded_at: new Date().toISOString() }, { onConflict: "space_id" });
+        if (res.error)
+            this.fail(res.error.message);
+    }
+    /** Four head counts (no rows travel): each table's rows, and its rows at another stamp. The policies scope a
+     *  write key to its space; the service role counts the default space's rows by the explicit filter. */
+    async countBehind(model) {
+        const space = await this.space();
+        const count = async (table, behind) => {
+            let q = this.db.from(table).select("*", { count: "exact", head: true }).eq("space_id", space);
+            if (behind)
+                q = q.neq("model", model);
+            const res = await q;
+            if (res.error)
+                this.fail(res.error.message);
+            return res.count ?? 0;
+        };
+        const [pages, entries, pagesBehind, entriesBehind] = await Promise.all([
+            count("published_pages", false), count("published_entries", false), count("published_pages", true), count("published_entries", true),
+        ]);
+        return { behind: pagesBehind + entriesBehind, total: pages + entries };
+    }
+    /** The static build's watermark (spec 2026-10-09 static mode §5): the newest published_at over both tables. */
+    async newestPublishedAt() {
+        const space = await this.space();
+        const latest = async (table) => {
+            const res = await this.db.from(table).select("published_at").eq("space_id", space).order("published_at", { ascending: false }).limit(1).maybeSingle();
+            if (res.error)
+                this.fail(res.error.message);
+            const at = res.data?.published_at;
+            return at ? Date.parse(at) : null;
+        };
+        const [p, e] = await Promise.all([latest("published_pages"), latest("published_entries")]);
+        return p === null && e === null ? null : Math.max(p ?? 0, e ?? 0);
+    }
+    /** Rows published strictly after `since`: the Deploy tile's "changes waiting". Two head counts. */
+    async countPublishedAfter(since) {
+        const space = await this.space();
+        const count = async (table) => {
+            const res = await this.db.from(table).select("*", { count: "exact", head: true }).eq("space_id", space).gt("published_at", new Date(since).toISOString());
+            if (res.error)
+                this.fail(res.error.message);
+            return res.count ?? 0;
+        };
+        const [p, e] = await Promise.all([count("published_pages"), count("published_entries")]);
+        return p + e;
+    }
+    /** The space's last Deploy press, one row in space_deploys (schema v11). */
+    async deployRequest() {
+        const res = await this.db.from("space_deploys").select("requested_at, requested_by").eq("space_id", await this.space()).maybeSingle();
+        if (res.error)
+            this.fail(res.error.message);
+        // A removal may have made the row before any press: no requested_at is no press.
+        const row = res.data;
+        return row?.requested_at ? { at: Date.parse(row.requested_at), by: row.requested_by } : null;
+    }
+    async requestDeploy(by, at = Date.now()) {
+        const res = await this.db.from("space_deploys")
+            .upsert({ space_id: await this.space(), requested_at: new Date(at).toISOString(), requested_by: by }, { onConflict: "space_id" });
+        if (res.error)
+            this.fail(res.error.message);
     }
     async markStale(keys) {
         await this.eachGroup(keys, async (table, column, ids, locale) => {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const SMOODLY_VERSION = "0.0.46";
+export declare const SMOODLY_VERSION = "0.0.48";

package/dist/version.js

@@ -1,2 +1,2 @@
 // Generated by scripts/write-version.mjs from package.json — do not edit.
-export const SMOODLY_VERSION = "0.0.46";
+export const SMOODLY_VERSION = "0.0.48";

package/migrations/20261008120000_smoodly_v10.sql

@@ -0,0 +1,47 @@
+-- Smoodly core schema, version 10 (DESIGN §3, the document stamp, decided 2026-10-08).
+-- Shipped in the smoodly package; `npx smoodly migrate` copies it into supabase/migrations/.
+-- Never edit a published file: the next change is the next file.
+-- The delta over version 9: published_models, one row per space holding the
+-- document stamp the space recorded as current, so only the deployment at that
+-- stamp rewrites delivery rows (a preview deployment on a newer package serves
+-- assembled documents and writes nothing). Additive: no function changes.
+
+set client_min_messages = warning;
+
+-- The document stamp a space recorded as current: set by `npx smoodly rebuild` and by the first writer
+-- into an empty record; only a reader at this stamp rewrites published_pages and published_entries.
+create table if not exists "published_models" (
+  "space_id" uuid primary key default '00000000-0000-0000-0000-000000000000',
+  "model" text not null,
+  "recorded_at" timestamptz not null default now()
+);
+
+alter table "published_models" enable row level security;
+
+-- Stamped with the caller's space on insert, as every content table.
+drop trigger if exists "smoodly_a_set_space" on "published_models";
+create trigger "smoodly_a_set_space" before insert on "published_models"
+  for each row execute function "smoodly_set_space"();
+
+-- A write key reads and writes its own space's record; no other key reads (spec 2026-09-29 content API contract §8).
+drop policy if exists "smoodly_write" on "published_models";
+
+drop policy if exists "smoodly_insert" on "published_models";
+create policy "smoodly_insert" on "published_models" for insert
+  with check ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_update" on "published_models";
+create policy "smoodly_update" on "published_models" for update
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write')
+  with check ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_delete" on "published_models";
+create policy "smoodly_delete" on "published_models" for delete
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_read" on "published_models";
+create policy "smoodly_read" on "published_models" for select
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+insert into "smoodly_meta" ("key", "value") values ('schema_version', '10')
+  on conflict ("key") do update set "value" = excluded."value";

package/migrations/20261009120000_smoodly_v11.sql

@@ -0,0 +1,49 @@
+-- Smoodly core schema, version 11 (DESIGN §3, static mode, decided 2026-10-09).
+-- Shipped in the smoodly package; `npx smoodly migrate` copies it into supabase/migrations/.
+-- Never edit a published file: the next change is the next file.
+-- The delta over version 10: space_deploys, one row per space holding the last
+-- Deploy press (static mode's button), so a serverless function can tell a
+-- build in flight from one that landed. Additive: no function changes.
+
+set client_min_messages = warning;
+
+-- The last Deploy press of a space (spec 2026-10-09 static mode §7): who pressed and when; the admin
+-- compares it with the build marker the live site serves to show building, landed or not landed.
+create table if not exists "space_deploys" (
+  "space_id" uuid primary key default '00000000-0000-0000-0000-000000000000',
+  -- Null until the first press: a removal may make the row first.
+  "requested_at" timestamptz,
+  "requested_by" text,
+  -- When a delivery row last went (an unpublish, a delete): a change the count of newer rows cannot see.
+  "removed_at" timestamptz
+);
+
+alter table "space_deploys" enable row level security;
+
+-- Stamped with the caller's space on insert, as every content table.
+drop trigger if exists "smoodly_a_set_space" on "space_deploys";
+create trigger "smoodly_a_set_space" before insert on "space_deploys"
+  for each row execute function "smoodly_set_space"();
+
+-- A write key reads and writes its own space's row; no other key reads (spec 2026-09-29 content API contract §8).
+drop policy if exists "smoodly_write" on "space_deploys";
+
+drop policy if exists "smoodly_insert" on "space_deploys";
+create policy "smoodly_insert" on "space_deploys" for insert
+  with check ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_update" on "space_deploys";
+create policy "smoodly_update" on "space_deploys" for update
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write')
+  with check ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_delete" on "space_deploys";
+create policy "smoodly_delete" on "space_deploys" for delete
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_read" on "space_deploys";
+create policy "smoodly_read" on "space_deploys" for select
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+insert into "smoodly_meta" ("key", "value") values ('schema_version', '11')
+  on conflict ("key") do update set "value" = excluded."value";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoodly",
-  "version": "0.0.46",
+  "version": "0.0.48",
   "description": "Open-source, code-first CMS for Astro and Next.js on Supabase: define a component once, it becomes a typed, editable building block.",
   "license": "MIT",
   "repository": {