includio-cms 0.36.8 → 0.37.0

package/dist/admin/state/active-context-resolve.js

@@ -0,0 +1,66 @@
+/**
+ * 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 const CONTENT_CONTEXT = 'content';
+/**
+ * Route prefixes owned by the content (CMS core) context. Navigating to one of
+ * these from a module context exits back to content. **Neutral/global** routes
+ * (`/admin/media|users|account|maintenance`) are deliberately NOT here: they are
+ * reachable from every context, so they keep the `stored` sticky context instead
+ * of forcing content.
+ */
+const CONTENT_CORE_PREFIXES = [
+    '/admin/collections',
+    '/admin/singles',
+    '/admin/entries',
+    '/admin/forms'
+];
+/** Whether `pathname` is the dashboard or a core CMS section (not a module). */
+export function isContentCorePath(pathname) {
+    if (pathname === '/admin' || pathname === '/admin/')
+        return true;
+    return CONTENT_CORE_PREFIXES.some((p) => pathname === p || pathname.startsWith(p + '/'));
+}
+/** Whether `pathname` is the landing or a sub-route of module `id`. */
+export function isModulePath(pathname, id) {
+    const base = `/admin/${id}`;
+    return pathname === base || pathname.startsWith(base + '/');
+}
+/** Resolves the active context id from URL, stored state, and module registry. */
+export function resolveActiveContext(input) {
+    const { ctxQuery, stored, pathname, moduleIds } = input;
+    // 1. Unambiguous module path wins (deep-link correctness).
+    for (const id of moduleIds) {
+        if (isModulePath(pathname, id))
+            return id;
+    }
+    const isValid = (id) => !!id && (id === CONTENT_CONTEXT || moduleIds.includes(id));
+    // 2. Explicit ?ctx intent.
+    if (isValid(ctxQuery))
+        return ctxQuery;
+    // 3. Content-core path → content (dashboard / collections / media / …).
+    if (isContentCorePath(pathname))
+        return CONTENT_CONTEXT;
+    // 4. Sticky stored context.
+    if (isValid(stored))
+        return stored;
+    // 5. Default to content.
+    return CONTENT_CONTEXT;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Reactive active-context id. Reads the URL (pathname + `?ctx`) and the sticky
+ * store. Call inside a `$derived`/`$effect` so it tracks `page` + store changes.
+ */
+export declare function getActiveContext(moduleIds: string[]): string;
+/** Persists the user's context choice (called by the context switcher). */
+export declare function setActiveContext(id: string): void;
+export { CONTENT_CONTEXT } from './active-context-resolve.js';

package/dist/admin/state/active-context.svelte.js

@@ -0,0 +1,27 @@
+import { PersistedState } from 'runed';
+import { page } from '$app/state';
+import { resolveActiveContext, CONTENT_CONTEXT } from './active-context-resolve.js';
+/**
+ * Persisted "sticky" admin context. Survives navigation to ambiguous routes
+ * (e.g. the entry editor of a surfaced collection) so the workspace doesn't
+ * flicker back to content. Module deep-links and `?ctx=` still take precedence
+ * — see {@link resolveActiveContext}.
+ */
+const stored = new PersistedState('admin-active-context', CONTENT_CONTEXT);
+/**
+ * Reactive active-context id. Reads the URL (pathname + `?ctx`) and the sticky
+ * store. Call inside a `$derived`/`$effect` so it tracks `page` + store changes.
+ */
+export function getActiveContext(moduleIds) {
+    return resolveActiveContext({
+        ctxQuery: page.url.searchParams.get('ctx'),
+        stored: stored.current,
+        pathname: page.url.pathname,
+        moduleIds
+    });
+}
+/** Persists the user's context choice (called by the context switcher). */
+export function setActiveContext(id) {
+    stored.current = id;
+}
+export { CONTENT_CONTEXT } from './active-context-resolve.js';

package/dist/booking/adjustments.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Manual booking adjustments — staff-entered surcharges (e.g. e-bike +200) and
+ * negotiated discounts, kept OUTSIDE the rule engine so a pricing recompute
+ * never wipes them. Signed minor units: surcharge > 0, discount < 0. Pure.
+ */
+export type AdjustmentKind = 'manual_surcharge' | 'manual_discount';
+export interface BookingAdjustment {
+    id: string;
+    bookingId: string;
+    kind: AdjustmentKind;
+    /** Signed minor units: surcharge > 0, discount < 0. */
+    amount: number;
+    label: string;
+    reason: string | null;
+    createdBy: string;
+    createdAt: Date;
+    /** Soft-void: set → excluded from recompute, kept for audit. */
+    voidedAt: Date | null;
+    voidedBy: string | null;
+}
+export interface AdjustmentSums {
+    /** Σ positive amounts of active surcharges. */
+    surcharge: number;
+    /** Σ magnitudes of active discounts (positive). */
+    manualDiscount: number;
+}
+export declare const NO_ADJUSTMENTS: AdjustmentSums;
+/** Convert a UI-entered positive magnitude + kind into a signed stored amount. */
+export declare function signedAmount(kind: AdjustmentKind, magnitude: number): number;
+/** Fold active (non-voided) adjustments into totals contributions. By sign. */
+export declare function sumAdjustments(rows: Pick<BookingAdjustment, 'amount' | 'voidedAt'>[]): AdjustmentSums;
+/** Reject a zero/negative magnitude at the write boundary. */
+export declare function assertAdjustmentMagnitude(magnitude: number): void;

package/dist/booking/adjustments.js

@@ -0,0 +1,26 @@
+export const NO_ADJUSTMENTS = { surcharge: 0, manualDiscount: 0 };
+/** Convert a UI-entered positive magnitude + kind into a signed stored amount. */
+export function signedAmount(kind, magnitude) {
+    const m = Math.abs(magnitude);
+    return kind === 'manual_discount' ? -m : m;
+}
+/** Fold active (non-voided) adjustments into totals contributions. By sign. */
+export function sumAdjustments(rows) {
+    let surcharge = 0;
+    let manualDiscount = 0;
+    for (const r of rows) {
+        if (r.voidedAt)
+            continue;
+        if (r.amount >= 0)
+            surcharge += r.amount;
+        else
+            manualDiscount += -r.amount;
+    }
+    return { surcharge, manualDiscount };
+}
+/** Reject a zero/negative magnitude at the write boundary. */
+export function assertAdjustmentMagnitude(magnitude) {
+    if (!Number.isFinite(magnitude) || magnitude <= 0) {
+        throw new Error(`Adjustment magnitude must be a positive amount, got ${magnitude}`);
+    }
+}

package/dist/booking/capacity.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Decide whether `requested` seats fit a trip. `capacity == null` means
+ * unlimited (no catalog capacity configured) → always ok. Pure.
+ */
+export declare function decideCapacity(input: {
+    capacity: number | null;
+    alreadyBooked: number;
+    requested: number;
+}): {
+    ok: boolean;
+    available: number | null;
+};

package/dist/booking/capacity.js

@@ -0,0 +1,10 @@
+/**
+ * Decide whether `requested` seats fit a trip. `capacity == null` means
+ * unlimited (no catalog capacity configured) → always ok. Pure.
+ */
+export function decideCapacity(input) {
+    if (input.capacity == null)
+        return { ok: true, available: null };
+    const available = input.capacity - input.alreadyBooked;
+    return { ok: input.requested <= available, available };
+}

package/dist/booking/client/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Browser SDK for the booking storefront + self-service portal. Thin fetch
+ * wrappers over the booking HTTP handlers. Isomorphic — no server imports.
+ *
+ * @public
+ */
+export interface BookingClientOptions {
+    /** Base URL prefix (default ''), e.g. when the API is on another origin. */
+    baseUrl?: string;
+    /** Custom fetch (e.g. SvelteKit's `fetch` during SSR). Defaults to global. */
+    fetch?: typeof globalThis.fetch;
+}
+/** Error thrown on a non-2xx response; `code` carries the server's error code. */
+export declare class BookingClientError extends Error {
+    code?: string;
+    constructor(message: string, code?: string);
+}
+/** Create a booking API client bound to a base URL + fetch. @public */
+export declare function createBookingClient(opts?: BookingClientOptions): {
+    /** Create a booking (public self-serve). Returns deposit redirect info. */
+    create: (input: unknown) => Promise<unknown>;
+    /** Fetch the portal view for an access token. */
+    getByToken: (token: string) => Promise<unknown>;
+    /** Self-service edit; rejects with `code: 'CONTACT_STAFF'` on below-paid edits. */
+    edit: (token: string, changes: unknown) => Promise<unknown>;
+    /** Create an installment/balance payment link. */
+    pay: (token: string, amount: number) => Promise<unknown>;
+    /** Self-service: save a participant's custom-field data (staff fields ignored). */
+    updateParticipant: (token: string, participantId: string, data: Record<string, unknown>) => Promise<unknown>;
+    /** Drugi czynnik: weryfikuj numer telefonu; sukces ustawia sesję portalu (cookie). */
+    verifyPhone: (token: string, phone: string) => Promise<unknown>;
+    /** Self-service: dołóż wycieczki istniejącym osobom (recompute salda). */
+    addTrips: (token: string, additions: Array<{
+        tripRef: string;
+        unitPrice: number;
+        assignments: string[];
+    }>) => Promise<unknown>;
+};
+export { useBooking } from './use-booking.svelte.js';

package/dist/booking/client/index.js

@@ -0,0 +1,44 @@
+/** Error thrown on a non-2xx response; `code` carries the server's error code. */
+export class BookingClientError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = 'BookingClientError';
+        this.code = code;
+    }
+}
+/** Create a booking API client bound to a base URL + fetch. @public */
+export function createBookingClient(opts = {}) {
+    const base = opts.baseUrl ?? '';
+    const f = opts.fetch ?? globalThis.fetch;
+    async function req(path, init) {
+        const res = await f(`${base}${path}`, init);
+        const data = (await res.json().catch(() => ({})));
+        if (!res.ok) {
+            throw new BookingClientError(typeof data.error === 'string' ? data.error : `HTTP ${res.status}`, typeof data.code === 'string' ? data.code : undefined);
+        }
+        return data;
+    }
+    const jsonInit = (method, body) => ({
+        method,
+        headers: { 'content-type': 'application/json' },
+        body: body === undefined ? undefined : JSON.stringify(body)
+    });
+    return {
+        /** Create a booking (public self-serve). Returns deposit redirect info. */
+        create: (input) => req('/api/booking', jsonInit('POST', input)),
+        /** Fetch the portal view for an access token. */
+        getByToken: (token) => req(`/api/booking/portal/${token}`, jsonInit('GET')),
+        /** Self-service edit; rejects with `code: 'CONTACT_STAFF'` on below-paid edits. */
+        edit: (token, changes) => req(`/api/booking/portal/${token}?action=edit`, jsonInit('POST', changes)),
+        /** Create an installment/balance payment link. */
+        pay: (token, amount) => req(`/api/booking/portal/${token}?action=pay`, jsonInit('POST', { amount })),
+        /** Self-service: save a participant's custom-field data (staff fields ignored). */
+        updateParticipant: (token, participantId, data) => req(`/api/booking/portal/${token}?action=participant`, jsonInit('POST', { participantId, data })),
+        /** Drugi czynnik: weryfikuj numer telefonu; sukces ustawia sesję portalu (cookie). */
+        verifyPhone: (token, phone) => req(`/api/booking/portal/${token}?action=verify-phone`, jsonInit('POST', { phone })),
+        /** Self-service: dołóż wycieczki istniejącym osobom (recompute salda). */
+        addTrips: (token, additions) => req(`/api/booking/portal/${token}?action=add-trips`, jsonInit('POST', { additions }))
+    };
+}
+export { useBooking } from './use-booking.svelte.js';

