includio-cms 0.36.8 → 0.37.0

package/dist/admin/remote/booking.remote.d.ts

@@ -0,0 +1,244 @@
+import { bookingsTable } from '../../db-postgres/schema/booking/index.js';
+import { type BookingStatus } from '../../booking/state-machine.js';
+import type { FieldDef } from '../../booking/participant-fields/types.js';
+/** Whether the booking module is registered. @public */
+export declare const getBookingEnabled: import("@sveltejs/kit").RemoteQueryFunction<void, boolean>;
+/**
+ * Lists active (non-deleted) bookings, newest first — paginated server-side.
+ *
+ * Search spans the booking number AND the `customer` bag. The bag's shape is defined by the
+ * consumer, not by the core, so we match against its text form instead of guessing key names.
+ *
+ * @public
+ */
+export declare const listBookings: import("@sveltejs/kit").RemoteQueryFunction<{
+    status?: "paid" | "cancelled" | "draft" | "reserved" | "partially_paid" | "completed" | undefined;
+    search?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+} | undefined, {
+    items: {
+        id: string;
+        number: string;
+        status: BookingStatus;
+        currency: string;
+        customer: Record<string, unknown>;
+        totals: import("../../db-postgres/schema/booking/index.js").BookingTotals;
+        accessToken: string;
+        staffNotes: string | null;
+        language: string | null;
+        balanceDueAt: Date | null;
+        holdExpiresAt: Date | null;
+        cancelReason: string | null;
+        deletedAt: Date | null;
+        deletedBy: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }[];
+    total: number;
+}>;
+/**
+ * Aggregate stats for the booking dashboard, computed in SQL.
+ *
+ * Deliberately NOT derived from {@link listBookings}: that query is paginated, so summing its rows
+ * would silently report stats for the first page only.
+ *
+ * @public
+ */
+export declare const getBookingStats: import("@sveltejs/kit").RemoteQueryFunction<void, {
+    active: number;
+    outstanding: number;
+    toConfirm: number;
+    currency: string;
+}>;
+/** Full booking detail (booking + items + participants + ledger + reminders). @public */
+export declare const getBooking: import("@sveltejs/kit").RemoteQueryFunction<string, {
+    booking: {
+        id: string;
+        number: string;
+        status: BookingStatus;
+        currency: string;
+        customer: Record<string, unknown>;
+        totals: import("../../db-postgres/schema/booking/index.js").BookingTotals;
+        accessToken: string;
+        staffNotes: string | null;
+        language: string | null;
+        balanceDueAt: Date | null;
+        holdExpiresAt: Date | null;
+        cancelReason: string | null;
+        deletedAt: Date | null;
+        deletedBy: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    };
+    items: {
+        participantFields: FieldDef[];
+        /** Human title of the catalog entry; falls back to the raw ref when unresolvable. */
+        tripTitle: string;
+        id: string;
+        bookingId: string;
+        tripRef: string;
+        departureDate: Date | null;
+        participantsCount: number;
+        unitPriceSnapshot: number;
+        subtotalSnapshot: number | null;
+        appliedDiscounts: import("../../booking/pricing.js").AppliedRule[];
+        createdAt: Date;
+        updatedAt: Date;
+    }[];
+    participants: import("../../booking/participants-view.js").FlatParticipant[];
+    persons: {
+        id: string;
+        bookingId: string;
+        data: Record<string, unknown>;
+        createdAt: Date;
+        updatedAt: Date;
+    }[];
+    assignments: {
+        id: string;
+        itemId: string;
+        personId: string;
+        data: Record<string, unknown>;
+        createdAt: Date;
+        updatedAt: Date;
+    }[];
+    payments: {
+        id: string;
+        bookingId: string;
+        kind: import("../../booking/ledger.js").PaymentKind;
+        amount: number;
+        status: import("../../booking/ledger.js").PaymentStatus;
+        providerRef: string | null;
+        paymentLink: string | null;
+        createdBy: string;
+        paidAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }[];
+    reminders: {
+        id: string;
+        bookingId: string;
+        type: string;
+        templateKey: string;
+        scheduledFor: Date;
+        sentAt: Date | null;
+        createdAt: Date;
+    }[];
+    adjustments: {
+        id: string;
+        bookingId: string;
+        kind: import("../../booking/adjustments.js").AdjustmentKind;
+        amount: number;
+        label: string;
+        reason: string | null;
+        createdBy: string;
+        createdAt: Date;
+        voidedAt: Date | null;
+        voidedBy: string | null;
+    }[];
+    ageFlag: import("../../booking/participant-fields/types.js").AgeFlagConfig | null;
+    /**
+     * Anchor-date key inside the `customer` bag. The only piece of that bag's semantics the
+     * core knows on its own — everything else the customer panel infers from values.
+     */
+    arrivalDateField: string | null;
+    /** Optional presentation hints for the `customer` bag (labels + `birthDate` role). */
+    customerFields: FieldDef[];
+} | null>;
+/** Published catalog trips for the staff item-editor picker (ref + best-effort title). @public */
+export declare const listBookingCatalog: import("@sveltejs/kit").RemoteQueryFunction<void, {
+    ref: string;
+    title: string;
+}[]>;
+/** Staff: create a booking from the admin panel. @public */
+export declare const createBookingStaff: import("@sveltejs/kit").RemoteCommand<any, Promise<{
+    booking: typeof bookingsTable.$inferSelect;
+    accessToken: string;
+}>>;
+/** Staff: edit a booking's items/customer (full edit power). @public */
+export declare const editBookingStaff: import("@sveltejs/kit").RemoteCommand<{
+    bookingId: string;
+    changes: any;
+}, Promise<{
+    number: string;
+    id: string;
+    createdAt: Date;
+    status: BookingStatus;
+    currency: string;
+    language: string | null;
+    accessToken: string;
+    deletedAt: Date | null;
+    deletedBy: string | null;
+    updatedAt: Date;
+    customer: Record<string, unknown>;
+    totals: import("../../db-postgres/schema/booking/index.js").BookingTotals;
+    staffNotes: string | null;
+    balanceDueAt: Date | null;
+    holdExpiresAt: Date | null;
+    cancelReason: string | null;
+}>>;
+/** Staff: generate an installment/balance payment link for any amount. @public */
+export declare const addPaymentLink: import("@sveltejs/kit").RemoteCommand<{
+    bookingId: string;
+    amount: number;
+}, Promise<{
+    paymentLink: string | null;
+}>>;
+/** Staff: record a manual cash payment. @public */
+export declare const recordCashPayment: import("@sveltejs/kit").RemoteCommand<{
+    bookingId: string;
+    amount: number;
+}, Promise<{
+    ok: boolean;
+}>>;
+/** Staff: refund a paid ledger entry via the adapter. @public */
+export declare const refundBookingPayment: import("@sveltejs/kit").RemoteCommand<{
+    paymentId: string;
+    amount?: number | undefined;
+}, Promise<{
+    ok: boolean;
+}>>;
+/** Staff: change booking status (validated transition). @public */
+export declare const changeBookingStatus: import("@sveltejs/kit").RemoteCommand<{
+    bookingId: string;
+    to: string;
+}, Promise<{
+    ok: boolean;
+}>>;
+/** Staff: cancel a booking (manual). @public */
+export declare const cancelBooking: import("@sveltejs/kit").RemoteCommand<{
+    bookingId: string;
+    reason?: "manual" | undefined;
+}, Promise<{
+    ok: boolean;
+}>>;
+/** Staff: send a transactional booking email manually. @public */
+export declare const sendBookingEmailCmd: import("@sveltejs/kit").RemoteCommand<{
+    bookingId: string;
+    kind: string;
+}, Promise<{
+    ok: boolean;
+}>>;
+/** Staff: edit a participant's custom-field data (schema-validated). @public */
+export declare const updateParticipantData: import("@sveltejs/kit").RemoteCommand<{
+    participantId: string;
+    data: Record<string, unknown>;
+}, Promise<{
+    ok: boolean;
+}>>;
+/** Staff: add a manual adjustment (surcharge/discount). Amount is a positive magnitude in minor units. @public */
+export declare const addAdjustment: import("@sveltejs/kit").RemoteCommand<{
+    bookingId: string;
+    kind: "manual_surcharge" | "manual_discount";
+    amount: number;
+    label: string;
+    reason?: string | undefined;
+}, Promise<{
+    ok: boolean;
+}>>;
+/** Staff: void (soft-delete) a manual adjustment. @public */
+export declare const voidAdjustment: import("@sveltejs/kit").RemoteCommand<{
+    adjustmentId: string;
+}, Promise<{
+    ok: boolean;
+}>>;

