includio-cms 0.5.3 → 0.5.7

package/CHANGELOG.md

@@ -3,6 +3,77 @@
 All notable changes to includio-cms are documented here.
 Generated from `src/lib/updates/` — do not edit manually.
 
+## 0.5.7 — 2026-03-06
+
+SEO field with slug toggle, structured-content & URL field fixes
+
+### Added
+- SEO field: auto/manual slug toggle with Switch component
+
+### Fixed
+- Structured content: skip empty paragraphs, wrap inline blocks in `<div>`
+- `resolveUrlFields`: normalize flat string url/text values, use raw DB calls for performance
+- Admin UI: migrate `{#await}` blocks to reactive query pattern for consistent loading states
+
+## 0.5.6 — 2026-03-05
+
+Relation field UX overhaul, collection list improvements, icon map refactor
+
+### Added
+- Relation field: dialog picker with search, reorder, multi-select UX
+- `getEntryLabels` — lightweight labels endpoint for relation field options
+- Collection list: relation labels displayed in columns, delete restricted to archived entries
+- Icon map: string-based sidebar icons replace component references
+
+### Fixed
+- TipTap: auto-expand new inline blocks, fix editor overflow, toolbar background
+- Runtime types: FormEntryMap rename, add remote.ts typings
+
+### Notes
+
+Removed `mode-watcher` dependency — light theme is now hardcoded.
+
+## 0.5.5 — 2026-03-04
+
+REST API with API key auth, orderable collection fixes
+
+### Added
+- REST API with API key authentication — CRUD for collections, singletons, entries, schema introspection, language listing
+- API key configuration in CMS config (`apiKeys` array)
+- getEntries supports `orderBy` parameter (column + direction)
+- Admin scaffold generates REST API catch-all route
+
+### Fixed
+- Orderable collections: DnD rows use proper `<tr>` element instead of `<div>` wrapper
+- Reorder buttons always visible (not sr-only) for better discoverability
+- Selection enabled for orderable collections
+- Relation field respects orderable collection sort order
+- Nav active state: exact match prevents false highlights on similarly-named routes
+
+### Notes
+
+Add `apiKeys: [{ key: "your-secret", name: "My App" }]` to CMS config. REST API available at `/admin/api/rest/`.
+
+## 0.5.4 — 2026-03-04
+
+Collection ordering (DnD), custom list columns
+
+### Added
+- Orderable collections: DnD reordering of entries in admin list with keyboard alternative (WCAG 2.1)
+- Custom list columns: display arbitrary entry fields as columns in collection list
+- sortOrder column on entries table for persistent manual ordering
+- reorderEntriesCommand remote for bulk sort order updates
+
+### Migration
+
+```sql
+ALTER TABLE entry ADD COLUMN sort_order INTEGER;
+```
+
+### Notes
+
+Add `orderable: true` to collections that need manual ordering. Add `listColumns: ["fieldSlug"]` to show fields in the entry list.
+
 ## 0.5.3 — 2026-03-04
 
 Form fields, inline blocks, hybrid preview, field components refactor

package/ROADMAP.md

@@ -89,6 +89,39 @@
 - [x] `[chore]` `[P2]` Storybook stories for all field types
 - [x] `[chore]` `[P1]` Field components refactor: bindable value props
 