package/dist/booking/client/use-booking.svelte.d.ts

@@ -0,0 +1,25 @@
+import { type BookingClientOptions } from './index.js';
+/**
+ * Reactive self-service portal state for a booking access token. Loads the view
+ * on creation; `edit`/`reload` refresh it, `pay` returns a payment link. Errors
+ * (including `CONTACT_STAFF` 409s) surface via `error`. A `PHONE_REQUIRED` 2FA
+ * gate surfaces via `needsPhone`; call `verifyPhone` to clear it and re-load the
+ * view.
+ *
+ * @public
+ */
+export declare function useBooking(token: string, opts?: BookingClientOptions): {
+    readonly view: unknown;
+    readonly loading: boolean;
+    readonly error: string | null;
+    readonly needsPhone: boolean;
+    reload: () => Promise<void>;
+    edit: (changes: unknown) => Promise<void>;
+    pay: (amount: number) => Promise<unknown>;
+    verifyPhone: (phone: string) => Promise<void>;
+    addTrips: (additions: Array<{
+        tripRef: string;
+        unitPrice: number;
+        assignments: string[];
+    }>) => Promise<void>;
+};

package/dist/booking/client/use-booking.svelte.js

@@ -0,0 +1,56 @@
+import { createBookingClient, BookingClientError } from './index.js';
+/**
+ * Reactive self-service portal state for a booking access token. Loads the view
+ * on creation; `edit`/`reload` refresh it, `pay` returns a payment link. Errors
+ * (including `CONTACT_STAFF` 409s) surface via `error`. A `PHONE_REQUIRED` 2FA
+ * gate surfaces via `needsPhone`; call `verifyPhone` to clear it and re-load the
+ * view.
+ *
+ * @public
+ */
+export function useBooking(token, opts = {}) {
+    const client = createBookingClient(opts);
+    let view = $state(null);
+    let loading = $state(false);
+    let error = $state(null);
+    let needsPhone = $state(false);
+    async function run(fn) {
+        loading = true;
+        error = null;
+        try {
+            view = await fn();
+            needsPhone = false;
+        }
+        catch (e) {
+            if (e instanceof BookingClientError && e.code === 'PHONE_REQUIRED') {
+                needsPhone = true;
+            }
+            else {
+                error = e instanceof Error ? e.message : 'Error';
+            }
+        }
+        finally {
+            loading = false;
+        }
+    }
+    run(() => client.getByToken(token));
+    return {
+        get view() {
+            return view;
+        },
+        get loading() {
+            return loading;
+        },
+        get error() {
+            return error;
+        },
+        get needsPhone() {
+            return needsPhone;
+        },
+        reload: () => run(() => client.getByToken(token)),
+        edit: (changes) => run(() => client.edit(token, changes)),
+        pay: (amount) => client.pay(token, amount),
+        verifyPhone: (phone) => run(() => client.verifyPhone(token, phone)),
+        addTrips: (additions) => run(() => client.addTrips(token, additions))
+    };
+}

