smoodly 0.0.47 → 0.0.49

package/dist/published.js

@@ -50,6 +50,8 @@ export class MemoryPublishedStore {
         this.pages = new Map();
         this.entryRows = new Map();
         this.recorded = null;
+        this.deploy = null;
+        this.removedAt = null;
     }
     async recordedModel() {
         return this.recorded;
@@ -57,27 +59,53 @@ export class MemoryPublishedStore {
     async recordModel(model) {
         this.recorded = model;
     }
+    async newestPublishedAt() {
+        const all = [...this.pages.values(), ...this.entryRows.values()].map((r) => r.publishedAt);
+        return all.length === 0 ? null : Math.max(...all);
+    }
+    async countPublishedAfter(since) {
+        return [...this.pages.values(), ...this.entryRows.values()].filter((r) => r.publishedAt > since).length;
+    }
+    async deployRequest() {
+        return this.deploy;
+    }
+    async requestDeploy(by, at = Date.now()) {
+        this.deploy = { at, by };
+    }
     async countBehind(model) {
         const rows = [...this.pages.values(), ...this.entryRows.values()];
         return { behind: rows.filter((r) => r.model !== model).length, total: rows.length };
     }
-    async putPages(rows) {
+    async putPages(rows, options) {
         vacate(this.pages, rows);
-        for (const row of rows)
-            this.pages.set(keyOf(row.id, row.locale), structuredClone(row));
+        for (const row of rows) {
+            const kept = options?.keep ? this.pages.get(keyOf(row.id, row.locale))?.publishedAt : undefined;
+            this.pages.set(keyOf(row.id, row.locale), structuredClone(kept === undefined ? row : { ...row, publishedAt: kept }));
+        }
     }
-    async putEntries(rows) {
+    async putEntries(rows, options) {
         vacate(this.entryRows, rows);
-        for (const row of rows)
-            this.entryRows.set(keyOf(row.id, row.locale), structuredClone(row));
+        for (const row of rows) {
+            const kept = options?.keep ? this.entryRows.get(keyOf(row.id, row.locale))?.publishedAt : undefined;
+            this.entryRows.set(keyOf(row.id, row.locale), structuredClone(kept === undefined ? row : { ...row, publishedAt: kept }));
+        }
     }
     async remove(keys) {
+        let deleted = 0;
         for (const key of keys) {
             const map = key.kind === "page" ? this.pages : this.entryRows;
             for (const [k, row] of map)
-                if (row.id === key.id && (key.locale === undefined || row.locale === key.locale))
+                if (row.id === key.id && (key.locale === undefined || row.locale === key.locale)) {
                     map.delete(k);
+                    deleted += 1;
+                }
         }
+        // Only a row that went is a change (a key with no row is not): the Deploy tile counts it (spec 2026-10-09 §5).
+        if (deleted > 0)
+            this.removedAt = Date.now();
+    }
+    async lastRemovalAt() {
+        return this.removedAt;
     }
     async byAddress(locale, path, globals) {
         const found = () => {

package/dist/schema-version.d.ts

@@ -1,7 +1,7 @@
 /** The minimum schema version the package needs. Moves ONLY in a release
  *  that adds a table, column, function or policy the package reads; a
  *  unit test holds it equal to the highest file in `migrations/`. */
-export declare const SCHEMA_VERSION = 10;
+export declare const SCHEMA_VERSION = 11;
 export declare const SCHEMA_VERSION_KEY = "schema_version";
 export declare const CORE_FILE_RE: RegExp;
 export declare const VIEWS_FILE_RE: RegExp;

package/dist/schema-version.js

@@ -7,7 +7,7 @@
 /** The minimum schema version the package needs. Moves ONLY in a release
  *  that adds a table, column, function or policy the package reads; a
  *  unit test holds it equal to the highest file in `migrations/`. */
-export const SCHEMA_VERSION = 10;
+export const SCHEMA_VERSION = 11;
 export const SCHEMA_VERSION_KEY = "schema_version";
 export const CORE_FILE_RE = /^(\d{14})_smoodly_v(\d+)\.sql$/;
 export const VIEWS_FILE_RE = /^(\d{14})_smoodly_views\.sql$/;

package/dist/site.js

@@ -109,7 +109,7 @@ export function createSmoodlySite(options) {
                 return (await assembler.entries(collection, { ...o, locale, draft: false })).map(assembledEntry(collection, locale));
             // A failed rebuild never fails the read: the rows as read are served, and the next read tries again.
             try {
-                await projector.entries(behind, { cap: Infinity });
+                await projector.entries(behind, { cap: Infinity, stamp: false });
                 rows = await read();
             }
             catch (e) {
@@ -139,7 +139,7 @@ export function createSmoodlySite(options) {
                 // One batched projection for every row behind (one tree read in the projector), then one more tree read.
                 // A failed rebuild never fails the read: the rows as read are served, and the next read tries again.
                 try {
-                    await projector.pages(behind, { cap: Infinity });
+                    await projector.pages(behind, { cap: Infinity, stamp: false });
                     rows = await published().tree(locale);
                 }
                 catch (e) {

package/dist/sql-space.d.ts

@@ -9,8 +9,9 @@ export type ContentTable = (typeof CONTENT_TABLES)[number];
 /** The delivery model's derived tables (spec 2026-10-07 §1): policy-covered and
  *  space-stamped like content, but not transferred (export skips them, import
  *  rebuilds them) and not counted toward the row cap, since they are derived.
- *  `published_models` (schema v10) holds one row per space: the document stamp the space recorded as current. */
-export declare const DELIVERY_TABLES: readonly ["published_pages", "published_entries", "published_models"];
+ *  `published_models` (schema v10) holds one row per space: the document stamp the space recorded as current;
+ *  `space_deploys` (schema v11) one row per space: the last Deploy press of static mode. */
+export declare const DELIVERY_TABLES: readonly ["published_pages", "published_entries", "published_models", "space_deploys"];
 export declare function currentSpaceSQL(): string;
 /** One permissive policy per action (spec 2026-09-29 pre-install fixes §3):
  *  the write key's insert, update and delete, each alone for its action; its

package/dist/sql-space.js

@@ -22,8 +22,9 @@ export const CONTENT_TABLES = [
 /** The delivery model's derived tables (spec 2026-10-07 §1): policy-covered and
  *  space-stamped like content, but not transferred (export skips them, import
  *  rebuilds them) and not counted toward the row cap, since they are derived.
- *  `published_models` (schema v10) holds one row per space: the document stamp the space recorded as current. */
-export const DELIVERY_TABLES = ["published_pages", "published_entries", "published_models"];
+ *  `published_models` (schema v10) holds one row per space: the document stamp the space recorded as current;
+ *  `space_deploys` (schema v11) one row per space: the last Deploy press of static mode. */
+export const DELIVERY_TABLES = ["published_pages", "published_entries", "published_models", "space_deploys"];
 export function currentSpaceSQL() {
     return `
 -- The space a request acts in: the key's claim in Smoodly Cloud, the

package/dist/sql.js

@@ -181,9 +181,19 @@ create table if not exists "published_models" (
   "recorded_at" timestamptz not null default now()
 );
 
+-- The last Deploy press of a space (spec 2026-10-09 static mode §7, schema v11): who pressed and when;
+-- the admin compares it with the build marker the live site serves.
+create table if not exists "space_deploys" (
+  "space_id" uuid primary key default ${DEFAULT_SPACE},
+  "requested_at" timestamptz,
+  "requested_by" text,
+  "removed_at" timestamptz
+);
+
 alter table "published_pages" enable row level security;
 alter table "published_entries" enable row level security;
 alter table "published_models" enable row level security;
+alter table "space_deploys" enable row level security;
 
 -- smoodly_list_entries without the draft branch, over the delivery table (spec 2026-10-07 §3):
 -- \`where\` and \`order\` read the raw published snapshot, the row answers with its document.

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,7 @@ 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>;
@@ -30,6 +31,16 @@ export declare class SupabasePublishedStore implements PublishedStore {
         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,33 @@ 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. */
@@ -149,6 +176,46 @@ export class SupabasePublishedStore {
         ]);
         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) => {
             let q = this.db.from(table).update({ stale: true }).in(column, ids);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const SMOODLY_VERSION = "0.0.47";
+export declare const SMOODLY_VERSION = "0.0.49";

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.47";
+export const SMOODLY_VERSION = "0.0.49";

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.47",
+  "version": "0.0.49",
   "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": {