+## 0.5.4 — Collection ordering & list columns
+
+- [x] `[feature]` `[P1]` Orderable collections: DnD reordering with keyboard alternative (WCAG 2.1) <!-- files: src/lib/admin/client/collection/data-table.svelte, src/lib/admin/client/collection/collection-entries.svelte -->
+- [x] `[feature]` `[P1]` Custom list columns: display entry fields as columns in collection list <!-- files: src/lib/admin/client/collection/collection-entries.svelte -->
+- [x] `[feature]` `[P1]` `sortOrder` column + `reorderEntriesCommand` remote <!-- files: src/lib/db-postgres/schema/entry.ts, src/lib/admin/remote/entry.remote.ts -->
+
+## 0.5.5 — REST API & orderable fixes
+
+- [x] `[feature]` `[P1]` REST API with API key authentication — CRUD for collections, singletons, entries, schema, languages <!-- files: src/lib/admin/api/rest/ -->
+- [x] `[feature]` `[P1]` API key configuration in CMS config (`apiKeys`) <!-- files: src/lib/types/cms.ts, src/lib/core/cms.ts -->
+- [x] `[feature]` `[P2]` getEntries `orderBy` parameter support <!-- files: src/lib/types/entries.ts, src/lib/core/server/entries/operations/get.ts -->
+- [x] `[fix]` `[P1]` Orderable collections: proper `<tr>` markup, visible reorder buttons, selection enabled <!-- files: src/lib/admin/client/collection/data-table.svelte -->
+- [x] `[fix]` `[P1]` Relation field respects orderable collection sort order <!-- files: src/lib/admin/components/fields/relation-field.svelte -->
+- [x] `[fix]` `[P1]` Nav active state exact match — prevents false highlights <!-- files: src/lib/admin/components/layout/nav-*.svelte -->
+- [x] `[chore]` `[P2]` Admin scaffold generates REST API route <!-- files: src/lib/cli/scaffold/admin.ts -->
+
+## 0.5.6 — Relation field & collection improvements
+
+- [x] `[feature]` `[P1]` Relation field: dialog picker, reorder, search, multi-select UX <!-- files: src/lib/admin/components/fields/relation-field.svelte -->
+- [x] `[feature]` `[P1]` getEntryLabels — lightweight labels endpoint for relation fields <!-- files: src/lib/admin/remote/entry.remote.ts -->
+- [x] `[feature]` `[P2]` Collection list: relation labels in columns, delete only for archived <!-- files: src/lib/admin/client/collection/collection-entries.svelte -->
+- [x] `[feature]` `[P2]` Icon map — string-based sidebar icons replace component refs <!-- files: src/lib/admin/components/layout/nav-main.svelte -->
+- [x] `[fix]` `[P1]` TipTap: auto-expand new inline blocks, editor overflow, toolbar bg <!-- files: src/lib/admin/components/fields/structured-content/ -->
+- [x] `[chore]` `[P2]` Runtime types: FormEntryMap rename, add remote.ts
+- [x] `[chore]` `[P2]` Remove mode-watcher, hardcode light theme
+
+## 0.5.7 — SEO field & content fixes
+
+- [x] `[feature]` `[P1]` SEO field: auto/manual slug toggle with Switch <!-- files: src/lib/admin/components/fields/seo-field.svelte -->
+- [x] `[fix]` `[P1]` Structured content: skip empty paragraphs, wrap inline blocks in div <!-- files: src/lib/core/server/entries/operations/ -->
+- [x] `[fix]` `[P1]` resolveUrlFields: normalize flat string url/text, use raw DB calls <!-- files: src/lib/core/server/entries/ -->
+- [x] `[chore]` `[P1]` Migrate #await to reactive query pattern across admin UI
+
 ## 0.6.0 — Plugin system _(deferred from 0.2.0)_
 
 - [ ] `[feature]` `[P0]` Wire plugin hooks into CRUD operations (before/afterCreate, Update, Delete) <!-- files: src/lib/types/plugins.ts, src/lib/core/server/entries/operations/ -->

package/dist/admin/api/rest/handler.d.ts

@@ -0,0 +1,7 @@
+import { type RequestHandler } from '@sveltejs/kit';
+export declare function createRestApiHandler(): {
+    GET: RequestHandler;
+    POST: RequestHandler;
+    PUT: RequestHandler;
+    DELETE: RequestHandler;
+};

package/dist/admin/api/rest/handler.js