package/dist/booking/config.d.ts

@@ -0,0 +1,156 @@
+import type { PaymentAdapter } from '../shop/types.js';
+import type { PricingConfig } from './pricing.js';
+import type { ParticipantPricingConfig } from './participant-pricing.js';
+import type { FieldDef, AgeFlagConfig } from './participant-fields/types.js';
+/** One scheduled reminder rule, relative to the earliest departure date. */
+export interface ReminderRule {
+    /** Stable type tag for the reminder (e.g. `pre-departure`). */
+    type: string;
+    /** Whole days before departure to send. */
+    daysBefore: number;
+    /** Email template key to render (see booking email registry). */
+    templateKey: string;
+}
+/** Context handed to the client-supplied {@link BookingValidator} seam. */
+export interface BookingValidationContext {
+    operation: 'create' | 'edit';
+    bookingId: string | null;
+    items: Array<{
+        tripRef: string;
+        departureDate: Date | null;
+        participantsCount: number;
+    }>;
+    customer: Record<string, unknown>;
+}
+/**
+ * Client-specific validation seam (e.g. weekly-model term conflicts). Throws to
+ * reject. The framework only enforces generic capacity + not-below-paid.
+ */
+export type BookingValidator = (ctx: BookingValidationContext) => void | Promise<void>;
+/**
+ * User-facing booking configuration. Passed to `defineBooking` and registered
+ * via `defineConfig({ modules: [defineBooking({...})] })`.
+ *
+ * @public
+ */
+export interface BookingConfig {
+    /** ISO currency code, e.g. `PLN`. */
+    currency: string;
+    /** Slug of the (client-specific) trip catalog collection. Omit when none. */
+    catalogCollection?: string;
+    /**
+     * Dodatkowe kolekcje rdzenia wciągane do kontekstu „Rezerwacje" w adminie (obok katalogu) —
+     * np. kolekcja definiująca typy wypraw i pola uczestnika. Bez tego mieszkają w kontekście
+     * „Treści" i wyglądają jak doszyta kolekcja CMS-a, choć obsługują rezerwacje.
+     *
+     * Wyłącznie prezentacja: nie zmienia danych ani uprawnień.
+     *
+     * @experimental Docelowo moduł będzie wnosił typy wypraw sam (0.38) — patrz ROADMAP.
+     */
+    surfacedCollections?: string[];
+    /** Deposit that secures a reservation, in minor units (default 0). */
+    depositAmount?: number;
+    /** Discount rules (legacy per-line engine; booking now prices per-participant). */
+    pricing?: PricingConfig;
+    /**
+     * Per-participant pricing config (age bands + volume ladder + early-bird) as a
+     * resolver so values can come from an editable CMS singleton (globalSettings).
+     * Called per create/edit. Omit ⇒ no age/volume discounts (everyone full price).
+     */
+    participantPricing?: () => ParticipantPricingConfig | Promise<ParticipantPricingConfig>;
+    /** Customer field holding the arrival date — anchor for age + early-bird + reminders. Default `arrivalDate`. */
+    arrivalDateField?: string;
+    /** Payment adapters (reused from the shop module's adapter family). */
+    payment?: PaymentAdapter[];
+    /**
+     * Portal URL template handed to payment adapters as the post-payment return
+     * URL. Placeholder `{token}` → `booking.accessToken`. Must be absolute, e.g.
+     * `https://shop.example/rezerwacja/{token}`. Omit to disable redirect return.
+     */
+    portalUrlTemplate?: string;
+    /**
+     * Absolute return URL for the CHECKOUT deposit payment (post-payment landing,
+     * e.g. a thank-you page), when it should differ from the portal. Handed to the
+     * adapter as `ctx.continueUrl` for the deposit only; installments/balance keep
+     * `portalUrlTemplate`. Omit ⇒ deposit returns to the portal like other payments.
+     */
+    checkoutReturnUrl?: string;
+    /** Operator address for staff notifications. */
+    adminEmail?: string;
+    /** Business display name shown in transactional email footers; omit for none. */
+    brand?: string;
+    /** Minutes an unpaid draft is held before auto-cancel (default 60). */
+    depositTtlMinutes?: number;
+    /** Days before departure the balance is due; omit to disable forfeiture. */
+    balanceDueDaysBefore?: number;
+    /** Field on the catalog entry holding seat capacity; omit for unlimited. */
+    capacityField?: string;
+    /** Reminder schedule (offsets before departure). */
+    reminders?: ReminderRule[];
+    /** Client-specific validation seam. */
+    validateBooking?: BookingValidator;
+    /** In-process maintenance loop tuning. */
+    maintenance?: {
+        autoRun?: boolean;
+        intervalMinutes?: number;
+    };
+    /** Bearer token guarding the secured maintenance endpoint; omit to disable. */
+    maintenanceToken?: string;
+    /** Sekret HMAC dla sesji portalu (2FA telefonem); omit ⇒ portal fail-closed. */
+    portalSecret?: string;
+    /** Schemat pól uczestnika: statyczny lub resolver per wpis katalogu. */
+    participantFields?: FieldDef[] | ((catalogEntry: Record<string, unknown>) => FieldDef[]);
+    /** Flaga wieku (np. „Dziecko") z pola roli `birthDate` + próg. */
+    ageFlag?: AgeFlagConfig;
+    /**
+     * Opis pól worka `customer` — WYŁĄCZNIE dla prezentacji w adminie. Rdzeń nie zna kształtu
+     * `customer` (definiuje go projekt), więc bez tego panel „Klient" pokazuje uczłowieczone
+     * klucze (`referralSource` → „Referral source"). Podaj `label`, żeby nazwać pola po ludzku,
+     * i `role: 'birthDate'`, żeby rdzeń dopisał wiek obok daty.
+     *
+     * Klucze zagnieżdżone (kolumny tabel, np. manifest osób) adresuje się kropką:
+     * `{ key: 'people.birthDate', label: 'Data urodzenia', role: 'birthDate' }`.
+     *
+     * Nie waliduje ani nie zmienia danych — to czysta warstwa prezentacji.
+     *
+     * @experimental Świadomie NIEPEŁNE: pola uczestnika mają w rdzeniu prawdziwy schemat
+     * (`participantFields` — napędza walidację, render i formularz), a `customer` ma dziś tylko
+     * etykiety, bo formularz kontaktowy jest pisany ręcznie w projekcie. Skutek: worek `customer`
+     * ma DWIE deklaracje (etykiety tutaj, reguły w repo projektu) i może się rozjechać. Domknięcie
+     * w 0.38 — patrz ROADMAP.
+     */
+    customerFields?: FieldDef[];
+}
+/** Fully-defaulted booking config, carried on `CMSModule.config`. */
+export interface ResolvedBookingConfig {
+    currency: string;
+    catalogCollection: string | null;
+    surfacedCollections: string[];
+    depositAmount: number;
+    pricing: PricingConfig;
+    participantPricing: (() => ParticipantPricingConfig | Promise<ParticipantPricingConfig>) | null;
+    arrivalDateField: string;
+    payment: PaymentAdapter[];
+    portalUrlTemplate: string | null;
+    checkoutReturnUrl: string | null;
+    adminEmail: string | null;
+    brand: string | null;
+    depositTtlMinutes: number;
+    balanceDueDaysBefore: number | null;
+    capacityField: string | null;
+    reminders: ReminderRule[];
+    validateBooking: BookingValidator | null;
+    maintenance: {
+        autoRun: boolean;
+        intervalMinutes: number;
+    };
+    maintenanceToken: string | null;
+    portalSecret: string | null;
+    participantFields: FieldDef[] | ((catalogEntry: Record<string, unknown>) => FieldDef[]);
+    ageFlag: AgeFlagConfig | null;
+    customerFields: FieldDef[];
+}
+/** Resolves a raw {@link BookingConfig} into a {@link ResolvedBookingConfig}. */
+export declare function resolveBookingConfig(config: BookingConfig): ResolvedBookingConfig;
+/** Rozwiązuje schemat pól dla danego wpisu katalogu (array lub resolver). */
+export declare function resolveParticipantFields(config: ResolvedBookingConfig, catalogEntry: Record<string, unknown>): FieldDef[];