package/dist/admin/remote/booking.remote.js

@@ -0,0 +1,283 @@
+import { command, query } from '$app/server';
+import z from 'zod';
+import { getCMS } from '../../core/cms.js';
+import { getBookingDb } from '../../booking/server/db.js';
+import { bookingsTable, bookingItemsTable, bookingPersonsTable, bookingItemPersonsTable, bookingPaymentsTable, bookingRemindersTable, bookingAdjustmentsTable } from '../../db-postgres/schema/booking/index.js';
+import { flattenAssignments } from '../../booking/participants-view.js';
+import { and, desc, eq, ilike, inArray, isNull, or, sql } from 'drizzle-orm';
+import { createBooking, editBooking } from '../../booking/server/bookings.js';
+import { createInstallmentPayment, recordCash } from '../../booking/server/payments.js';
+import { addBookingAdjustment as addAdjustmentSvc, voidBookingAdjustment as voidAdjustmentSvc } from '../../booking/server/adjustments.js';
+import { refundPayment } from '../../booking/server/refunds.js';
+import { saveParticipantData } from '../../booking/server/participants.js';
+import { sendBookingEmail } from '../../booking/server/email.js';
+import { assertTransition, BOOKING_STATUSES } from '../../booking/state-machine.js';
+import { resolveParticipantFields } from '../../booking/config.js';
+import { resolveEntry, resolveEntries } from '../../core/server/entries/operations/resolveEntry.js';
+import { requireAuth } from './middleware/auth.js';
+/**
+ * Best-effort display title of a catalog entry. The core does not know the catalog's shape, so it
+ * tries the conventional title-ish keys and falls back to the raw ref. Shared by the item picker
+ * and the booking detail so both name a trip the same way.
+ */
+function catalogTitle(entry, ref) {
+    const title = entry.title ?? entry.name ?? entry._slug;
+    return title ? String(title) : ref;
+}
+/** Whether the booking module is registered. @public */
+export const getBookingEnabled = query(async () => {
+    return getCMS().hasModule('booking');
+});
+/**
+ * Lists active (non-deleted) bookings, newest first — paginated server-side.
+ *
+ * Search spans the booking number AND the `customer` bag. The bag's shape is defined by the
+ * consumer, not by the core, so we match against its text form instead of guessing key names.
+ *
+ * @public
+ */
+export const listBookings = query(z
+    .object({
+    status: z.enum(BOOKING_STATUSES).optional(),
+    search: z.string().optional(),
+    limit: z.number().int().min(1).max(200).default(50),
+    offset: z.number().int().min(0).default(0)
+})
+    .optional(), async (opts) => {
+    requireAuth();
+    if (!getCMS().hasModule('booking'))
+        return { items: [], total: 0 };
+    const { status, search, limit = 50, offset = 0 } = opts ?? {};
+    const db = getBookingDb();
+    const filters = [isNull(bookingsTable.deletedAt)];
+    if (status)
+        filters.push(eq(bookingsTable.status, status));
+    if (search?.trim()) {
+        const term = `%${search.trim()}%`;
+        filters.push(or(ilike(bookingsTable.number, term), sql `${bookingsTable.customer}::text ILIKE ${term}`));
+    }
+    const where = and(...filters);
+    const [items, counted] = await Promise.all([
+        db
+            .select()
+            .from(bookingsTable)
+            .where(where)
+            .orderBy(desc(bookingsTable.createdAt))
+            .limit(limit)
+            .offset(offset),
+        db.select({ count: sql `count(*)::int` }).from(bookingsTable).where(where)
+    ]);
+    return { items, total: counted[0]?.count ?? 0 };
+});
+/**
+ * Aggregate stats for the booking dashboard, computed in SQL.
+ *
+ * Deliberately NOT derived from {@link listBookings}: that query is paginated, so summing its rows
+ * would silently report stats for the first page only.
+ *
+ * @public
+ */
+export const getBookingStats = query(async () => {
+    requireAuth();
+    if (!getCMS().hasModule('booking'))
+        return { active: 0, outstanding: 0, toConfirm: 0, currency: 'PLN' };
+    const db = getBookingDb();
+    const cfg = getCMS().getModuleConfig('booking') ?? null;
+    const [row] = await db
+        .select({
+        active: sql `count(*)::int`,
+        outstanding: sql `coalesce(sum((${bookingsTable.totals}->>'balance')::bigint), 0)::bigint`,
+        toConfirm: sql `count(*) filter (where ${bookingsTable.status} in ('draft','reserved'))::int`
+    })
+        .from(bookingsTable)
+        .where(isNull(bookingsTable.deletedAt));
+    return {
+        active: row?.active ?? 0,
+        outstanding: Number(row?.outstanding ?? 0),
+        toConfirm: row?.toConfirm ?? 0,
+        currency: cfg?.currency ?? 'PLN'
+    };
+});
+/** Full booking detail (booking + items + participants + ledger + reminders). @public */
+export const getBooking = query(z.string().uuid(), async (id) => {
+    requireAuth();
+    if (!getCMS().hasModule('booking'))
+        return null;
+    const db = getBookingDb();
+    const [booking] = await db
+        .select()
+        .from(bookingsTable)
+        .where(and(eq(bookingsTable.id, id), isNull(bookingsTable.deletedAt)));
+    if (!booking)
+        return null;
+    const items = await db.select().from(bookingItemsTable).where(eq(bookingItemsTable.bookingId, id));
+    const itemIds = items.map((i) => i.id);
+    const persons = await db
+        .select()
+        .from(bookingPersonsTable)
+        .where(eq(bookingPersonsTable.bookingId, id));
+    const assignments = itemIds.length
+        ? await db
+            .select()
+            .from(bookingItemPersonsTable)
+            .where(inArray(bookingItemPersonsTable.itemId, itemIds))
+        : [];
+    const participants = flattenAssignments(persons, assignments);
+    const payments = await db
+        .select()
+        .from(bookingPaymentsTable)
+        .where(eq(bookingPaymentsTable.bookingId, id));
+    const reminders = await db
+        .select()
+        .from(bookingRemindersTable)
+        .where(eq(bookingRemindersTable.bookingId, id));
+    const adjustments = await db
+        .select()
+        .from(bookingAdjustmentsTable)
+        .where(eq(bookingAdjustmentsTable.bookingId, id))
+        .orderBy(desc(bookingAdjustmentsTable.createdAt));
+    // Resolve the participant-field schema AND a display title per catalog entry (booking-agnostic).
+    const cfg = getCMS().getModuleConfig('booking') ?? null;
+    const ageFlag = cfg?.ageFlag ?? null;
+    // Resolve whenever a catalog exists: staff must see the trip's NAME, not its uuid.
+    const needsEntry = cfg != null && cfg.catalogCollection != null;
+    const schemaByRef = new Map();
+    const titleByRef = new Map();
+    if (cfg) {
+        for (const ref of new Set(items.map((i) => i.tripRef))) {
+            let entry = {};
+            if (needsEntry) {
+                const resolved = await resolveEntry({ id: ref, status: 'published' });
+                if (resolved)
+                    entry = resolved;
+            }
+            schemaByRef.set(ref, resolveParticipantFields(cfg, entry));
+            titleByRef.set(ref, catalogTitle(entry, ref));
+        }
+    }
+    const itemsWithSchema = items.map((i) => ({
+        ...i,
+        participantFields: schemaByRef.get(i.tripRef) ?? [],
+        /** Human title of the catalog entry; falls back to the raw ref when unresolvable. */
+        tripTitle: titleByRef.get(i.tripRef) ?? i.tripRef
+    }));
+    return {
+        booking,
+        items: itemsWithSchema,
+        participants,
+        persons,
+        assignments,
+        payments,
+        reminders,
+        adjustments,
+        ageFlag,
+        /**
+         * Anchor-date key inside the `customer` bag. The only piece of that bag's semantics the
+         * core knows on its own — everything else the customer panel infers from values.
+         */
+        arrivalDateField: cfg?.arrivalDateField ?? null,
+        /** Optional presentation hints for the `customer` bag (labels + `birthDate` role). */
+        customerFields: cfg?.customerFields ?? []
+    };
+});
+/** Published catalog trips for the staff item-editor picker (ref + best-effort title). @public */
+export const listBookingCatalog = query(async () => {
+    requireAuth();
+    const cfg = getCMS().getModuleConfig('booking');
+    if (!cfg?.catalogCollection)
+        return [];
+    const entries = await resolveEntries({ collection: cfg.catalogCollection, status: 'published' });
+    return entries.map((e) => {
+        const rec = e;
+        const ref = String(rec._id ?? '');
+        return { ref, title: catalogTitle(rec, ref) };
+    });
+});
+/** Staff: create a booking from the admin panel. @public */
+export const createBookingStaff = command(z.any(), async (input) => {
+    requireAuth();
+    return createBooking(input);
+});
+/** Staff: edit a booking's items/customer (full edit power). @public */
+export const editBookingStaff = command(z.object({ bookingId: z.string().uuid(), changes: z.any() }), async ({ bookingId, changes }) => {
+    requireAuth();
+    return editBooking(bookingId, changes, { actor: 'staff' });
+});
+/** Staff: generate an installment/balance payment link for any amount. @public */
+export const addPaymentLink = command(z.object({ bookingId: z.string().uuid(), amount: z.number().int().positive() }), async ({ bookingId, amount }) => {
+    requireAuth();
+    const result = await createInstallmentPayment(bookingId, amount);
+    if (result.paymentLink) {
+        await sendBookingEmail(bookingId, 'payment-link', {
+            amount,
+            paymentLink: result.paymentLink
+        }).catch((e) => console.error('[booking] payment-link email failed', e));
+    }
+    return result;
+});
+/** Staff: record a manual cash payment. @public */
+export const recordCashPayment = command(z.object({ bookingId: z.string().uuid(), amount: z.number().int().positive() }), async ({ bookingId, amount }) => {
+    requireAuth();
+    await recordCash(bookingId, amount);
+    return { ok: true };
+});
+/** Staff: refund a paid ledger entry via the adapter. @public */
+export const refundBookingPayment = command(z.object({ paymentId: z.string().uuid(), amount: z.number().int().positive().optional() }), async ({ paymentId, amount }) => {
+    requireAuth();
+    await refundPayment(paymentId, amount);
+    return { ok: true };
+});
+/** Staff: change booking status (validated transition). @public */
+export const changeBookingStatus = command(z.object({ bookingId: z.string().uuid(), to: z.string() }), async ({ bookingId, to }) => {
+    requireAuth();
+    const db = getBookingDb();
+    const [b] = await db.select().from(bookingsTable).where(eq(bookingsTable.id, bookingId));
+    if (!b)
+        throw new Error('Booking not found');
+    assertTransition(b.status, to); // throws BookingStateError on illegal move
+    await db
+        .update(bookingsTable)
+        .set({ status: to, updatedAt: new Date() })
+        .where(eq(bookingsTable.id, bookingId));
+    return { ok: true };
+});
+/** Staff: cancel a booking (manual). @public */
+export const cancelBooking = command(z.object({ bookingId: z.string().uuid(), reason: z.enum(['manual']).default('manual') }), async ({ bookingId, reason }) => {
+    requireAuth();
+    const db = getBookingDb();
+    await db
+        .update(bookingsTable)
+        .set({ status: 'cancelled', cancelReason: reason, updatedAt: new Date() })
+        .where(eq(bookingsTable.id, bookingId));
+    return { ok: true };
+});
+/** Staff: send a transactional booking email manually. @public */
+export const sendBookingEmailCmd = command(z.object({ bookingId: z.string().uuid(), kind: z.string() }), async ({ bookingId, kind }) => {
+    requireAuth();
+    await sendBookingEmail(bookingId, kind);
+    return { ok: true };
+});
+/** Staff: edit a participant's custom-field data (schema-validated). @public */
+export const updateParticipantData = command(z.object({ participantId: z.string().uuid(), data: z.record(z.string(), z.unknown()) }), async ({ participantId, data }) => {
+    requireAuth();
+    await saveParticipantData(participantId, data, 'staff');
+    return { ok: true };
+});
+/** Staff: add a manual adjustment (surcharge/discount). Amount is a positive magnitude in minor units. @public */
+export const addAdjustment = command(z.object({
+    bookingId: z.string().uuid(),
+    kind: z.enum(['manual_surcharge', 'manual_discount']),
+    amount: z.number().int().positive(),
+    label: z.string().min(1),
+    reason: z.string().optional()
+}), async ({ bookingId, kind, amount, label, reason }) => {
+    const { user } = requireAuth();
+    await addAdjustmentSvc(bookingId, { kind, magnitude: amount, label, reason }, { actor: user.email ?? 'staff' });
+    return { ok: true };
+});
+/** Staff: void (soft-delete) a manual adjustment. @public */
+export const voidAdjustment = command(z.object({ adjustmentId: z.string().uuid() }), async ({ adjustmentId }) => {
+    const { user } = requireAuth();
+    await voidAdjustmentSvc(adjustmentId, { actor: user.email ?? 'staff' });
+    return { ok: true };
+});