@@ -0,0 +1,116 @@
+import { json } from '@sveltejs/kit';
+import { authenticateApiKey } from './middleware/apiKey.js';
+import * as schemaRoutes from './routes/schema.js';
+import * as languagesRoutes from './routes/languages.js';
+import * as collectionsRoutes from './routes/collections.js';
+import * as singletonsRoutes from './routes/singletons.js';
+import * as entriesRoutes from './routes/entries.js';
+function matchRoute(method, path) {
+    // Schema routes
+    if (method === 'GET' && path === 'schema') {
+        return { handler: 'schema', params: [] };
+    }
+    if (method === 'GET' && path.startsWith('schema/')) {
+        return { handler: 'schema', params: [] };
+    }
+    // Languages
+    if (method === 'GET' && path === 'languages') {
+        return { handler: 'languages', params: [] };
+    }
+    // Entries lifecycle: POST /entries/:id/:action
+    const entriesMatch = path.match(/^entries\/([^/]+)\/(publish|unpublish|archive|unarchive)$/);
+    if (method === 'POST' && entriesMatch) {
+        return { handler: 'entries', params: [entriesMatch[1], entriesMatch[2]] };
+    }
+    // Collections: /collections/:slug/:id?
+    const collectionWithId = path.match(/^collections\/([^/]+)\/([^/]+)$/);
+    if (collectionWithId) {
+        return { handler: 'collections', params: [collectionWithId[1], collectionWithId[2]] };
+    }
+    const collectionOnly = path.match(/^collections\/([^/]+)$/);
+    if (collectionOnly) {
+        return { handler: 'collections', params: [collectionOnly[1]] };
+    }
+    // Singletons: /singletons/:slug
+    const singletonMatch = path.match(/^singletons\/([^/]+)$/);
+    if (singletonMatch) {
+        return { handler: 'singletons', params: [singletonMatch[1]] };
+    }
+    return null;
+}
+export function createRestApiHandler() {
+    function handle(method) {
+        return async (event) => {
+            // Authenticate
+            const apiKey = authenticateApiKey(event);
+            if (!apiKey) {
+                return json({ error: 'Unauthorized — invalid or missing API key' }, { status: 401 });
+            }
+            const restPath = event.params.restPath || '';
+            const route = matchRoute(method, restPath);
+            if (!route) {
+                return json({ error: 'Not found' }, { status: 404 });
+            }
+            try {
+                switch (route.handler) {
+                    case 'schema': {
+                        // Pass restPath minus 'schema/' prefix
+                        const schemaPath = restPath === 'schema' ? '' : restPath.slice(7);
+                        event.params.restPath = schemaPath;
+                        return await schemaRoutes.GET(event);
+                    }
+                    case 'languages':
+                        return await languagesRoutes.GET();
+                    case 'collections': {
+                        const [slug, id] = route.params;
+                        switch (method) {
+                            case 'GET':
+                                return await collectionsRoutes.GET(event, slug, id);
+                            case 'POST':
+                                return await collectionsRoutes.POST(event, slug);
+                            case 'PUT':
+                                if (!id)
+                                    return json({ error: 'Entry ID required' }, { status: 400 });
+                                return await collectionsRoutes.PUT(event, slug, id);
+                            case 'DELETE':
+                                if (!id)
+                                    return json({ error: 'Entry ID required' }, { status: 400 });
+                                return await collectionsRoutes.DELETE(event, slug, id);
+                        }
+                        break;
+                    }
+                    case 'singletons': {
+                        const [slug] = route.params;
+                        switch (method) {
+                            case 'GET':
+                                return await singletonsRoutes.GET(event, slug);
+                            case 'PUT':
+                                return await singletonsRoutes.PUT(event, slug);
+                            default:
+                                return json({ error: 'Method not allowed' }, { status: 405 });
+                        }
+                    }
+                    case 'entries': {
+                        const [id, action] = route.params;
+                        return await entriesRoutes.POST(event, id, action);
+                    }
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : 'Internal server error';
+                const status = message === 'Unauthorized' ? 401
+                    : message === 'Forbidden' ? 403
+                        : message.includes('not found') || message.includes('Not found') ? 404
+                            : 500;
+                return json({ error: message }, { status });
+            }
+            return json({ error: 'Not found' }, { status: 404 });
+        };
+    }
+    return {
+        GET: handle('GET'),
+        POST: handle('POST'),
+        PUT: handle('PUT'),
+        DELETE: handle('DELETE')
+    };
+}

package/dist/admin/api/rest/middleware/apiKey.d.ts

@@ -0,0 +1,6 @@
+import type { RequestEvent } from '@sveltejs/kit';
+import type { ApiKeyConfig } from '../../../../types/cms.js';
+export declare function extractApiKey(event: RequestEvent): string | null;
+export declare function validateApiKey(key: string): ApiKeyConfig | null;
+export declare function setSyntheticUser(event: RequestEvent, apiKey: ApiKeyConfig): void;
+export declare function authenticateApiKey(event: RequestEvent): ApiKeyConfig | null;

package/dist/admin/api/rest/middleware/apiKey.js

@@ -0,0 +1,45 @@
+import { getCMS } from '../../../../core/cms.js';
+export function extractApiKey(event) {
+    const authHeader = event.request.headers.get('authorization');
+    if (authHeader?.startsWith('Bearer ')) {
+        return authHeader.slice(7);
+    }
+    return event.request.headers.get('x-api-key');
+}
+export function validateApiKey(key) {
+    const cms = getCMS();
+    return cms.apiKeys.find((k) => k.key === key) ?? null;
+}
+export function setSyntheticUser(event, apiKey) {
+    const name = apiKey.name || 'api';
+    event.locals.user = {
+        id: `api:${name}`,
+        name,
+        role: apiKey.role || 'admin',
+        email: `${name}@api.local`,
+        emailVerified: true,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        image: null
+    };
+    event.locals.session = {
+        id: 'api-session',
+        userId: `api:${name}`,
+        expiresAt: new Date(Date.now() + 86400000),
+        token: '',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ipAddress: null,
+        userAgent: null
+    };
+}
+export function authenticateApiKey(event) {
+    const key = extractApiKey(event);
+    if (!key)
+        return null;
+    const apiKey = validateApiKey(key);
+    if (!apiKey)
+        return null;
+    setSyntheticUser(event, apiKey);
+    return apiKey;
+}

package/dist/admin/api/rest/routes/collections.d.ts

@@ -0,0 +1,5 @@
+import { type RequestEvent } from '@sveltejs/kit';
+export declare function GET(event: RequestEvent, slug: string, id?: string): Promise<Response>;
+export declare function POST(event: RequestEvent, slug: string): Promise<Response>;
+export declare function PUT(event: RequestEvent, slug: string, id: string): Promise<Response>;
+export declare function DELETE(_event: RequestEvent, slug: string, id: string): Promise<Response>;

package/dist/admin/api/rest/routes/collections.js

@@ -0,0 +1,104 @@
+import { json } from '@sveltejs/kit';
+import { getCMS } from '../../../../core/cms.js';
+import { getRawEntries, getRawEntry, countRawEntries } from '../../../../core/server/entries/operations/get.js';
+import { createEntry } from '../../../../core/server/entries/operations/create.js';
+import { upsertDraftVersion } from '../../../../core/server/entries/operations/update.js';
+import { deleteEntry } from '../../../../core/server/entries/operations/delete.js';
+export async function GET(event, slug, id) {
+    const cms = getCMS();
+    if (!cms.collections[slug]) {
+        return json({ error: `Collection "${slug}" not found` }, { status: 404 });
+    }
+    // GET /collections/:slug/:id — single entry
+    if (id) {
+        const entry = await getRawEntry({ id, slug, includeArchived: true });
+        if (!entry) {
+            return json({ error: 'Entry not found' }, { status: 404 });
+        }
+        return json({
+            id: entry.id,
+            slug: entry.slug,
+            type: entry.type,
+            createdAt: entry.createdAt,
+            updatedAt: entry.updatedAt,
+            publishedAt: entry.publishedAt,
+            archivedAt: entry.archivedAt,
+            availableLocales: entry.availableLocales,
+            sortOrder: entry.sortOrder,
+            draftData: entry.draftVersion?.data ?? null,
+            publishedData: entry.publishedVersion?.data ?? null,
+            draftVersionId: entry.draftVersion?.id ?? null,
+            publishedVersionId: entry.publishedVersion?.id ?? null
+        });
+    }
+    // GET /collections/:slug — list
+    const url = event.url;
+    const status = url.searchParams.get('status') || undefined;
+    const limit = parseInt(url.searchParams.get('limit') || '50', 10);
+    const offset = parseInt(url.searchParams.get('offset') || '0', 10);
+    const includeArchived = status === 'archived';
+    const onlyArchived = status === 'archived';
+    const [entries, total] = await Promise.all([
+        getRawEntries({ slug, limit, offset, includeArchived, onlyArchived }),
+        countRawEntries({ slug, includeArchived, onlyArchived })
+    ]);
+    const items = entries.map((entry) => ({
+        id: entry.id,
+        slug: entry.slug,
+        type: entry.type,
+        createdAt: entry.createdAt,
+        updatedAt: entry.updatedAt,
+        publishedAt: entry.publishedAt,
+        archivedAt: entry.archivedAt,
+        availableLocales: entry.availableLocales,
+        sortOrder: entry.sortOrder,
+        draftData: entry.draftVersion?.data ?? null,
+        publishedData: entry.publishedVersion?.data ?? null
+    }));
+    return json({ items, total, limit, offset });
+}
+export async function POST(event, slug) {
+    const cms = getCMS();
+    if (!cms.collections[slug]) {
+        return json({ error: `Collection "${slug}" not found` }, { status: 404 });
+    }
+    const body = await event.request.json().catch(() => null);
+    const entry = await createEntry({ slug, type: 'collection' });
+    // If data provided, save as draft
+    if (body?.data && typeof body.data === 'object') {
+        await upsertDraftVersion(entry.id, body.data, { skipValidation: true });
+    }
+    return json({ id: entry.id, slug: entry.slug }, { status: 201 });
+}
+export async function PUT(event, slug, id) {
+    const cms = getCMS();
+    if (!cms.collections[slug]) {
+        return json({ error: `Collection "${slug}" not found` }, { status: 404 });
+    }
+    const entry = await getRawEntry({ id, slug });
+    if (!entry) {
+        return json({ error: 'Entry not found' }, { status: 404 });
+    }
+    const body = await event.request.json().catch(() => null);
+    if (!body?.data || typeof body.data !== 'object') {
+        return json({ error: 'Request body must contain "data" object' }, { status: 400 });
+    }
+    const version = await upsertDraftVersion(entry.id, body.data, { skipValidation: true });
+    return json({
+        id: entry.id,
+        versionId: version.id,
+        versionNumber: version.versionNumber
+    });
+}
+export async function DELETE(_event, slug, id) {
+    const cms = getCMS();
+    if (!cms.collections[slug]) {
+        return json({ error: `Collection "${slug}" not found` }, { status: 404 });
+    }
+    const entry = await getRawEntry({ id, slug, includeArchived: true });
+    if (!entry) {
+        return json({ error: 'Entry not found' }, { status: 404 });
+    }
+    await deleteEntry(entry.id);
+    return json({ success: true });
+}

package/dist/admin/api/rest/routes/entries.d.ts

@@ -0,0 +1,2 @@
+import { type RequestEvent } from '@sveltejs/kit';
+export declare function POST(_event: RequestEvent, id: string, action: string): Promise<Response>;

package/dist/admin/api/rest/routes/entries.js

@@ -0,0 +1,37 @@
+import { json } from '@sveltejs/kit';
+import { requireAuth } from '../../../remote/middleware/auth.js';
+import { getRawEntryOrThrow } from '../../../../core/server/entries/operations/get.js';
+import { updateEntry, unpublishEntry } from '../../../../core/server/entries/operations/update.js';
+export async function POST(_event, id, action) {
+    const { user } = requireAuth();
+    switch (action) {
+        case 'publish': {
+            const entry = await getRawEntryOrThrow({ id, includeArchived: false });
+            const draftVersion = entry.draftVersion;
+            if (!draftVersion) {
+                return json({ error: 'No draft version to publish' }, { status: 400 });
+            }
+            await updateEntry(id, {
+                publishedVersionId: draftVersion.id,
+                publishedAt: new Date(),
+                publishedBy: user.id,
+                archivedAt: null
+            });
+            return json({ success: true, publishedVersionId: draftVersion.id });
+        }
+        case 'unpublish': {
+            await unpublishEntry(id);
+            return json({ success: true });
+        }
+        case 'archive': {
+            await updateEntry(id, { archivedAt: new Date() });
+            return json({ success: true });
+        }
+        case 'unarchive': {
+            await updateEntry(id, { archivedAt: null });
+            return json({ success: true });
+        }
+        default:
+            return json({ error: `Unknown action "${action}"` }, { status: 400 });
+    }
+}

package/dist/admin/api/rest/routes/languages.d.ts

@@ -0,0 +1 @@
+export declare function GET(): Promise<Response>;

package/dist/admin/api/rest/routes/languages.js

@@ -0,0 +1,5 @@
+import { json } from '@sveltejs/kit';
+import { getCMS } from '../../../../core/cms.js';
+export async function GET() {
+    return json({ languages: getCMS().languages });
+}

package/dist/admin/api/rest/routes/schema.d.ts

@@ -0,0 +1,2 @@
+import { type RequestEvent } from '@sveltejs/kit';
+export declare function GET(event: RequestEvent): Promise<Response>;

package/dist/admin/api/rest/routes/schema.js

@@ -0,0 +1,78 @@
+import { json } from '@sveltejs/kit';
+import { getCMS } from '../../../../core/cms.js';
+import { getFieldsFromConfig } from '../../../../core/fields/layoutUtils.js';
+function serializeField(field) {
+    const { ...rest } = field;
+    // Remove non-serializable properties
+    delete rest.icon;
+    return rest;
+}
+function serializeFields(fields) {
+    return fields.map(serializeField);
+}
+export async function GET(event) {
+    const cms = getCMS();
+    const path = event.params.restPath || '';
+    // GET /schema/collections/:slug
+    const collectionMatch = path.match(/^collections\/([^/]+)$/);
+    if (collectionMatch) {
+        const slug = collectionMatch[1];
+        const collection = cms.collections[slug];
+        if (!collection) {
+            return json({ error: `Collection "${slug}" not found` }, { status: 404 });
+        }
+        return json({
+            slug: collection.slug,
+            type: collection.type,
+            labels: collection.labels,
+            fields: serializeFields(getFieldsFromConfig(collection)),
+            orderable: collection.orderable,
+            listColumns: collection.listColumns,
+            slugField: collection.slugField
+        });
+    }
+    // GET /schema/singletons/:slug
+    const singletonMatch = path.match(/^singletons\/([^/]+)$/);
+    if (singletonMatch) {
+        const slug = singletonMatch[1];
+        const single = cms.singles[slug];
+        if (!single) {
+            return json({ error: `Singleton "${slug}" not found` }, { status: 404 });
+        }
+        return json({
+            slug: single.slug,
+            type: single.type,
+            label: single.label,
+            fields: serializeFields(getFieldsFromConfig(single))
+        });
+    }
+    // GET /schema — full schema overview
+    if (path === '') {
+        const collections = Object.values(cms.collections).map((c) => ({
+            slug: c.slug,
+            type: c.type,
+            labels: c.labels,
+            fields: serializeFields(getFieldsFromConfig(c)),
+            orderable: c.orderable,
+            listColumns: c.listColumns,
+            slugField: c.slugField
+        }));
+        const singletons = Object.values(cms.singles).map((s) => ({
+            slug: s.slug,
+            type: s.type,
+            label: s.label,
+            fields: serializeFields(getFieldsFromConfig(s))
+        }));
+        const forms = Object.values(cms.forms).map((f) => ({
+            slug: f.slug,
+            fields: f.fields
+        }));
+        return json({
+            collections,
+            singletons,
+            forms,
+            languages: cms.languages
+        });
+    }
+    return json({ error: 'Not found' }, { status: 404 });
+}

package/dist/admin/api/rest/routes/singletons.d.ts

@@ -0,0 +1,3 @@
+import { type RequestEvent } from '@sveltejs/kit';
+export declare function GET(_event: RequestEvent, slug: string): Promise<Response>;
+export declare function PUT(event: RequestEvent, slug: string): Promise<Response>;

package/dist/admin/api/rest/routes/singletons.js

@@ -0,0 +1,60 @@
+import { json } from '@sveltejs/kit';
+import { getCMS } from '../../../../core/cms.js';
+import { getRawEntries } from '../../../../core/server/entries/operations/get.js';
+import { createEntry } from '../../../../core/server/entries/operations/create.js';
+import { upsertDraftVersion } from '../../../../core/server/entries/operations/update.js';
+export async function GET(_event, slug) {
+    const cms = getCMS();
+    if (!cms.singles[slug]) {
+        return json({ error: `Singleton "${slug}" not found` }, { status: 404 });
+    }
+    const entries = await getRawEntries({ slug });
+    const entry = entries[0];
+    if (!entry) {
+        return json({
+            slug,
+            type: 'single',
+            draftData: null,
+            publishedData: null
+        });
+    }
+    return json({
+        id: entry.id,
+        slug: entry.slug,
+        type: entry.type,
+        createdAt: entry.createdAt,
+        updatedAt: entry.updatedAt,
+        publishedAt: entry.publishedAt,
+        draftData: entry.draftVersion?.data ?? null,
+        publishedData: entry.publishedVersion?.data ?? null,
+        draftVersionId: entry.draftVersion?.id ?? null,
+        publishedVersionId: entry.publishedVersion?.id ?? null
+    });
+}
+export async function PUT(event, slug) {
+    const cms = getCMS();
+    if (!cms.singles[slug]) {
+        return json({ error: `Singleton "${slug}" not found` }, { status: 404 });
+    }
+    const body = await event.request.json().catch(() => null);
+    if (!body?.data || typeof body.data !== 'object') {
+        return json({ error: 'Request body must contain "data" object' }, { status: 400 });
+    }
+    // Find or create singleton entry
+    const entries = await getRawEntries({ slug });
+    let entry = entries[0];
+    if (!entry) {
+        const dbEntry = await createEntry({ slug, type: 'single' });
+        const created = await getRawEntries({ slug });
+        entry = created[0];
+        if (!entry) {
+            return json({ error: 'Failed to create singleton entry' }, { status: 500 });
+        }
+    }
+    const version = await upsertDraftVersion(entry.id, body.data, { skipValidation: true });
+    return json({
+        id: entry.id,
+        versionId: version.id,
+        versionNumber: version.versionNumber
+    });
+}