package/dist/booking/config.js

@@ -0,0 +1,36 @@
+/** Resolves a raw {@link BookingConfig} into a {@link ResolvedBookingConfig}. */
+export function resolveBookingConfig(config) {
+    return {
+        currency: config.currency,
+        catalogCollection: config.catalogCollection ?? null,
+        surfacedCollections: config.surfacedCollections ?? [],
+        depositAmount: config.depositAmount ?? 0,
+        pricing: config.pricing ?? { rules: [] },
+        participantPricing: config.participantPricing ?? null,
+        arrivalDateField: config.arrivalDateField ?? 'arrivalDate',
+        payment: config.payment ?? [],
+        portalUrlTemplate: config.portalUrlTemplate ?? null,
+        checkoutReturnUrl: config.checkoutReturnUrl ?? null,
+        adminEmail: config.adminEmail ?? null,
+        brand: config.brand ?? null,
+        depositTtlMinutes: config.depositTtlMinutes ?? 60,
+        balanceDueDaysBefore: config.balanceDueDaysBefore ?? null,
+        capacityField: config.capacityField ?? null,
+        reminders: config.reminders ?? [],
+        validateBooking: config.validateBooking ?? null,
+        maintenance: {
+            autoRun: config.maintenance?.autoRun ?? true,
+            intervalMinutes: config.maintenance?.intervalMinutes ?? 15
+        },
+        maintenanceToken: config.maintenanceToken ?? null,
+        portalSecret: config.portalSecret ?? null,
+        participantFields: config.participantFields ?? [],
+        ageFlag: config.ageFlag ?? null,
+        customerFields: config.customerFields ?? []
+    };
+}
+/** Rozwiązuje schemat pól dla danego wpisu katalogu (array lub resolver). */
+export function resolveParticipantFields(config, catalogEntry) {
+    const pf = config.participantFields;
+    return typeof pf === 'function' ? pf(catalogEntry) : pf;
+}