package/dist/admin/remote/entry.remote.d.ts

@@ -90,6 +90,9 @@ export declare const updateEntryCommand: import("@sveltejs/kit").RemoteCommand<{
 export declare const archiveEntryCommand: import("@sveltejs/kit").RemoteCommand<string, Promise<import("../../types/entries.js").DbEntry>>;
 export declare const unarchiveEntryCommand: import("@sveltejs/kit").RemoteCommand<string, Promise<import("../../types/entries.js").DbEntry>>;
 export declare const deleteEntryCommand: import("@sveltejs/kit").RemoteCommand<string, Promise<void>>;
+export declare const duplicateEntryCommand: import("@sveltejs/kit").RemoteCommand<string, Promise<{
+    id: string;
+}>>;
 export declare const reorderEntriesCommand: import("@sveltejs/kit").RemoteCommand<{
     orderedIds: string[];
     collectionSlug: string;

package/dist/admin/remote/entry.remote.js

@@ -6,11 +6,13 @@ import { db } from '../../server/db/index.js';
 import { user } from '../../server/db/schema/auth-schema.js';
 import { inArray } from 'drizzle-orm';
 import { createEntry as createEntryOperation, createEntrySchema, createEntryVersion } from '../../core/server/entries/operations/create.js';
-import { _getRawEntries as getRawEntriesOperation, _countRawEntries as countRawEntriesOperation, _getRawEntry as getRawEntryOperation, _getRawEntryOrThrow as getRawEntryOrThrow, _getDbEntry as getDbEntry, getEntryVersion as getEntryVersionOperation, getEntryLabels as getEntryLabelsOperation } from '../../core/server/entries/operations/get.js';
+import { _getRawEntries as getRawEntriesOperation, _countRawEntries as countRawEntriesOperation, _getRawEntry as getRawEntryOperation, _getRawEntryOrThrow as getRawEntryOrThrow, _getDbEntry as getDbEntry, _getDbEntryOrThrow as getDbEntryOrThrow, getEntryVersion as getEntryVersionOperation, getEntryLabels as getEntryLabelsOperation } from '../../core/server/entries/operations/get.js';
 import { resolveEntries, resolveEntry } from '../../core/server/entries/operations/resolveEntry.js';
 import { getCMS } from '../../core/cms.js';
 import { getFieldsFromConfig } from '../../core/fields/layoutUtils.js';
 import { pruneOldDraftVersions, unpublishEntryLang, cancelScheduledEntryLang, upsertDraftVersion, updateEntry, updateEntrySchema, updateEntryVersionCommandTypes } from '../../core/server/entries/operations/update.js';
+import { normalizeSlugFields } from '../../core/server/entries/operations/slugNormalize.js';
+import { duplicateEntry } from '../../core/server/entries/operations/duplicate.js';
 import z from 'zod';
 import { requireAuth } from './middleware/auth.js';
 import { stableSlotReorder } from './reorder.js';
@@ -205,6 +207,11 @@ const updateEntryVersionCommandSchema = z.object({
 });
 export const updateEntryVersionCommand = command(updateEntryVersionCommandSchema, async (input) => {
     const { user } = requireAuth();
+    // Normalize slug fields once, before any write path (covers draft in-place
+    // updates and publish). Keeps stored slugs valid regardless of raw input.
+    const entryForSlug = await getDbEntryOrThrow({ id: input.entryId });
+    const config = getCMS().getBySlug(entryForSlug.slug);
+    const data = normalizeSlugFields(config, input.data);
     let result;
     // Publish failures should reach the client with a structured body so the
     // editor can pin the message to the offending field. SvelteKit hides any
@@ -214,7 +221,7 @@ export const updateEntryVersionCommand = command(updateEntryVersionCommandSchema
             return await createEntryVersion({
                 entryId: input.entryId,
                 lang: input.lang,
-                data: input.data,
+                data,
                 publishedAt,
                 publishedBy: user.id
             });
@@ -232,7 +239,7 @@ export const updateEntryVersionCommand = command(updateEntryVersionCommandSchema
     };
     switch (input.type) {
         case 'draft':
-            result = await upsertDraftVersion(input.entryId, input.data, input.lang, { skipValidation: true });
+            result = await upsertDraftVersion(input.entryId, data, input.lang, { skipValidation: true });
             break;
         case 'published-now': {
             result = await runPublish(new Date());
@@ -289,6 +296,10 @@ export const deleteEntryCommand = command(z.string().uuid(), async (id) => {
     }
     return getCMS().databaseAdapter.deleteEntry({ id });
 });
+export const duplicateEntryCommand = command(z.string().uuid(), async (id) => {
+    requireAuth();
+    return duplicateEntry(id);
+});
 export const reorderEntriesCommand = command(z.object({
     orderedIds: z.array(z.string().uuid()),
     collectionSlug: z.string()

package/dist/admin/remote/index.d.ts

@@ -9,4 +9,6 @@ export * from './ai.remote.js';
 export * from './preview.remote.js';
 export * from './email.remote.js';
 export * from './shop.remote.js';
+export * from './booking.remote.js';
+export * from './modules.remote.js';
 export * from './admin.remote.js';

package/dist/admin/remote/index.js

@@ -9,4 +9,6 @@ export * from './ai.remote.js';
 export * from './preview.remote.js';
 export * from './email.remote.js';
 export * from './shop.remote.js';
+export * from './booking.remote.js';
+export * from './modules.remote.js';
 export * from './admin.remote.js';

package/dist/admin/remote/modules.remote.d.ts

@@ -0,0 +1,10 @@
+import { type CMSModuleDescriptor } from '../../types/modules.js';
+/**
+ * Returns the serializable descriptors of all registered modules (shop,
+ * booking, …) — id, label, icon, and context (nav sections + surfaced
+ * collections). Strips server-only `serverHooks` and the opaque `config`
+ * (which may carry adapter functions). Powers the admin context switcher and
+ * the generic module nav.
+ * @public
+ */
+export declare const getModules: import("@sveltejs/kit").RemoteQueryFunction<void, CMSModuleDescriptor[]>;

package/dist/admin/remote/modules.remote.js

@@ -0,0 +1,14 @@
+import { query } from '$app/server';
+import { getCMS } from '../../core/cms.js';
+import { toModuleDescriptor } from '../../types/modules.js';
+/**
+ * Returns the serializable descriptors of all registered modules (shop,
+ * booking, …) — id, label, icon, and context (nav sections + surfaced
+ * collections). Strips server-only `serverHooks` and the opaque `config`
+ * (which may carry adapter functions). Powers the admin context switcher and
+ * the generic module nav.
+ * @public
+ */
+export const getModules = query(async () => {
+    return Array.from(getCMS().modules.values()).map(toModuleDescriptor);
+});

package/dist/admin/state/active-context-resolve.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Active admin context resolution. Pure, deterministic, framework-free so it can
+ * be unit-tested without the browser/runed state.
+ *
+ * Precedence (highest first):
+ *  1. **Unambiguous module path** — `/admin/{id}` or `/admin/{id}/...` always
+ *     wins, so a deep-link to `/admin/shop/orders` shows the shop context
+ *     regardless of stored state.
+ *  2. **`?ctx=` query** — explicit intent, used when linking a surfaced core
+ *     collection (`/admin/collections/{slug}?ctx=shop`) whose path doesn't
+ *     encode a context.
+ *  3. **Content-core path** — the dashboard (`/admin`) and core CMS sections
+ *     (collections, singles, entries, forms) resolve to content. Neutral/global
+ *     routes (media, users, account, maintenance) are excluded: they fall through
+ *     to the stored sticky context so they stay inside the active module workspace.
+ *  4. **Stored sticky** — the last context the user switched to (covers
+ *     ambiguous routes like the entry editor `/admin/entries/{id}`).
+ *  5. **Content** — the default CMS core workspace.
+ */
+/** The base CMS-core context (content editing). */
+export declare const CONTENT_CONTEXT = "content";
+/** Whether `pathname` is the dashboard or a core CMS section (not a module). */
+export declare function isContentCorePath(pathname: string): boolean;
+export interface ResolveActiveContextInput {
+    /** Value of the `ctx` query param, or null/undefined. */
+    ctxQuery?: string | null;
+    /** Persisted "sticky" context, or null/undefined. */
+    stored?: string | null;
+    /** Current pathname, e.g. `/admin/shop/orders`. */
+    pathname: string;
+    /** Ids of registered modules, e.g. `['shop', 'booking']`. */
+    moduleIds: string[];
+}
+/** Whether `pathname` is the landing or a sub-route of module `id`. */
+export declare function isModulePath(pathname: string, id: string): boolean;
+/** Resolves the active context id from URL, stored state, and module registry. */
+export declare function resolveActiveContext(input: ResolveActiveContextInput): string;