smoodly 0.0.24 → 0.0.26

package/dist/admin/validate.d.ts

@@ -22,6 +22,10 @@ export type ElementDescs = Record<string, {
     fields: Record<string, Desc>;
     settings?: Record<string, Desc>;
 }>;
+/** The errors of `previous` that a fresh validation still reports, with the
+ *  fresh message: a form's refusal list shrinks as its fields are fixed and
+ *  never grows from typing (2026-09-25) — only a publish adds. */
+export declare function stillFailing(previous: Record<string, string>, fresh: FieldError[]): Record<string, string>;
 /** Validate one value map. Without `scope.fields` the values ARE the fields (an entry, a page, an object global). */
 export declare function validateFields(values: Record<string, unknown>, descriptors: Record<string, Desc>, elements?: ElementDescs, scope?: ValidationScope): FieldError[];
 /** A tree node (or a visual global, in node shape) against its schema: fields, settings (prefixed), css (spec 2026-09-14 §3, §4). */

package/dist/admin/validate.js

@@ -12,14 +12,21 @@ import { normalizeTag, sameTag } from "../tags.js";
 import { hasContent } from "./richtext-doc.js";
 import { ELEMENT_NODE, richtextBlocks } from "../richtext-walk.js";
 import { rowsProblems } from "../custom/rows.js";
+import { isCalendarDay, isInstant } from "./forms/date-picker.js";
 const subfields = (d) => d.fields && typeof d.fields === "object" ? d.fields : {};
 const itemOf = (d) => d.item && typeof d.item === "object" ? d.item : undefined;
 const isEmpty = (v) => v === undefined || v === null || v === "" || (Array.isArray(v) && v.length === 0);