package/dist/booking/draft.d.ts

@@ -0,0 +1,77 @@
+import type { ResolvedBookingConfig } from './config.js';
+import { type PricingParticipant, type PricedTrip, type ParticipantPricingConfig } from './participant-pricing.js';
+import { type BookingTotals } from './totals.js';
+import type { FieldDef } from './participant-fields/types.js';
+import type { AppliedRule } from './pricing.js';
+/**
+ * A person on the booking. Identity fields (name, date of birth — the
+ * role:name / role:birthDate participant fields) are entered ONCE and shared
+ * across every trip the person takes. `ref` is a client-stable key used to
+ * correlate the person with their item assignments within a single payload.
+ */
+export interface PersonInput {
+    ref: string;
+    identity: Record<string, unknown>;
+}
+/** Assignment of a person to a trip line, with that person's per-trip answers. */
+export interface ItemAssignmentInput {
+    /** References a {@link PersonInput.ref} in the same payload. */
+    personRef: string;
+    /** Per-trip custom-field answers (trip-type-specific). */
+    data?: Record<string, unknown>;
+}
+/** One requested trip line in a create/edit payload. */
+export interface BookingItemInput {
+    tripRef: string;
+    departureDate: Date | null;
+    /** Unit (adult) price (minor units) snapshotted at booking time. */
+    unitPrice: number;
+    /** Who takes this trip (+ their per-trip data). Count derives from this. */
+    assignments: ItemAssignmentInput[];
+}
+export interface CreateBookingInput {
+    customer: Record<string, unknown>;
+    /** People on the booking (identity, shared across trips). */
+    persons: PersonInput[];
+    items: BookingItemInput[];
+    language?: string;
+}
+/** Per-call pricing context (dynamic: from globalSettings + this booking's customer). */
+export interface DraftPricingContext {
+    participantPricing: ParticipantPricingConfig;
+    /** Arrival date — anchor for age + early-bird. Null ⇒ everyone full price. */
+    anchor: Date | null;
+    /** Identity field schema, used to locate the role:birthDate key for age. */
+    identityFields: FieldDef[];
+}
+export interface BookingDraft {
+    totals: BookingTotals;
+    persons: PersonInput[];
+    items: Array<{
+        tripRef: string;
+        departureDate: Date | null;
+        participantsCount: number;
+        unitPriceSnapshot: number;
+        subtotalSnapshot: number | null;
+        appliedDiscounts: AppliedRule[];
+        assignments: ItemAssignmentInput[];
+    }>;
+    reminders: Array<{
+        type: string;
+        templateKey: string;
+        scheduledFor: Date;
+    }>;
+    balanceDueAt: Date | null;
+    holdExpiresAt: Date;
+}
+/** Build the per-participant pricing inputs from a create payload. */
+export declare function pricingInputsFromCreate(input: CreateBookingInput, identityFields: FieldDef[]): {
+    participants: PricingParticipant[];
+    trips: PricedTrip[];
+};
+/**
+ * Pure: turn a create payload + config + pricing context + clock into the
+ * rows/totals to persist. Prices per-participant (age bands + volume ladder +
+ * early-bird), anchored to the arrival date in `ctx.anchor`.
+ */
+export declare function buildBookingDraft(input: CreateBookingInput, config: ResolvedBookingConfig, ctx: DraftPricingContext, now: Date): BookingDraft;