smoodly 0.0.14 → 0.0.16

package/dist/shared.d.ts

@@ -6,6 +6,14 @@ import type { BuilderMap, NamespaceValues, SectionSchema } from "./schema.ts";
 export declare const SHARED_NODE_TYPE = "shared";
 /** The reserved key a visual item's styles live under in the node's shared JSONB. */
 export declare const STYLES_KEY = "$styles";
+/** The node id a layout-rendered visual item carries (spec 2026-09-13 §1):
+ *  `getShared` stamps it into the styles, the section wrapper emits it,
+ *  the canvas selects by it. A placement keeps its own tree node id
+ *  (`shared-xxxxxxxx`, no colon). */
+export declare const SHARED_NODE_PREFIX = "shared:";
+export declare const sharedNodeId: (name: string) => string;
+/** The item a layout node id names, or null for any other id. */
+export declare function sharedNameOf(id: string): string | null;
 export type SharedSchema<V = Record<string, unknown>, N extends string = string> = CollectionSchema<any, N> & {
     kind: "shared";
     /** The registered section a visual item renders through; absent = an object item. */
@@ -31,7 +39,6 @@ export declare function sharedLink(node: {
 type SharedInput<N extends string = string> = {
     name: N;
     title: string;
-    versions?: boolean;
 };
 export declare function shared<F extends BuilderMap, const N extends string = string>(input: SharedInput<N> & {
     fields: F;

package/dist/shared.js

@@ -2,6 +2,16 @@
 export const SHARED_NODE_TYPE = "shared";
 /** The reserved key a visual item's styles live under in the node's shared JSONB. */
 export const STYLES_KEY = "$styles";
+/** The node id a layout-rendered visual item carries (spec 2026-09-13 §1):
+ *  `getShared` stamps it into the styles, the section wrapper emits it,
+ *  the canvas selects by it. A placement keeps its own tree node id
+ *  (`shared-xxxxxxxx`, no colon). */
+export const SHARED_NODE_PREFIX = "shared:";
+export const sharedNodeId = (name) => `${SHARED_NODE_PREFIX}${name}`;
+/** The item a layout node id names, or null for any other id. */
+export function sharedNameOf(id) {
+    return id.startsWith(SHARED_NODE_PREFIX) && id.length > SHARED_NODE_PREFIX.length ? id.slice(SHARED_NODE_PREFIX.length) : null;
+}
 /** The placement a tree node is, or null for any other node. Accepts a
  *  bare `{ type, fields }` shape or a full tree node — `id` (and any
  *  other tree-node property) is ignored. */
@@ -31,6 +41,5 @@ export function shared(input) {
         styles: input.section ? input.section.schema.styles : {},
         ...(input.section ? { section: input.section.schema.name } : {}),
         ...(input.section?.schema.sample ? { sample: input.section.schema.sample } : {}),
-        ...(input.versions ? { versions: true } : {}),
     };
 }

package/dist/site.d.ts

@@ -82,8 +82,10 @@ export type EntryQuery = {
     limit?: number;
     draft?: boolean;
 };
+/** `version`: a stored page version to render instead of the draft — History (spec 2026-09-13 §4), draft mode only. */
 export type LoadOptions = {
     draft?: boolean;
+    version?: string;
 };
 export interface SmoodlySite {
     readonly locales: LocaleSet;

package/dist/site.js

@@ -2,7 +2,7 @@ import { ARRAY_FIELD_TYPES, entryFieldsIn, localizedKeys, schemaOf } from "./ent
 import { buildPageTree, chainOf, entryPathRows, entrySegment, pagePath, } from "./paths.js";
 import { resolveFields, resolveMedia, resolveMediaSets, resolveTree } from "./resolve.js";
 import { elementSchemas } from "./richtext-walk.js";
-import { STYLES_KEY } from "./shared.js";
+import { sharedNodeId, STYLES_KEY } from "./shared.js";
 import { withDefaults } from "./field-defaults.js";
 /** The `page` prop for a loaded page. `toUrl` is the app's `href` seam
  *  bound to the render locale; the default keeps CMS paths as URLs. */
@@ -86,7 +86,7 @@ export function createSmoodlySite(options) {
         hasPage: hasPage(node, locale, draft),
         fields: fields.get(node.id) ?? {},
     });
-    async function loadPage(id, locale, path, draft) {
+    async function loadPage(id, locale, path, draft, version) {
         const { pages } = options.stores();
         const record = await pages.getPage(id);
         if (!record || record.template === null)
@@ -94,7 +94,15 @@ export function createSmoodlySite(options) {
         const row = record.locales[locale];
         if (!row)
             return null;
-        const raw = draft ? await pages.getDraftTree(id, locale) : row.status === "published" ? await pages.getPublishedTree(id, locale) : null;
+        let raw;
+        if (version !== undefined) {
+            // History: a stored version of THIS page in THIS locale, and only inside draft mode.
+            const stored = draft ? await pages.getVersion(version) : null;
+            raw = stored && stored.pageId === id && stored.locale === locale ? stored.tree : null;
+        }
+        else {
+            raw = draft ? await pages.getDraftTree(id, locale) : row.status === "published" ? await pages.getPublishedTree(id, locale) : null;
+        }
         if (!raw)
             return null;
         const tree = await resolveTree(raw, {
@@ -279,9 +287,11 @@ export function createSmoodlySite(options) {
                 return fields;
             const { [STYLES_KEY]: styles, ...rest } = fields;
             const fetch = assetFetcher();
-            if (fetch && styles && typeof styles === "object")
-                await resolveMedia(styles, sectionStyles(item.section), fetch, elements);
-            return { ...rest, styles: styles !== null && typeof styles === "object" ? styles : {} };
+            const own = styles !== null && typeof styles === "object" ? styles : {};
+            if (fetch)
+                await resolveMedia(own, sectionStyles(item.section), fetch, elements);
+            // The layout node id rides the styles: the wrapper strips it and emits data-smd-node (spec 2026-09-13 §1).
+            return { ...rest, styles: { ...own, __smoodlyNode: sharedNodeId(item.name) } };
         },
     };
     const site = {
@@ -290,7 +300,7 @@ export function createSmoodlySite(options) {
         locate: (locale, path) => options.stores().pages.resolvePath(locale, path),
         load(target, locale, path, opts = {}) {
             const draft = opts.draft ?? false;
-            return target.kind === "page" ? loadPage(target.id, locale, path, draft) : loadEntry(target.id, locale, path, draft);
+            return target.kind === "page" ? loadPage(target.id, locale, path, draft, opts.version) : loadEntry(target.id, locale, path, draft);
         },
         async resolve(locale, path, opts) {
             const target = await site.locate(locale, path);

package/dist/sql.js

@@ -36,16 +36,16 @@ function fieldExpr(key, d, source) {
 }
 export function collectionSQL(collection) {
     const name = collection.name;
-    const versioned = collection.versions === true;
-    // Where a field's value lives: a versioned collection's view reads the
-    // published snapshot (merged at publish time); otherwise shared fields
-    // come from the node and localized ones from the locale row.
-    const sourceOf = (d) => (versioned ? 'v."fields"' : d.localized === true ? 'l."fields"' : 'e."fields"');
+    // Every collection is versioned (spec 2026-09-14 §1): a field's value is the published
+    // snapshot's, falling back to the live row (the node's shared fields under the locale
+    // row's localized ones) for a published row from before versioning that nobody has
+    // written since — the store gives it a snapshot on its first write.
+    const source = `coalesce(v."fields", e."fields" || l."fields")`;
     const columns = ['e."id"', 'l."locale"', 'l."slug"', 'e."sort"', 'e."created_at"', 'l."updated_at"'];
     for (const [key, d] of Object.entries(collection.fields)) {
         if (key === "slug")
             continue; // the segment is the row's column, never a field
-        columns.push(`${fieldExpr(key, d, sourceOf(d))} as ${q(snake(key))}`);
+        columns.push(`${fieldExpr(key, d, source)} as ${q(snake(key))}`);
     }
     const statements = [
         [
@@ -54,7 +54,7 @@ export function collectionSQL(collection) {
             columns.map((c) => "  " + c).join(",\n"),
             `from "entries" e`,
             `join "entry_locales" l on l."entry_id" = e."id"`,
-            ...(versioned ? [`join "entry_versions" v on v."id" = l."published_version_id"`] : []),
+            `left join "entry_versions" v on v."id" = l."published_version_id"`,
             `where e."collection" = '${name}' and l."status" = 'published';`,
         ].join("\n"),
     ];
@@ -106,6 +106,7 @@ create table if not exists "page_locales" (
   "draft_version_id" uuid,
   "published_version_id" uuid,
   "updated_at" timestamptz not null default now(),
+  "updated_by" text,
   primary key ("page_id", "locale")
 );
 
@@ -118,19 +119,20 @@ create or replace function "smoodly_reorder_pages"(p_ids uuid[]) returns void la
 $$;
 
 -- A version belongs to ONE locale of one page: each locale has its own
--- draft, its own publish and its own history.
+-- draft, its own publish and its own history. One row per publish plus
+-- the live draft (spec 2026-09-13 history §1): the unpublished draft row
+-- is rewritten in place and saved_at is when its content last changed.
 create table if not exists "page_versions" (
   "id" uuid primary key default gen_random_uuid(),
   ${SPACE_COL},
   "page_id" uuid not null references "pages" ("id") on delete cascade,
   "locale" text not null,
   "tree" jsonb not null,
-  "created_by" text,
-  "created_at" timestamptz not null default now()
+  "saved_at" timestamptz not null default now()
 );
 
 create index if not exists "page_versions_page_locale_idx"
-  on "page_versions" ("page_id", "locale", "created_at");
+  on "page_versions" ("page_id", "locale", "saved_at");
 
 create table if not exists "entries" (
   "id" uuid primary key default gen_random_uuid(),
@@ -167,6 +169,7 @@ create table if not exists "entry_locales" (
   "draft_version_id" uuid,
   "published_version_id" uuid,
   "updated_at" timestamptz not null default now(),
+  "updated_by" text,
   primary key ("entry_id", "locale")
 );
 
@@ -176,19 +179,19 @@ create index if not exists "entry_locales_status_idx"
 -- A version belongs to ONE locale of one entry and stores the MERGED
 -- fields (shared + localized + slug) as they were at that save, so
 -- restoring an old Finnish version restores the shared fields too.
--- Rows exist only for collections registered with \`versions: true\`.
+-- Rows for every collection and every shared item (spec 2026-09-14 §1).
+-- One row per publish plus the live draft (spec 2026-09-13 history §1).
 create table if not exists "entry_versions" (
   "id" uuid primary key default gen_random_uuid(),
   ${SPACE_COL},
   "entry_id" uuid not null references "entries" ("id") on delete cascade,
   "locale" text not null,
   "fields" jsonb not null,
-  "created_by" text,
-  "created_at" timestamptz not null default now()
+  "saved_at" timestamptz not null default now()
 );
 
 create index if not exists "entry_versions_entry_locale_idx"
-  on "entry_versions" ("entry_id", "locale", "created_at");
+  on "entry_versions" ("entry_id", "locale", "saved_at");
 
 -- v1 reorder (DESIGN.md §3 Manual ordering): rewrite sort 1..N in ONE
 -- statement. Deliberately does not touch updated_at — a drag must not

package/dist/store.d.ts

@@ -11,6 +11,9 @@ export type PageLocale = {
     status: "draft" | "published";
     draftVersionId: string | null;
     publishedVersionId: string | null;
+    updatedAt: number;
+    /** The editor's email behind the last write that touched this row; null for the seed and scripts (spec 2026-09-13 history §2). */
+    updatedBy: string | null;
 };
 export type PageRecord = {
     id: string;
@@ -37,22 +40,23 @@ export type AddLocaleOptions = {
     slug?: string;
     title?: string;
 };
+/** `savedAt` is when the content last changed: the unpublished draft row is rewritten in place (spec 2026-09-13 history §1). */
 export type PageVersion = {
     id: string;
     pageId: string;
     locale: string;
     tree: PageTree;
-    createdAt: number;
+    savedAt: number;
 };
 export interface PageStore {
-    createPage(input: CreatePageInput): Promise<PageRecord>;
+    createPage(input: CreatePageInput, by?: string): Promise<PageRecord>;
     getPage(id: string): Promise<PageRecord | null>;
     listPages(): Promise<PageRecord[]>;
     resolvePath(locale: string, path: string): Promise<PathTarget | null>;
     /** locale → path, for the locales the page exists in. */
     pathsOf(id: string): Promise<Record<string, string>>;
     /** Refused when the page already has the locale or its parent lacks it (the parent rule). */
-    addLocale(id: string, locale: string, options: AddLocaleOptions): Promise<PageRecord>;
+    addLocale(id: string, locale: string, options: AddLocaleOptions, by?: string): Promise<PageRecord>;
     /** Deletes the row, its versions and its paths. Refused while a
      *  descendant has the locale, and for the page's last locale. */
     removeLocale(id: string, locale: string): Promise<PageRecord>;
@@ -60,7 +64,7 @@ export interface PageStore {
         locale: string;
         slug?: string;
         title?: string;
-    }): Promise<PageRecord>;
+    }, by?: string): Promise<PageRecord>;
     /**
      * Reparents `id` under `to.parentId`. `to.index` is the moved node's
      * final 0-based position among the destination siblings: the node is
@@ -73,9 +77,21 @@ export interface PageStore {
         index?: number;
     }): Promise<PageRecord>;
     /** A folder becomes a page: an empty draft version per present locale. */
-    setTemplate(id: string, template: string): Promise<PageRecord>;
-    saveDraft(id: string, locale: string, tree: PageTree): Promise<PageVersion>;
-    publish(id: string, locale: string): Promise<PageRecord>;
+    setTemplate(id: string, template: string, by?: string): Promise<PageRecord>;
+    saveDraft(id: string, locale: string, tree: PageTree, by?: string): Promise<PageVersion>;
+    publish(id: string, locale: string, by?: string): Promise<PageRecord>;
+    /** The draft goes back to what is live: the locale's draft pointer set to its
+     *  published pointer and the abandoned draft row deleted (spec 2026-09-13 history §1).
+     *  Refused when nothing is published in the locale (spec 2026-09-13 publish flow §4). */
+    discardDraft(id: string, locale: string, by?: string): Promise<PageRecord>;
+    /** Takes ONE locale off the site: status draft, both pointers kept so a later
+     *  publish republishes the current draft (spec §5). */
+    unpublish(id: string, locale: string, by?: string): Promise<PageRecord>;
+    /** The version's tree becomes the draft through the draft rule (spec 2026-09-13 history §6); the
+     *  published version restores as a discard. Refused when the version is not this page's in this locale. */
+    restore(id: string, locale: string, versionId: string, by?: string): Promise<PageRecord>;
+    /** One stored version by id, whoever it belongs to — callers check `pageId` and `locale`. */
+    getVersion(versionId: string): Promise<PageVersion | null>;
     getDraftTree(id: string, locale: string): Promise<PageTree | null>;
     getPublishedTree(id: string, locale: string): Promise<PageTree | null>;
     /** The page fields of many versions in ONE read (spec 2026-09-10 page fields §3):
@@ -110,6 +126,7 @@ export declare const pageErrors: {
     notFound: (id: string) => Error;
     slugTaken: (slug: string) => Error;
     folder: (id: string) => Error;
+    nothingPublished: (id: string, locale: string) => Error;
     hasTemplate: (id: string) => Error;
     homeChildren: () => Error;
     cycle: () => Error;
@@ -121,6 +138,7 @@ export declare const pageErrors: {
     lastLocale: (id: string) => Error;
     localeInUse: (locale: string, titles: string[]) => Error;
     moveLocales: (locale: string) => Error;
+    foreignVersion: (id: string, locale: string, versionId: string) => Error;
 };
 export { assertSupportedLocale } from "./paths.ts";
 /** The page's row for a locale — the "does not exist in locale" guard every per-locale write runs. */
@@ -161,26 +179,33 @@ export declare class MemoryPageStore implements PageStore {
     private liveTrees;
     private writeRefs;
     private newVersion;
+    /** The draft rule (spec 2026-09-13 history §1): the unpublished draft row is
+     *  rewritten in place; a new row starts only when the draft IS the published one. */
+    private writeDraftVersion;
     private dropVersions;
-    createPage(input: CreatePageInput): Promise<PageRecord>;
+    createPage(input: CreatePageInput, by?: string): Promise<PageRecord>;
     getPage(id: string): Promise<PageRecord | null>;
     listPages(): Promise<PageRecord[]>;
     resolvePath(locale: string, path: string): Promise<PathTarget | null>;
     pathsOf(id: string): Promise<Record<string, string>>;
-    addLocale(id: string, locale: string, options: AddLocaleOptions): Promise<PageRecord>;
+    addLocale(id: string, locale: string, options: AddLocaleOptions, by?: string): Promise<PageRecord>;
     removeLocale(id: string, locale: string): Promise<PageRecord>;
     rename(id: string, patch: {
         locale: string;
         slug?: string;
         title?: string;
-    }): Promise<PageRecord>;
+    }, by?: string): Promise<PageRecord>;
     move(id: string, to: {
         parentId: string | null;
         index?: number;
     }): Promise<PageRecord>;
-    setTemplate(id: string, template: string): Promise<PageRecord>;
-    saveDraft(id: string, locale: string, tree: PageTree): Promise<PageVersion>;
-    publish(id: string, locale: string): Promise<PageRecord>;
+    setTemplate(id: string, template: string, by?: string): Promise<PageRecord>;
+    saveDraft(id: string, locale: string, tree: PageTree, by?: string): Promise<PageVersion>;
+    publish(id: string, locale: string, by?: string): Promise<PageRecord>;
+    discardDraft(id: string, locale: string, by?: string): Promise<PageRecord>;
+    unpublish(id: string, locale: string, by?: string): Promise<PageRecord>;
+    restore(id: string, locale: string, versionId: string, by?: string): Promise<PageRecord>;
+    getVersion(versionId: string): Promise<PageVersion | null>;
     getDraftTree(id: string, locale: string): Promise<PageTree | null>;
     fieldsOf(versionIds: string[]): Promise<Record<string, Record<string, unknown>>>;
     getPublishedTree(id: string, locale: string): Promise<PageTree | null>;

package/dist/store.js

@@ -27,6 +27,7 @@ export const pageErrors = {
     notFound: (id) => new Error(`smoodly: no page "${id}".`),
     slugTaken: (slug) => new Error(`smoodly: a page with slug "${slug}" already exists under this parent.`),
     folder: (id) => new Error(`smoodly: "${id}" is a folder — give it a template first.`),
+    nothingPublished: (id, locale) => new Error(`smoodly: page "${id}" has nothing published in locale "${locale}" — there is no version to restore.`),
     hasTemplate: (id) => new Error(`smoodly: "${id}" already has a template.`),
     homeChildren: () => new Error("smoodly: the home page cannot have child pages."),
     cycle: () => new Error("smoodly: a page cannot be moved under itself."),
@@ -38,6 +39,7 @@ export const pageErrors = {
     lastLocale: (id) => new Error(`smoodly: page "${id}" must exist in at least one locale — delete the page instead.`),
     localeInUse: (locale, titles) => new Error(`smoodly: child pages still exist in locale "${locale}" — remove it from ${titles.map((t) => `"${t}"`).join(", ")} first.`),
     moveLocales: (locale) => new Error(`smoodly: the destination parent does not exist in locale "${locale}" — the page cannot move under it.`),
+    foreignVersion: (id, locale, versionId) => new Error(`smoodly: "${versionId}" is not a version of page "${id}" in locale "${locale}".`),
 };
 export { assertSupportedLocale } from "./paths.js";
 /** The page's row for a locale — the "does not exist in locale" guard every per-locale write runs. */
@@ -83,6 +85,11 @@ export async function assertPublishable(label, tree, sections, entries, locale)
 }
 let counter = 0;
 const uid = () => `id-${++counter}-${Date.now().toString(36)}`;
+/** The row's audit pair: every write that touches a locale row sets both (spec 2026-09-13 history §2). */
+function touchRow(row, by) {
+    row.updatedAt = Date.now();
+    row.updatedBy = by ?? null;
+}
 export class MemoryPageStore {
     constructor(options = {}) {
         this.options = options;
@@ -165,17 +172,35 @@ export class MemoryPageStore {
         refs.rewrite({ sourceKind: "page", sourceId: page.id }, pageRefEdges(this.liveTrees(page), sections, elements));
     }
     newVersion(pageId, locale, tree) {
-        const version = { id: uid(), pageId, locale, tree: structuredClone(tree), createdAt: Date.now() };
+        const version = { id: uid(), pageId, locale, tree: structuredClone(tree), savedAt: Date.now() };
         this.versions.set(version.id, version);
         return version;
     }
+    /** The draft rule (spec 2026-09-13 history §1): the unpublished draft row is
+     *  rewritten in place; a new row starts only when the draft IS the published one. */
+    writeDraftVersion(page, locale, tree, by) {
+        const row = localeRow(page, locale);
+        const current = row.draftVersionId ? this.versions.get(row.draftVersionId) : undefined;
+        let version;
+        if (current && row.draftVersionId !== row.publishedVersionId) {
+            current.tree = structuredClone(tree);
+            current.savedAt = Date.now();
+            version = current;
+        }
+        else {
+            version = this.newVersion(page.id, locale, tree);
+            row.draftVersionId = version.id;
+        }
+        touchRow(row, by);
+        return version;
+    }
     dropVersions(pageId, locale) {
         for (const [vid, v] of this.versions) {
             if (v.pageId === pageId && (locale === undefined || v.locale === locale))
                 this.versions.delete(vid);
         }
     }
-    async createPage(input) {
+    async createPage(input, by) {
         assertSupportedLocale(input.locale, this.opts.locales);
         assertSegment(input.slug, "page slug");
         const parentId = input.parentId ?? null;
@@ -204,6 +229,8 @@ export class MemoryPageStore {
                     status: "draft",
                     draftVersionId: version?.id ?? null,
                     publishedVersionId: null,
+                    updatedAt: Date.now(),
+                    updatedBy: by ?? null,
                 },
             },
         };
@@ -236,7 +263,7 @@ export class MemoryPageStore {
     pathsOf(id) {
         return this.paths.pathsOf({ kind: "page", id });
     }
-    async addLocale(id, locale, options) {
+    async addLocale(id, locale, options, by) {
         assertSupportedLocale(locale, this.opts.locales);
         const page = this.must(id);
         if (page.locales[locale])
@@ -259,6 +286,8 @@ export class MemoryPageStore {
             status: "draft",
             draftVersionId: version?.id ?? null,
             publishedVersionId: null,
+            updatedAt: Date.now(),
+            updatedBy: by ?? null,
         };
         try {
             await this.writePaths([page]);
@@ -294,7 +323,7 @@ export class MemoryPageStore {
         this.writeRefs(page);
         return this.snapshot(page);
     }
-    async rename(id, patch) {
+    async rename(id, patch, by) {
         const page = this.must(id);
         const row = localeRow(page, patch.locale);
         if (patch.slug !== undefined)
@@ -323,6 +352,7 @@ export class MemoryPageStore {
             Object.assign(row, before);
             throw e;
         }
+        touchRow(row, by);
         return this.snapshot(page);
     }
     async move(id, to) {
@@ -369,26 +399,26 @@ export class MemoryPageStore {
         }
         return this.snapshot(page);
     }
-    async setTemplate(id, template) {
+    async setTemplate(id, template, by) {
         const page = this.must(id);
         if (page.template !== null)
             throw pageErrors.hasTemplate(id);
         page.template = template;
-        for (const [locale, row] of Object.entries(page.locales))
+        for (const [locale, row] of Object.entries(page.locales)) {
             row.draftVersionId = this.newVersion(id, locale, { zones: {} }).id;
+            touchRow(row, by);
+        }
         return this.snapshot(page);
     }
-    async saveDraft(id, locale, tree) {
+    async saveDraft(id, locale, tree, by) {
         const page = this.must(id);
         if (page.template === null)
             throw pageErrors.folder(id);
-        const row = localeRow(page, locale);
-        const version = this.newVersion(id, locale, tree);
-        row.draftVersionId = version.id;
+        const version = this.writeDraftVersion(page, locale, tree, by);
         this.writeRefs(page);
         return { ...version, tree: structuredClone(version.tree) };
     }
-    async publish(id, locale) {
+    async publish(id, locale, by) {
         const page = this.must(id);
         if (page.template === null)
             throw pageErrors.folder(id);
@@ -401,9 +431,49 @@ export class MemoryPageStore {
             await assertPublishable(row.slug, draft, sections, entries, locale);
         row.publishedVersionId = row.draftVersionId;
         row.status = "published";
+        touchRow(row, by);
         this.writeRefs(page);
         return this.snapshot(page);
     }
+    async discardDraft(id, locale, by) {
+        const page = this.must(id);
+        const row = localeRow(page, locale);
+        if (!row.publishedVersionId)
+            throw pageErrors.nothingPublished(id, locale);
+        const abandoned = row.draftVersionId;
+        row.draftVersionId = row.publishedVersionId;
+        if (abandoned && abandoned !== row.publishedVersionId)
+            this.versions.delete(abandoned); // never shown as a stray draft
+        touchRow(row, by);
+        this.writeRefs(page); // the refs union (draft ∪ published) just shrank to one tree
+        return this.snapshot(page);
+    }
+    async unpublish(id, locale, by) {
+        const page = this.must(id);
+        const row = localeRow(page, locale);
+        row.status = "draft";
+        touchRow(row, by);
+        this.writeRefs(page);
+        return this.snapshot(page);
+    }
+    async restore(id, locale, versionId, by) {
+        const page = this.must(id);
+        if (page.template === null)
+            throw pageErrors.folder(id);
+        const row = localeRow(page, locale);
+        const version = this.versions.get(versionId);
+        if (!version || version.pageId !== id || version.locale !== locale)
+            throw pageErrors.foreignVersion(id, locale, versionId);
+        if (versionId === row.publishedVersionId)
+            return this.discardDraft(id, locale, by);
+        this.writeDraftVersion(page, locale, version.tree, by);
+        this.writeRefs(page);
+        return this.snapshot(page);
+    }
+    async getVersion(versionId) {
+        const v = this.versions.get(versionId);
+        return v ? { ...v, tree: structuredClone(v.tree) } : null;
+    }
     async getDraftTree(id, locale) {
         const row = this.pages.get(id)?.locales[locale];
         if (!row?.draftVersionId)
@@ -428,7 +498,7 @@ export class MemoryPageStore {
     async listVersions(id, locale) {
         return [...this.versions.values()]
             .filter((v) => v.pageId === id && v.locale === locale)
-            .sort((a, b) => b.createdAt - a.createdAt || b.id.localeCompare(a.id))
+            .sort((a, b) => b.savedAt - a.savedAt || b.id.localeCompare(a.id))
             .map((v) => ({ ...v, tree: structuredClone(v.tree) }));
     }
     async deletePage(id) {

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

@@ -37,23 +37,28 @@ export declare class SupabaseEntryStore implements EntryStore {
     private assertParentHasLocale;
     private updateNode;
     private insertLocale;
+    /** A touch writes the audit pair — `updated_at` and `updated_by` (spec 2026-09-13 history §2). */
     private updateLocale;
     /** The row goes first (it is what makes the entry exist in the locale), then its versions. */
     private deleteLocale;
-    /** A versioned collection snapshots the merged fields and points the
-     *  locale's draft at the new row; others do nothing here. */
+    /** The draft rule for every collection (spec 2026-09-14 §1), see MemoryEntryStore.recordVersion. */
     private recordVersion;
-    create(collection: string, fields: Record<string, unknown>, options: CreateEntryOptions): Promise<EntryRecord>;
+    /** See MemoryEntryStore.ensureLiveSnapshot: the snapshot of what is live, both pointers on it. */
+    private ensureLiveSnapshot;
+    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[]>;
     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>): Promise<EntryRecord>;
-    setStatus(collection: string, id: string, locale: string, status: "draft" | "published"): Promise<EntryRecord>;
-    addLocale(collection: string, id: string, locale: string, options: AddEntryLocaleOptions): Promise<EntryRecord>;
+    update(collection: string, id: string, locale: string, fields: Record<string, unknown>, by?: string): Promise<EntryRecord>;
+    setStatus(collection: string, id: string, locale: string, status: "draft" | "published", by?: string): Promise<EntryRecord>;
+    discardDraft(collection: string, id: string, locale: string, by?: string): Promise<EntryRecord>;
+    addLocale(collection: string, id: string, locale: string, options: AddEntryLocaleOptions, by?: string): Promise<EntryRecord>;
     removeLocale(collection: string, id: string, locale: string): Promise<EntryRecord>;
     listVersions(collection: string, id: string, locale: string): Promise<EntryVersion[]>;
+    restore(collection: string, id: string, locale: string, versionId: string, by?: string): Promise<EntryRecord>;
+    getVersion(collection: string, versionId: string): Promise<EntryVersion | null>;
     move(collection: string, id: string, to: {
         parentId: string | null;
         index?: number;