+/** An object holding nothing but empty values, at any depth — `{}`, `{ label: "" }`. */
+const isBlankObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v) &&
+    Object.values(v).every((x) => isEmpty(x) || isBlankObject(x));
 /** An object whose every subfield is optional — or is itself an object that
  *  may be absent — may be absent altogether. */
 const mayBeAbsent = (d) => d.optional === true || d.type === "boolean" || (d.type === "object" && Object.values(subfields(d)).every(mayBeAbsent));
 const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
 function validateValue(path, value, d, errors, elements, scope) {
+    // An optional object with nothing filled in is absent (drafts inserted before 2026-09-26 carry `{}`).
+    if (d.type === "object" && d.optional === true && isBlankObject(value))
+        return;
     if (isEmpty(value)) {
         if (!mayBeAbsent(d))
             errors.push({ field: path, message: "Required." });
@@ -49,6 +56,17 @@ function validateValue(path, value, d, errors, elements, scope) {
         }
         return;
     }
+    // Dates (spec 2026-09-25 date pickers §2): the stored formats exactly, and a day the calendar has.
+    if (d.type === "date") {
+        if (typeof value !== "string" || !isCalendarDay(value))
+            errors.push({ field: path, message: "Not a date (2026-09-02)." });
+        return;
+    }
+    if (d.type === "datetime") {
+        if (typeof value !== "string" || !isInstant(value))
+            errors.push({ field: path, message: "Not a date and time." });
+        return;
+    }
     if (d.type === "image" || d.type === "video" || d.type === "file") {
         if (typeof value !== "object" || Array.isArray(value) || typeof value.asset !== "string") {
             errors.push({ field: path, message: "Must be an uploaded file." });
@@ -151,6 +169,16 @@ function validateMap(prefix, values, descriptors, errors, elements, scope) {
         validateValue(prefix === "" ? key : `${prefix}.${key}`, values[key], d, errors, elements, scope);
     }
 }
+/** The errors of `previous` that a fresh validation still reports, with the
+ *  fresh message: a form's refusal list shrinks as its fields are fixed and
+ *  never grows from typing (2026-09-25) — only a publish adds. */
+export function stillFailing(previous, fresh) {
+    const out = {};
+    for (const e of fresh)
+        if (e.field in previous)
+            out[e.field] = e.message;
+    return out;
+}
 /** Validate one value map. Without `scope.fields` the values ARE the fields (an entry, a page, an object global). */
 export function validateFields(values, descriptors, elements = {}, scope = {}) {
     const errors = [];

package/dist/cli/load-collections.d.ts

@@ -0,0 +1,2 @@
+import type { CollectionSchema } from "../collections.ts";
+export declare function loadCollections(file: string, cwd: string): Promise<CollectionSchema<any>[]>;

package/dist/cli/load-collections.js

@@ -0,0 +1,26 @@
+// packages/smoodly/src/cli/load-collections.ts
+// Loads the app's `smoodly/collections.ts` — TypeScript, through tsx's
+// import API, under the app's own tsconfig so its `@/` alias resolves.
+// The barrel and not `smoodly/config.ts`: the config imports the page
+// shapes and with them React and Next, which a command line has no use
+// for; the barrel is what the config registers in both starters.
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { tsImport } from "tsx/esm/api";
+export async function loadCollections(file, cwd) {
+    if (!existsSync(file)) {
+        throw new Error(`smoodly: ${file} does not exist — pass --collections <file> for the module that exports \`collections\`.`);
+    }
+    const tsconfig = join(cwd, "tsconfig.json");
+    const mod = (await tsImport(pathToFileURL(file).href, {
+        parentURL: import.meta.url,
+        ...(existsSync(tsconfig) ? { tsconfig } : {}),
+    }));
+    const list = mod.collections;
+    const isCollection = (c) => typeof c === "object" && c !== null && typeof c.name === "string";
+    if (!Array.isArray(list) || !list.every(isCollection)) {
+        throw new Error(`smoodly: ${file} must export \`collections\`, the list of smoodly.collection() definitions the config registers.`);
+    }
+    return list;
+}

package/dist/cli/main.d.ts

@@ -0,0 +1,13 @@
+import { type MigrateArgs } from "./migrate.ts";
+export declare const USAGE = "usage: smoodly migrate [--check] [--collections <file>] [--migrations <dir>]\n\n  Copies the core schema files this package ships that supabase/migrations/\n  lacks, and writes one views file for the collections whose view is new or\n  changed. Prints the push or reset command; never runs it.\n\n  --check              write nothing; exit 1 when anything is pending\n  --collections <file> the module exporting `collections` (default smoodly/collections.ts)\n  --migrations <dir>   the app's migration folder (default supabase/migrations)";
+export type Parsed = {
+    command: "migrate";
+    args: MigrateArgs;
+} | {
+    command: "help";
+} | {
+    command: "error";
+    message: string;
+};
+export declare function parseArgs(argv: string[]): Parsed;
+export declare function main(argv: string[], out?: (line: string) => void): Promise<number>;

package/dist/cli/main.js

@@ -0,0 +1,62 @@
+// packages/smoodly/src/cli/main.ts
+// `smoodly` — the package's command line (spec 2026-09-26 §2). One
+// subcommand for now; `check`, `export` and the drift report land here
+// later. Exit codes: 0 done or nothing to do, 1 pending (--check) or a
+// refused file, 2 usage.
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runMigrate } from "./migrate.js";
+export const USAGE = `usage: smoodly 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
+  --collections <file> the module exporting \`collections\` (default smoodly/collections.ts)
+  --migrations <dir>   the app's migration folder (default supabase/migrations)`;
+export function parseArgs(argv) {
+    const [command, ...rest] = argv;
+    if (!command || command === "--help" || command === "-h" || command === "help")
+        return { command: "help" };
+    if (command !== "migrate")
+        return { command: "error", message: `unknown command "${command}"` };
+    const args = { check: false, collections: "smoodly/collections.ts", 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 };
+}
+export async function main(argv, out = console.log) {
+    const parsed = parseArgs(argv);
+    if (parsed.command === "help") {
+        out(USAGE);
+        return 0;
+    }
+    if (parsed.command === "error") {
+        out(`smoodly: ${parsed.message}\n\n${USAGE}`);
+        return 2;
+    }
+    try {
+        return await runMigrate(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.
+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/migrate.d.ts

@@ -0,0 +1,23 @@
+import type { CollectionSchema } from "../collections.ts";
+import { type MigrationFile, type MigratePlan } from "../migrations.ts";
+export type MigrateArgs = {
+    check: boolean;
+    collections: string;
+    migrations: string;
+};
+/** The folder shipped in the package: `../../migrations/` from dist/cli/ and from src/cli/ alike. */
+export declare const PACKAGE_MIGRATIONS_DIR: string;
+export declare const NO_FOLDER = "No supabase/migrations folder here \u2014 nothing to do. (Smoodly Cloud keeps the schema current; a self-host app gets the folder from `supabase init`.)";
+export declare const NEXT_STEP = "Next: apply it \u2014 `supabase db push` (hosted) or `supabase db reset` (local).";
+export declare const upToDate: (version: number, n: number) => string;
+export declare const modifiedMessage: (name: string) => string;
+export declare function readSqlFiles(dir: string): Promise<MigrationFile[]>;
+/** One line per thing the plan does; "Pending" wording under --check. */
+export declare function describePlan(plan: MigratePlan, check: boolean): string[];
+export type MigrateDeps = {
+    cwd?: string;
+    /** Test seam: replaces the tsx loader. */
+    load?: (file: string, cwd: string) => Promise<CollectionSchema<any>[]>;
+    now?: () => Date;
+};
+export declare function runMigrate(args: MigrateArgs, out: (line: string) => void, deps?: MigrateDeps): Promise<number>;

package/dist/cli/migrate.js

@@ -0,0 +1,64 @@
+// packages/smoodly/src/cli/migrate.ts
+// The filesystem half of `smoodly migrate` (spec 2026-09-26 §2): reads
+// the package's migrations/ and the app's supabase/migrations/, loads the
+// app's collections, asks the pure planner (../migrations.ts) what to
+// write, writes it. The message strings are what the docs quote.
+import { existsSync } from "node:fs";
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { collectionSQL } from "../sql.js";
+import { coreFileVersion, SCHEMA_VERSION } from "../schema-version.js";
+import { planIsEmpty, planMigrate } from "../migrations.js";
+import { loadCollections } from "./load-collections.js";
+/** The folder shipped in the package: `../../migrations/` from dist/cli/ and from src/cli/ alike. */
+export const PACKAGE_MIGRATIONS_DIR = fileURLToPath(new URL("../../migrations/", import.meta.url));
+export const NO_FOLDER = "No supabase/migrations folder here — nothing to do. (Smoodly Cloud keeps the schema current; a self-host app gets the folder from `supabase init`.)";
+export const NEXT_STEP = "Next: apply it — `supabase db push` (hosted) or `supabase db reset` (local).";
+export const upToDate = (version, n) => `Up to date: core schema v${version}, every collection's view is current (${n} ${n === 1 ? "collection" : "collections"}).`;
+export const modifiedMessage = (name) => `Refusing: ${name} differs from the package's copy. A published migration is never edited — restore it from the package, or move your change to a new file.`;
+export async function readSqlFiles(dir) {
+    const names = (await readdir(dir)).filter((n) => n.endsWith(".sql")).sort();
+    return Promise.all(names.map(async (name) => ({ name, text: await readFile(join(dir, name), "utf8") })));
+}
+/** One line per thing the plan does; "Pending" wording under --check. */
+export function describePlan(plan, check) {
+    const lines = [];
+    for (const name of plan.modified)
+        lines.push(modifiedMessage(name));
+    for (const f of plan.copy)
+        lines.push(`${check ? "Pending" : "Copied"} ${f.name} (core schema v${coreFileVersion(f.name)}).`);
+    if (plan.views) {
+        const names = [...plan.views.text.matchAll(/^-- smoodly:collection (\S+)/gm)].map((m) => m[1]);
+        lines.push(`${check ? "Pending" : "Wrote"} ${plan.views.name} (views: ${names.join(", ")}).`);
+    }
+    return lines;
+}
+export async function runMigrate(args, out, deps = {}) {
+    const cwd = deps.cwd ?? process.cwd();
+    const appDir = resolve(cwd, args.migrations);
+    if (!existsSync(appDir)) {
+        out(NO_FOLDER);
+        return 0;
+    }
+    const collections = await (deps.load ?? loadCollections)(resolve(cwd, args.collections), cwd);
+    const plan = planMigrate({
+        packageFiles: await readSqlFiles(PACKAGE_MIGRATIONS_DIR),
+        appFiles: await readSqlFiles(appDir),
+        collections: collections.map((c) => ({ name: c.name, sql: collectionSQL(c) })),
+    }, (deps.now ?? (() => new Date()))());
+    for (const line of describePlan(plan, args.check))
+        out(line);
+    if (plan.modified.length > 0)
+        return 1;
+    if (planIsEmpty(plan)) {
+        out(upToDate(SCHEMA_VERSION, collections.length));
+        return 0;
+    }
+    if (args.check)
+        return 1;
+    for (const f of [...plan.copy, ...(plan.views ? [plan.views] : [])])
+        await writeFile(join(appDir, f.name), f.text, "utf8");
+    out(NEXT_STEP);
+    return 0;
+}

package/dist/config.d.ts

@@ -32,6 +32,10 @@ export type SmoodlyConfig = {
         default: string;
         supported: string[];
     };
+    /** The site's time zone, an IANA name such as "Europe/Helsinki" (spec
+     *  2026-09-25 date pickers §5): editors pick datetimes in it, views
+     *  format with it. Absent = the editor's browser zone. */
+    timeZone?: string;
     /** `tree.depth` — how deep editors may nest pages. Absent = flat. */
     pages?: {
         tree?: {

package/dist/config.js

@@ -3,6 +3,7 @@ import { DEFAULT_MEDIA } from "./media.js";
 import { DEFAULT_ADMIN_PATH, assertAdminPath, isAdminSlug } from "./admin-path.js";
 import { resolveStyleValues, styleDescriptors } from "./styles.js";
 import { resolveCustom } from "./custom/index.js";
+import { isValidZone } from "./time-zone.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"];
@@ -135,6 +136,13 @@ function assertLocales(config) {
     if (!supported.includes(def))
         throw new Error(`smoodly: the default locale "${def}" is not in the supported list.`);
 }
+function assertTimeZone(config) {
+    if (config.timeZone === undefined)
+        return;
+    if (!isValidZone(config.timeZone)) {
+        throw new Error(`smoodly: timeZone "${config.timeZone}" is not a time zone this runtime knows — use an IANA name such as "Europe/Helsinki".`);
+    }
+}
 /** Every element name a richtext toolset embeds, walking objects and lists. */
 function toolsetElementNames(descriptors, out) {
     for (const d of Object.values(descriptors ?? {})) {
@@ -174,6 +182,7 @@ function assertToolsetElements(config) {
 }
 export function defineConfig(config) {
     assertLocales(config);
+    assertTimeZone(config);
     assertUniqueNames(config);
     assertGlobalSections(config);
     assertToolsetElements(config);

package/dist/draft-token.d.ts

@@ -0,0 +1,31 @@
+export type DraftToken = {
+    versionId: string;
+    savedAt: string;
+};
+/** What a locale row carries for the token (both stores' row types satisfy it). */
+export type DraftPointerRow = {
+    draftVersionId: string | null;
+    draftSavedAt: string | null;
+};
+/** The row's token, or null when it has no draft pointer (a folder, a page created without a tree). */
+export declare function draftToken(row: DraftPointerRow): DraftToken | null;
+export declare function sameToken(a: DraftToken | null, b: DraftToken | null): boolean;
+/** An untrusted value is a token when it has the two strings and nothing is missing. */
+export declare function isDraftToken(v: unknown): v is DraftToken;
+export declare class StaleDraftError extends Error {
+    /** The row's token now — what a reload would get. */
+    readonly current: DraftToken | null;
+    /** The audit pair of the row: who wrote last, when. */
+    readonly by: string | null;
+    readonly at: number;
+    constructor(
+    /** The row's token now — what a reload would get. */
+    current: DraftToken | null, 
+    /** The audit pair of the row: who wrote last, when. */
+    by: string | null, at: number);
+}
+/** The read-side check every guarded write runs first. `undefined` = no check. */
+export declare function assertFresh(row: DraftPointerRow & {
+    updatedBy: string | null;
+    updatedAt: number;
+}, expected: DraftToken | null | undefined): void;

package/dist/draft-token.js

@@ -0,0 +1,41 @@
+// The draft token (spec 2026-09-26 concurrency §1): the locale row's
+// draft pointer with that version's saved time. Every state change moves
+// it — a save rewrites saved_at, a discard points at the published
+// version, a restore creates a new draft. Pure and framework-free; both
+// stores throw StaleDraftError, the ops map it, the admin freezes on it.
+/** The row's token, or null when it has no draft pointer (a folder, a page created without a tree). */
+export function draftToken(row) {
+    return row.draftVersionId === null ? null : { versionId: row.draftVersionId, savedAt: row.draftSavedAt ?? "" };
+}
+export function sameToken(a, b) {
+    if (a === null || b === null)
+        return a === b;
+    return a.versionId === b.versionId && a.savedAt === b.savedAt;
+}
+/** An untrusted value is a token when it has the two strings and nothing is missing. */
+export function isDraftToken(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v)
+        && typeof v.versionId === "string"
+        && typeof v.savedAt === "string";
+}
+export class StaleDraftError extends Error {
+    constructor(
+    /** The row's token now — what a reload would get. */
+    current, 
+    /** The audit pair of the row: who wrote last, when. */
+    by, at) {
+        super("smoodly: the draft changed since it was loaded — reload before saving.");
+        this.current = current;
+        this.by = by;
+        this.at = at;
+        this.name = "StaleDraftError";
+    }
+}
+/** The read-side check every guarded write runs first. `undefined` = no check. */
+export function assertFresh(row, expected) {
+    if (expected === undefined)
+        return;
+    const current = draftToken(row);
+    if (!sameToken(current, expected))
+        throw new StaleDraftError(current, row.updatedBy, row.updatedAt);
+}

package/dist/entry-store.d.ts

@@ -3,6 +3,7 @@ import type { GlobalSchema } from "./global.ts";
 import { type RefEdge, type SectionLike } from "./refs.ts";
 import { MemoryRefIndex } from "./ref-index.ts";
 import { type PathIndex } from "./path-index.ts";
+import { type DraftToken } from "./draft-token.ts";
 import { type LocaleSet, type PathTarget } from "./paths.ts";
 export type EntryLocale = {
     /** The entry's segment in this locale; null claims no URL. */
@@ -11,6 +12,8 @@ export type EntryLocale = {
     /** ONLY the .localized() fields, for this locale. */
     fields: Record<string, unknown>;
     draftVersionId: string | null;
+    /** The draft version's saved time as the store's own text (spec 2026-09-26 concurrency §1). Null with no pointer. */
+    draftSavedAt: 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). */
@@ -104,14 +107,14 @@ export interface EntryStore {
     }): Promise<Record<string, Record<string, unknown>>>;
     /** Replaces the merged fields for `locale`: shared keys on the node
      * (every locale sees them), localized keys and the slug on the row. */
-    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>;
+    update(collection: string, id: string, locale: string, fields: Record<string, unknown>, by?: string, expected?: DraftToken | null): Promise<EntryRecord>;
+    setStatus(collection: string, id: string, locale: string, status: "draft" | "published", by?: string, expected?: DraftToken | null): Promise<EntryRecord>;
     /** The live row goes back to what is published: the published snapshot's fields
      *  (shared and localized, split as on save — the slug is never versioned) written over
      *  the row, the draft pointer set to the published one, the abandoned draft row deleted
      *  (spec 2026-09-13 history §1). Refused when the locale has no published version (a
      *  non-versioned collection never has one). */
-    discardDraft(collection: string, id: string, locale: string, by?: string): Promise<EntryRecord>;
+    discardDraft(collection: string, id: string, locale: string, by?: string, expected?: DraftToken | null): Promise<EntryRecord>;
     /** Copies `from`'s localized fields and slug as the new row (shared
      * fields need no copy); refused when the entry has the locale or its
      * parent lacks it. */
@@ -124,7 +127,7 @@ export interface EntryStore {
     /** The snapshot's shared and localized fields become the draft (the slug is never
      *  versioned) through the draft rule; the live version restores as a discard. Refused
      *  when the version is not this entry's in this locale (spec 2026-09-13 history §6). */
-    restore(collection: string, id: string, locale: string, versionId: string, by?: string): Promise<EntryRecord>;
+    restore(collection: string, id: string, locale: string, versionId: string, by?: string, expected?: DraftToken | null): Promise<EntryRecord>;
     /** One stored version by id — callers check `entryId` and `locale`. */
     getVersion(collection: string, versionId: string): Promise<EntryVersion | null>;
     /** Blocked while anything references the entry (the safe-delete guard),
@@ -268,13 +271,13 @@ export declare class MemoryEntryStore implements EntryStore {
     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): 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>;
+    update(collection: string, id: string, locale: string, fields: Record<string, unknown>, by?: string, expected?: DraftToken | null): 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>;
     listVersions(collection: string, id: string, locale: string): Promise<EntryVersion[]>;
-    restore(collection: string, id: string, locale: string, versionId: string, by?: string): Promise<EntryRecord>;
+    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;

package/dist/entry-store.js

@@ -13,6 +13,7 @@ import { collectionDepth, collectionOrder } from "./collections.js";
 import { collectEntryRefs } from "./refs.js";
 import { MemoryRefIndex } from "./ref-index.js";
 import { MemoryPathIndex } from "./path-index.js";
+import { assertFresh } from "./draft-token.js";
 import { globalEntryId } from "./global-id.js";
 import { DEFAULT_SPACE_ID } from "./sql-space.js";
 import { assertDepth, assertSupportedLocale, chainOf, entryPathRows, slugOf, unsupportedLocale, } from "./paths.js";
@@ -44,6 +45,11 @@ export function schemaOf(collections, name) {
 export const isGlobalSchema = (schema) => schema.kind === "global";
 let counter = 0;
 const uid = (prefix) => `${prefix}-${++counter}-${Date.now().toString(36)}`;
+/** A version's saved time: wall-clock, but strictly increasing, so two saves in one
+ *  millisecond still move the draft token (spec 2026-09-26 concurrency §1) the way
+ *  Postgres's microsecond `now()` does. */
+let lastSavedAt = 0;
+const savedClock = () => (lastSavedAt = Math.max(Date.now(), lastSavedAt + 1));
 export const DEFAULT_ENTRY_LOCALES = { default: "en", supported: ["en"] };
 export const entryErrors = {
     notFound: (collection, id) => new Error(`smoodly: no entry "${id}" in "${collection}".`),
@@ -216,14 +222,16 @@ export class MemoryEntryStore {
         const current = row.draftVersionId ? this.versions.get(row.draftVersionId) : undefined;
         if (current && row.draftVersionId !== row.publishedVersionId) {
             current.fields = fields;
-            current.savedAt = Date.now();
+            current.savedAt = savedClock();
+            row.draftSavedAt = String(current.savedAt);
             this.versionSeq.set(current.id, ++this.seq); // newest again
             return;
         }
-        const version = { id: uid("version"), entryId: entry.id, locale, fields, savedAt: Date.now() };
+        const version = { id: uid("version"), entryId: entry.id, locale, fields, savedAt: savedClock() };
         this.versions.set(version.id, version);
         this.versionSeq.set(version.id, ++this.seq);
         row.draftVersionId = version.id;
+        row.draftSavedAt = String(version.savedAt);
     }
     /** 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
@@ -232,11 +240,12 @@ export class MemoryEntryStore {
         const row = entry.locales[locale];
         if (row.status !== "published" || row.publishedVersionId !== null)
             return;
-        const version = { id: uid("version"), entryId: entry.id, locale, fields: entryFieldsIn(entry, locale), savedAt: Date.now() };
+        const version = { id: uid("version"), entryId: entry.id, locale, fields: entryFieldsIn(entry, locale), savedAt: savedClock() };
         this.versions.set(version.id, version);
         this.versionSeq.set(version.id, ++this.seq);
         row.draftVersionId = version.id;
         row.publishedVersionId = version.id;
+        row.draftSavedAt = String(version.savedAt);
     }
     dropVersions(entryId, locale) {
         for (const [id, v] of this.versions) {
@@ -323,7 +332,7 @@ export class MemoryEntryStore {
             collection, parentId, fields: shared,
             locales: {
                 [options.locale]: {
-                    slug, status: "draft", fields: localized, draftVersionId: null, publishedVersionId: null, updatedAt: now, updatedBy: by ?? null,
+                    slug, status: "draft", fields: localized, draftVersionId: null, draftSavedAt: null, publishedVersionId: null, updatedAt: now, updatedBy: by ?? null,
                 },
             },
             sort: null, createdAt: now, updatedAt: now,
@@ -387,10 +396,11 @@ export class MemoryEntryStore {
         }
         return out;
     }
-    async update(collection, id, locale, fields, by) {
+    async update(collection, id, locale, fields, by, expected) {
         const schema = this.schema(collection);
         const entry = this.must(collection, id);
         const row = entryLocaleRow(entry, locale);
+        assertFresh(row, expected);
         this.ensureLiveSnapshot(entry, locale);
         const { shared, localized, slug } = splitFields(fields, schema);
         if (isGlobalSchema(schema) && slug !== null)
@@ -413,10 +423,11 @@ export class MemoryEntryStore {
         this.writeRefs(entry);
         return this.snapshot(entry);
     }
-    async setStatus(collection, id, locale, status, by) {
+    async setStatus(collection, id, locale, status, by, expected) {
         const entry = this.must(collection, id);
         const row = entryLocaleRow(entry, locale);
         if (status === "published") {
+            assertFresh(row, expected);
             // Publish points at the current draft; a row always has one after its first write, but never trust that from here.
             if (!row.draftVersionId)
                 this.recordVersion(entry, locale);
@@ -428,10 +439,11 @@ export class MemoryEntryStore {
         this.writeRefs(entry); // the published snapshot just became, or stopped being, a live set
         return this.snapshot(entry);
     }
-    async discardDraft(collection, id, locale, by) {
+    async discardDraft(collection, id, locale, by, expected) {
         const schema = this.schema(collection);
         const entry = this.must(collection, id);
         const row = entryLocaleRow(entry, locale);
+        assertFresh(row, expected);
         const snapshot = row.publishedVersionId ? this.versions.get(row.publishedVersionId) : undefined;
         if (!snapshot)
             throw entryErrors.nothingPublished(collection, id, locale);
@@ -440,6 +452,7 @@ export class MemoryEntryStore {
         row.fields = localized;
         const abandoned = row.draftVersionId;
         row.draftVersionId = row.publishedVersionId;
+        row.draftSavedAt = String(snapshot.savedAt);
         if (abandoned && abandoned !== row.publishedVersionId) {
             this.versions.delete(abandoned);
             this.versionSeq.delete(abandoned);
@@ -462,7 +475,7 @@ export class MemoryEntryStore {
         const now = Date.now();
         entry.locales[locale] = {
             slug: source.slug, status: "draft", fields: structuredClone(source.fields),
-            draftVersionId: null, publishedVersionId: null, updatedAt: now, updatedBy: by ?? null,
+            draftVersionId: null, draftSavedAt: null, publishedVersionId: null, updatedAt: now, updatedBy: by ?? null,
         };
         this.recordVersion(entry, locale);
         // Only this node's rows change: a child cannot have a locale its parent lacked.
@@ -510,15 +523,16 @@ export class MemoryEntryStore {
             .sort((a, b) => b.savedAt - a.savedAt || this.versionSeq.get(b.id) - this.versionSeq.get(a.id))
             .map((v) => structuredClone(v));
     }
-    async restore(collection, id, locale, versionId, by) {
+    async restore(collection, id, locale, versionId, by, expected) {
         const schema = this.schema(collection);
         const entry = this.must(collection, id);
         const row = entryLocaleRow(entry, locale);
         const version = this.versions.get(versionId);
         if (!version || version.entryId !== id || version.locale !== locale)
             throw entryErrors.foreignVersion(collection, id, locale, versionId);
+        assertFresh(row, expected);
         if (versionId === row.publishedVersionId)
-            return this.discardDraft(collection, id, locale, by);
+            return this.discardDraft(collection, id, locale, by, expected);
         const { shared, localized } = splitFields(version.fields, schema);
         entry.fields = shared;
         row.fields = localized; // the slug is the row's own and never versioned

package/dist/env.d.ts

@@ -14,3 +14,12 @@ export declare function resolveSmoodlyEnv(env: Record<string, string | undefined
 /** `resolveSmoodlyEnv(process.env)` — call lazily, never at module load,
  *  so `next build` without env still succeeds. */
 export declare const smoodlyEnv: () => SmoodlyEnv;
+/** What the browser needs to join the content project's presence channel (spec 2026-09-26 concurrency §5): public values only. */
+export type ContentConfig = {
+    url: string;
+    key: string;
+    spaceId: string;
+};
+/** The space a key acts in: its `space_id` claim when it is a JWT that carries one, else the default space. */
+export declare function spaceIdOfKey(key: string): string;
+export declare function publicContentConfig(env: SmoodlyEnv): ContentConfig;

package/dist/env.js

@@ -1,6 +1,7 @@
 // The one config shape (spec 2026-09-04 §4/§6). Self-host sets three
 // names; the cloud sets five. The two defaults are what keep a single
 // code path: a default for an absent value is not a mode branch.
+import { DEFAULT_SPACE_ID } from "./sql-space.js";
 const REQUIRED = ["SMOODLY_URL", "SMOODLY_SECRET_KEY", "SMOODLY_PUBLISHABLE_KEY"];
 export function resolveSmoodlyEnv(env) {
     const missing = REQUIRED.filter((name) => !env[name]);
@@ -20,3 +21,21 @@ export function resolveSmoodlyEnv(env) {
 /** `resolveSmoodlyEnv(process.env)` — call lazily, never at module load,
  *  so `next build` without env still succeeds. */
 export const smoodlyEnv = () => resolveSmoodlyEnv(process.env);
+/** The space a key acts in: its `space_id` claim when it is a JWT that carries one, else the default space. */
+export function spaceIdOfKey(key) {
+    const parts = key.split(".");
+    if (parts.length !== 3)
+        return DEFAULT_SPACE_ID;
+    try {
+        // base64url → base64, padded; atob exists in Node 22 and every browser, so no Buffer here.
+        const b64 = parts[1].replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(parts[1].length / 4) * 4, "=");
+        const claims = JSON.parse(atob(b64));
+        return typeof claims.space_id === "string" && claims.space_id ? claims.space_id : DEFAULT_SPACE_ID;
+    }
+    catch {
+        return DEFAULT_SPACE_ID;
+    }
+}
+export function publicContentConfig(env) {
+    return { url: env.url, key: env.publishableKey, spaceId: spaceIdOfKey(env.secretKey) };
+}

package/dist/fields.d.ts

@@ -74,6 +74,8 @@ export declare const f: {
         from?: string;
     }) => FieldBuilder<string, {}>;
     date: () => FieldBuilder<string, {}>;
+    /** A UTC instant to the minute, "2026-09-02T14:30:00Z" (spec 2026-09-25 date pickers §1). */
+    datetime: () => FieldBuilder<string, {}>;
     number: () => FieldBuilder<number, {}>;
     /** `aspect`: one `"w:h"` or several the crop tool may lock to — a per-use
      *  constraint, so the component knows its box before the image loads. */

package/dist/fields.js

@@ -81,6 +81,8 @@ export const f = {
     link: () => builder({ type: "link" }),
     slug: (opts) => builder({ type: "slug", ...(opts?.from ? { from: opts.from } : {}) }),
     date: () => builder({ type: "date" }),
+    /** A UTC instant to the minute, "2026-09-02T14:30:00Z" (spec 2026-09-25 date pickers §1). */
+    datetime: () => builder({ type: "datetime" }),
     number: () => builder({ type: "number" }),
     /** `aspect`: one `"w:h"` or several the crop tool may lock to — a per-use
      *  constraint, so the component knows its box before the image loads. */