includio-cms 0.37.0 → 0.37.1

package/API.md

@@ -1,4 +1,4 @@
-# includio-cms — Public API v0.37.0
+# includio-cms — Public API v0.37.1
 
 > Auto-generated by `scripts/generate-api-md.ts`. Do not edit by hand.
 
@@ -688,7 +688,7 @@ Tags:
 - `interface BookingStatusItem`
 - `type BookingTx = Parameters<Parameters<ReturnType<typeof getBookingDb>['transaction']>[0]>[0]` — Exact drizzle transaction handle, derived from the booking db's `transaction`.
 - `class BookingValidationError` — Thrown when a booking fails capacity (core) or the client `validateBooking` seam.
-- `createBooking(input: CreateBookingInput, opts: { now?: Date } = {}): Promise<{ booking: typeof bookingsTable.$inferSelect; accessToken: string }>` — Create a booking (public self-serve or staff). Validates catalog capacity +
+- `createBooking(input: CreateBookingInput, opts: { now?: Date; actor?: PriceActor } = {}): Promise<{ booking: typeof bookingsTable.$inferSelect; accessToken: string }>` — Create a booking (public self-serve or staff). Validates catalog capacity +
 - `createBookingHandler(): { POST: RequestHandler }` — Public self-serve booking creation. Mount at `POST /api/booking`.
 - `createDepositPayment(bookingId: string): Promise<{ redirectUrl: string | null; status: 'redirect' | 'manual' | 'error'...` — Create the deposit payment for a freshly-created booking: ask the first
 - `createInstallmentPayment(bookingId: string, amount: number): Promise<{ paymentLink: string | null }>` — Generate an installment/balance payment link for an arbitrary amount (staff or
@@ -700,12 +700,12 @@ Tags:
 - `getBookingMaintenanceStatus(): { running: boolean; lastRun: Date | null }`
 - `listBookingAdjustments(bookingId: string): Promise<BookingAdjustment[]>` — List all adjustments (active + voided) for a booking, newest first.
 - `pickEmailTemplate(kind: BookingEmailKind): string` — Template file name for a kind (1:1 — kept as a function for future indirection).
-- `portalAddTrips(token: string, additions: Array<{ tripRef: string; unitPrice: number; as...): <inferred>` — Self-service dobieranie wycieczki: doczytaj obecny stan, scal z `additions`
+- `portalAddTrips(token: string, additions: Array<{ tripRef: string; assignments: string[] }>): <inferred>` — Self-service dobieranie wycieczki: doczytaj obecny stan, scal z `additions`
 - `portalEdit(token: string, changes: BookingEditChanges): <inferred>` — Portal self-service edit (actor:'portal' guards). Throws → handler maps to 409/400.
 - `portalPay(token: string, amount: number): <inferred>` — Portal: create an installment/balance payment link.
 - `portalUpdateParticipant(token: string, assignmentId: string, data: Record<string, unknown>): <inferred>` — Portal self-service: customer fills their own participant data. Verifies the
 - `portalView(token: string): <inferred>` — Portal view: booking + items + participants + ledger (no staff data).
-- `priceFromExistingRows(tx: BookingTx, bookingId: string, config: ResolvedBookingConfig, now: Date): Promise<ParticipantPriceResult>` — Price a booking from its CURRENTLY persisted people/items/assignments (no
+- `priceFromExistingRows(tx: BookingTx, bookingId: string, config: ResolvedBookingConfig): Promise<ParticipantPriceResult>` — Price a booking from its CURRENTLY persisted people/items/assignments (no
 - `processDueExpirations(now: Date = new Date()): Promise<{ abandoned: number; forfeited: number }>` — Auto-cancel expired bookings: abandoned drafts (deposit hold lapsed) and
 - `processDueReminders(now: Date = new Date()): Promise<number>` — Send all due reminders (unsent, `scheduledFor <= now`) via the email adapter,
 - `readTripCapacity(tripRef: string): Promise<number | null>` — Read a trip's seat capacity from the catalog collection.

package/CHANGELOG.md

@@ -3,6 +3,29 @@
 All notable changes to includio-cms are documented here.
 Generated from `src/lib/updates/` — do not edit manually.
 
+## 0.37.1 — 2026-07-14
+
+Dwie łatki cenowe w bookingu. (1) Cena rezerwacji przestaje pochodzić z żądania HTTP — do 0.37.0 publiczne endpointy przyjmowały `unitPrice` prosto z ciała żądania i nikt nie konfrontował go z katalogiem, więc wyprawę dało się zarezerwować za grosz. (2) Data wyceny zostaje zamrożona na rezerwacji — dotąd każde jej dotknięcie (edycja, ale też zaksięgowanie korekty) przeliczało reguły zależne od czasu wg DZISIEJSZEJ daty, przez co early-bird sprzed miesięcy cicho znikał i klient robił się winien pieniądze.
+
+### Added
+- `defineBooking({ resolvePrice })` — serwerowy szew zwracający cenę bazową (dorosłego) pozycji katalogu w groszach. Rdzeń nie zna kształtu katalogu, więc cenę podaje projekt: `resolvePrice: async (tripRef) => Math.round(Number((await resolveEntry({ id: tripRef, status: "published" }))?.price ?? 0) * 100)`.
+- Model zaufania oparty na aktorze: `createBooking(input, { actor })` przyjmuje `public | portal | staff`. Domyślny aktor to `public` (niezaufany) — pominięcie parametru nie otwiera dziury. Zalogowana obsługa (`staff`) nadal może podać cenę ręcznie: korekta i rabat negocjowany telefonicznie zostają możliwe.
+- Typ `PricedCreateInput` wymusza kolejność: rezerwacji nie da się zbudować z pozycji, której nie wyceniła bramka — pilnuje tego kompilator, nie dyscyplina.
+
+### Fixed
+- **Bezpieczeństwo (data wyceny).** Nowa kolumna `bookings.priced_at` zamraża moment wyceny. `editBooking` i `priceFromExistingRows` (ścieżka korekt — `adjustments.ts:65` i `:155`) liczą teraz early-bird na tę datę, nie na `new Date()`. Wcześniej wystarczyło, że obsługa zaksięguje dopłatę ustaloną telefonicznie tydzień przed wylotem, a rabat za wczesną rezerwację przepadał. `priceFromExistingRows` straciło parametr `now` — kompilator nie pozwoli już podać tam zegara.
+- Rezerwacje sprzed 0.37.1 mają `priced_at = NULL` i wyceniają się z `created_at` — dokładnie tym, czym było wtedy `now`. Zero migracji danych, zero zmiany zachowania.
+- **Bezpieczeństwo (ceny).** Trzy publiczne drogi wpuszczały cenę z zewnątrz: tworzenie rezerwacji (`createBookingHandler`), dokładanie wycieczki przez portal (`add-trips`) i portalowa edycja pozycji (`portalEdit` → `editBooking`). Bramka stoi teraz w rdzeniu (`createBooking`/`editBooking`), nie w handlerach, więc każdy przyszły publiczny endpoint jest chroniony domyślnie.
+- Cena pozycji już zapisanej w rezerwacji jest brana z jej `unitPriceSnapshot`, a nie przeliczana z katalogu — dotknięcie rezerwacji przez portal nie podniesie klientowi ceny, gdy cennik w międzyczasie poszedł w górę.
+- Odczyt katalogu w `editBooking` odbywa się przed otwarciem transakcji: szew klienta robi własne I/O, a wołany pod blokadą `FOR UPDATE` trzymałby wiersz rezerwacji i sięgał po drugie połączenie z tej samej puli.
+- Ceny ujemne i niecałkowite (ułamek grosza) są odrzucane — również dla obsługi.
+
+### Breaking
+- Nowa kolumna `bookings.priced_at` — wymagana migracja (`drizzle-kit push`). Nullable, bez backfillu.
+- **`defineBooking({ resolvePrice })` jest teraz wymagany, gdy booking wystawia publiczne endpointy** (`createBookingHandler`, portal). Bez niego rdzeń odmawia wyceny (fail-closed) zamiast po cichu zaufać cenie z żądania. Instalacje używające wyłącznie panelu admina działają bez zmian.
+- `BookingItemInput.unitPrice` jest opcjonalne i **honorowane wyłącznie dla `actor: "staff"`**. Dla klienta końcowego jest ignorowane — cenę ustala katalog.
+- Publiczne API klienta: `createBookingClient().addTrips(token, additions)` oraz `useBooking().addTrips(additions)` nie przyjmują już `unitPrice` w pozycjach (`{ tripRef, assignments }`). Storefronty przekazujące cenę muszą ją usunąć z ładunku — była i tak ignorowana po stronie serwera.
+
 ## 0.37.0 — 2026-06-17
 
 Moduły-nakładki + context switcher: shop i booking jako równorzędne, opcjonalne moduły rozszerzające rdzeń CMS (model „WooCommerce na WordPressie"). Zunifikowany rejestr `config.modules`, przełącznik kontekstu w adminie (Treści / Sklep / Rezerwacje) dla czytelniejszego UI, per-moduł dashboard. Shop przepięty na nowy kontrakt `CMSModule` (dowód generyczności #1), booking dodany jako drugi moduł biblioteki z pełnym rdzeniem domenowym (wycena/state machine/księga płatności) — dowód #2. Booking write-flow + portal self-service domknięte: tworzenie (public+staff), zadatek + webhook idempotentny, pełna edycja self-service (recompute/pojemność/„nie poniżej wpłaconego”), maile + przypomnienia, cron bez-infra (in-process loop + secured endpoint), strefa obsługi w adminie, scaffold `--booking`. Plan: `docs/superpowers/plans/2026-06-18-booking-write-flow-portal.md`, spec: `docs/superpowers/specs/2026-06-18-booking-write-flow-portal-design.md`.

package/DOCS.md

@@ -1,4 +1,4 @@
-# Includio CMS Documentation (v0.37.0)
+# Includio CMS Documentation (v0.37.1)
 
 > This file is auto-generated from the docs site. For the latest version, update the package.
 

package/ROADMAP.md

@@ -35,8 +35,22 @@
 - [x] `[feature]` `[P1]` Slug first-class + SEO v1.0 freeze (0.26.0) — `resolveSeo` public (`includio-cms/core`), `seoFieldDescriptor` SSOT (Zod+TS drift-guard), admin URL un-hardcode (`slugPath.ts` pure resolver, no `seo`-field requirement), `SlugField`/`SeoField`/`SeoFieldData` `@public` v1.0-frozen <!-- files: src/lib/core/fields/slugPath.ts, src/lib/core/fields/seoFieldDescriptor.ts, src/lib/core/fields/resolveSeo.ts, src/lib/types/fields.ts, src/lib/admin/client/collection/collection-entries.svelte, src/lib/updates/0.26.0/ -->
 - [x] `[feature]` `[P2]` Soft-delete zamówień admin-only (0.34.0) — ukrycie zamówienia z listy bez utraty danych (`deleted_at`/`deleted_by`), kosz + przywracanie, guard `decideOrderDeletion` (safe-statuses + faktura), auto-restore przy płatności, zwolnienie rezerwacji stocku, `requireRole('admin')` <!-- files: src/lib/shop/server/orders.ts, src/lib/db-postgres/schema/shop/order.ts, src/lib/admin/remote/shop.remote.ts, src/lib/admin/client/shop/{shop-order-detail-page,shop-orders-list-page,restore-order-cell}.svelte, src/lib/updates/0.34.0/ -->
 
+## 0.37.1 — Bramka cenowa (bezpieczeństwo)
+
+- [x] `[fix]` `[breaking]` `[P0]` **Data wyceny zamrożona na rezerwacji** (`bookings.priced_at`). Dotąd cena bazowa była zamrożona, ale data — nie: `editBooking` i `priceFromExistingRows` (ścieżka **korekt**) przeliczały reguły zależne od czasu wg `new Date()`. Obsługa księgowała dopłatę ustaloną telefonicznie tydzień przed wylotem → `daysUntil(anchor, now)` spadało poniżej progu → **early-bird sprzed miesięcy cicho znikał, a klient robił się winien pieniądze**. Bomba tykała sama, bez żadnej zmiany cennika. Rezerwacje sprzed 0.37.1: `priced_at = NULL` → fallback na `created_at` (zero migracji danych). Pełny snapshot **wartości** polityki (`pricing_snapshot`) zostaje w 0.38.0 §4.4 — wymaga świadomej zmiany cennika przez klientkę, więc da się ją uprzedzić.
+- [x] `[fix]` `[breaking]` `[P0]` **Cena rezerwacji przestaje pochodzić z żądania HTTP.** Do 0.37.0 trzy publiczne drogi wpuszczały `unitPrice` z ciała żądania i nikt nie konfrontował go z katalogiem (`create-handler.ts:37`, portalowe `add-trips`, portalowe `edit` → `editBooking`) — wyprawę dało się zarezerwować za grosz. Bramka stoi teraz w rdzeniu (`createBooking`/`editBooking`), oparta na aktorze: `public`/`portal` nie dyktują ceny (nowa pozycja → szew `resolvePrice` z katalogu, istniejąca → jej `unitPriceSnapshot`), `staff` nadal może korygować ręcznie. Domyślny aktor to `public`, więc przyszły publiczny endpoint jest bezpieczny bez pamiętania o niczym. Fail-closed: brak `resolvePrice` = odmowa wyceny.
+
 ## 0.38.0 — Moduły: kontrakt vs polityka
 
+> **WSTRZYMANE (2026-07-14).** Łuk jest dojrzały, ale klientka nie zobaczy z niego nic, a produktyzacja
+> (`module_settings`, `AdminRouter`, kupony) zwraca się dopiero przy **drugim kliencie z bookingiem**.
+> Wracamy, gdy taki się pojawi — wtedy abstrakcje wyjdą z dwóch realnych przypadków, nie z jednego.
+> Wyjątek już zrobiony: kawałek 3a (jądro reguł) leży zrebase'owany na `feat/pricing-rules-kernel`.
+> Poprawka do wprowadzenia przy powrocie: pozycja o typach wypraw twierdzi, że „moduł ma wnosić je sam" —
+> **to jest błędne**. `tripType` to pojęcie domenowe klienta (klient nr 3 może wynajmować kajaki).
+> Moduł może wnieść MECHANIZM (rejestr typów pól + generator pola `blocks` + adapter + headless front),
+> nie POJĘCIE.
+
 Spec: `docs/superpowers/specs/2026-07-13-moduly-kontrakt-vs-polityka-design.md`. Kolejność i uzasadnienia tam.
 
 - [x] `[feature]` `[P0]` Kawałek 3a — jądro reguł w rdzeniu (`core/rules`) + cennik jako kategorie uczestnika; golden testy parytetu ze starym silnikiem. Branch `feat/pricing-rules-kernel`.

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

@@ -24,6 +24,7 @@ export declare const listBookings: import("@sveltejs/kit").RemoteQueryFunction<{
         currency: string;
         customer: Record<string, unknown>;
         totals: import("../../db-postgres/schema/booking/index.js").BookingTotals;
+        pricedAt: Date | null;
         accessToken: string;
         staffNotes: string | null;
         language: string | null;
@@ -60,6 +61,7 @@ export declare const getBooking: import("@sveltejs/kit").RemoteQueryFunction<str
         currency: string;
         customer: Record<string, unknown>;
         totals: import("../../db-postgres/schema/booking/index.js").BookingTotals;
+        pricedAt: Date | null;
         accessToken: string;
         staffNotes: string | null;
         language: string | null;
@@ -172,6 +174,7 @@ export declare const editBookingStaff: import("@sveltejs/kit").RemoteCommand<{
     updatedAt: Date;
     customer: Record<string, unknown>;
     totals: import("../../db-postgres/schema/booking/index.js").BookingTotals;
+    pricedAt: Date | null;
     staffNotes: string | null;
     balanceDueAt: Date | null;
     holdExpiresAt: Date | null;

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

@@ -196,7 +196,10 @@ export const listBookingCatalog = query(async () => {
 /** Staff: create a booking from the admin panel. @public */
 export const createBookingStaff = command(z.any(), async (input) => {
     requireAuth();
-    return createBooking(input);
+    // `actor: 'staff'` — zalogowana obsługa może podać cenę ręcznie (korekta, rabat
+    // negocjowany telefonicznie). Publiczne ścieżki NIE mają tego prawa: bez tej flagi
+    // rdzeń bierze cenę wyłącznie z katalogu (`resolvePrice`).
+    return createBooking(input, { actor: 'staff' });
 });
 /** 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 }) => {

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

@@ -29,10 +29,13 @@ export declare function createBookingClient(opts?: BookingClientOptions): {
     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). */
+    /**
+     * Self-service: dołóż wycieczki istniejącym osobom (recompute salda).
+     *
+     * Cena **nie jest** parametrem — ustala ją serwer z katalogu (`resolvePrice`).
+     */
     addTrips: (token: string, additions: Array<{
         tripRef: string;
-        unitPrice: number;
         assignments: string[];
     }>) => Promise<unknown>;
 };

package/dist/booking/client/index.js

@@ -37,7 +37,11 @@ export function createBookingClient(opts = {}) {
         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). */
+        /**
+         * Self-service: dołóż wycieczki istniejącym osobom (recompute salda).
+         *
+         * Cena **nie jest** parametrem — ustala ją serwer z katalogu (`resolvePrice`).
+         */
         addTrips: (token, additions) => req(`/api/booking/portal/${token}?action=add-trips`, jsonInit('POST', { additions }))
     };
 }

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

@@ -19,7 +19,6 @@ export declare function useBooking(token: string, opts?: BookingClientOptions):
     verifyPhone: (phone: string) => Promise<void>;
     addTrips: (additions: Array<{
         tripRef: string;
-        unitPrice: number;
         assignments: string[];
     }>) => Promise<void>;
 };

package/dist/booking/config.d.ts

@@ -50,6 +50,25 @@ export interface BookingConfig {
     surfacedCollections?: string[];
     /** Deposit that secures a reservation, in minor units (default 0). */
     depositAmount?: number;
+    /**
+     * **Szew serwerowy: cena bazowa (dorosłego) pozycji katalogu, w groszach.**
+     *
+     * Rdzeń nie zna kształtu katalogu (`tripRef` jest dla niego nieprzezroczysty), więc
+     * cenę musi podać projekt. Wołany **wyłącznie na serwerze** przy każdej rezerwacji
+     * składanej przez klienta końcowego — dzięki temu przeglądarka nie ma na cenę wpływu.
+     *
+     * **Wymagany, gdy booking wystawia publiczne endpointy** (`createBookingHandler`,
+     * portal). Bez niego rdzeń odmawia wyceny (fail-closed) zamiast zaufać cenie z żądania.
+     * Obsługa w adminie (`actor: 'staff'`) nadal może podać cenę ręcznie — korekta jest
+     * zamierzoną funkcją.
+     *
+     * @example
+     * resolvePrice: async (tripRef) => {
+     *   const entry = await resolveEntry({ id: tripRef, status: 'published' });
+     *   return Math.round(Number(entry?.price ?? 0) * 100); // PLN → grosze
+     * }
+     */
+    resolvePrice?: (tripRef: string) => number | Promise<number>;
     /** Discount rules (legacy per-line engine; booking now prices per-participant). */
     pricing?: PricingConfig;
     /**
@@ -127,6 +146,7 @@ export interface ResolvedBookingConfig {
     catalogCollection: string | null;
     surfacedCollections: string[];
     depositAmount: number;
+    resolvePrice: ((tripRef: string) => number | Promise<number>) | null;
     pricing: PricingConfig;
     participantPricing: (() => ParticipantPricingConfig | Promise<ParticipantPricingConfig>) | null;
     arrivalDateField: string;

package/dist/booking/config.js

@@ -5,6 +5,7 @@ export function resolveBookingConfig(config) {
         catalogCollection: config.catalogCollection ?? null,
         surfacedCollections: config.surfacedCollections ?? [],
         depositAmount: config.depositAmount ?? 0,
+        resolvePrice: config.resolvePrice ?? null,
         pricing: config.pricing ?? { rules: [] },
         participantPricing: config.participantPricing ?? null,
         arrivalDateField: config.arrivalDateField ?? 'arrivalDate',

package/dist/booking/draft.d.ts

@@ -24,8 +24,15 @@ export interface ItemAssignmentInput {
 export interface BookingItemInput {
     tripRef: string;
     departureDate: Date | null;
-    /** Unit (adult) price (minor units) snapshotted at booking time. */
-    unitPrice: number;
+    /**
+     * Cena bazowa (dorosłego) w groszach, zamrażana na pozycji.
+     *
+     * **Honorowana wyłącznie dla `actor: 'staff'`** (ręczna korekta w adminie). Dla klienta
+     * końcowego (`public`/`portal`) jest ignorowana — cenę ustala rdzeń z katalogu przez szew
+     * `resolvePrice`, bo inaczej każdy mógłby zamówić wyprawę za grosz. Pomiń, gdy cena ma
+     * pochodzić z katalogu.
+     */
+    unitPrice?: number;
     /** Who takes this trip (+ their per-trip data). Count derives from this. */
     assignments: ItemAssignmentInput[];
 }
@@ -64,8 +71,20 @@ export interface BookingDraft {
     balanceDueAt: Date | null;
     holdExpiresAt: Date;
 }
+/**
+ * Pozycja po przejściu przez bramkę cenową — cena jest już ustalona (z katalogu, ze
+ * snapshotu albo od obsługi). Typ istnieje po to, by **nie dało się** zbudować rezerwacji
+ * z pozycji, której nikt nie wycenił: kompilator pilnuje, że bramka poszła pierwsza.
+ */
+export type PricedBookingItem = BookingItemInput & {
+    unitPrice: number;
+};
+/** Ładunek create z pozycjami już wycenionymi. */
+export type PricedCreateInput = Omit<CreateBookingInput, 'items'> & {
+    items: PricedBookingItem[];
+};
 /** Build the per-participant pricing inputs from a create payload. */
-export declare function pricingInputsFromCreate(input: CreateBookingInput, identityFields: FieldDef[]): {
+export declare function pricingInputsFromCreate(input: PricedCreateInput, identityFields: FieldDef[]): {
     participants: PricingParticipant[];
     trips: PricedTrip[];
 };
@@ -74,4 +93,4 @@ export declare function pricingInputsFromCreate(input: CreateBookingInput, ident
  * 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;
+export declare function buildBookingDraft(input: PricedCreateInput, config: ResolvedBookingConfig, ctx: DraftPricingContext, now: Date): BookingDraft;

package/dist/booking/server/adjustments.js

@@ -36,7 +36,9 @@ export async function addBookingAdjustment(bookingId, input, opts) {
         if (!booking)
             throw new Error(`Booking ${bookingId} not found`);
         assertEditAllowed(booking.status);
-        const result = await priceFromExistingRows(tx, bookingId, config, now);
+        // Bez `now`: przeliczenie idzie z zamrożonej daty wyceny rezerwacji. Zaksięgowanie
+        // dopłaty nie może odebrać klientowi early-birda sprzed miesięcy.
+        const result = await priceFromExistingRows(tx, bookingId, config);
         const active = await tx
             .select()
             .from(bookingAdjustmentsTable)
@@ -109,7 +111,8 @@ export async function voidBookingAdjustment(adjustmentId, opts) {
             .update(bookingAdjustmentsTable)
             .set({ voidedAt: now, voidedBy: opts.actor })
             .where(eq(bookingAdjustmentsTable.id, adjustmentId));
-        const result = await priceFromExistingRows(tx, adj.bookingId, config, now);
+        // Wycofanie korekty — również z zamrożonej daty wyceny, nie z dzisiejszej.
+        const result = await priceFromExistingRows(tx, adj.bookingId, config);
         const active = await tx
             .select()
             .from(bookingAdjustmentsTable)

package/dist/booking/server/bookings.d.ts

@@ -3,6 +3,7 @@ import { type CreateBookingInput, type PersonInput, type ItemAssignmentInput } f
 import { type ParticipantPriceResult } from '../participant-pricing.js';
 import type { ResolvedBookingConfig } from '../config.js';
 import { type BookingTx } from './reminders.js';
+import { type PriceActor } from './price-source.js';
 /** Edit payload: replace people + items (+assignments) and/or customer details. */
 export interface BookingEditChanges {
     persons?: PersonInput[];
@@ -22,6 +23,7 @@ export interface BookingEditChanges {
  */
 export declare function createBooking(input: CreateBookingInput, opts?: {
     now?: Date;
+    actor?: PriceActor;
 }): Promise<{
     booking: typeof bookingsTable.$inferSelect;
     accessToken: string;
@@ -41,5 +43,9 @@ export declare function editBooking(bookingId: string, changes: BookingEditChang
  * edit). Shared by adjustment recompute — mirrors the "no items change" branch
  * of {@link editBooking}. Must run inside a transaction that has locked the
  * booking row.
+ *
+ * **Wycenia na zamrożoną datę rezerwacji (`pricedAt`), nie na dziś.** To jest ścieżka
+ * korekt: obsługa księguje dopłatę ustaloną telefonicznie, a przeliczenie nie może przy
+ * okazji odebrać klientowi rabatu za wczesną rezerwację.
  */
-export declare function priceFromExistingRows(tx: BookingTx, bookingId: string, config: ResolvedBookingConfig, now: Date): Promise<ParticipantPriceResult>;
+export declare function priceFromExistingRows(tx: BookingTx, bookingId: string, config: ResolvedBookingConfig): Promise<ParticipantPriceResult>;

package/dist/booking/server/bookings.js

@@ -12,6 +12,18 @@ import { recomputeTotals, assertEditAllowed, assertPortalEditAllowed } from '../
 import { deriveStatus } from '../state-machine.js';
 import { runCapacityCheck, runValidateBooking } from './validation.js';
 import { rescheduleReminders } from './reminders.js';
+import { priceItemsFromCatalog, fetchCatalogPrices, catalogRefsNeeded, pickItemPrices } from './price-source.js';
+/**
+ * Data, na którą wycenia się TĘ rezerwację — nigdy „dzisiaj".
+ *
+ * Reguły zależne od czasu (early-bird) muszą widzieć moment złożenia rezerwacji, inaczej
+ * każde późniejsze dotknięcie (edycja, korekta) po cichu odbiera klientowi rabat.
+ * `pricedAt` jest NULL dla rezerwacji sprzed 0.37.1 — dla nich `createdAt` jest dokładnie
+ * tym, czym było wtedy `now`.
+ */
+function pricingDateOf(booking) {
+    return booking.pricedAt ?? booking.createdAt;
+}
 /** Resolve personRef → DB person id; throws on a dangling assignment reference. */
 function personIdLookup(map, ref) {
     const id = map.get(ref);
@@ -50,6 +62,9 @@ export async function createBooking(input, opts = {}) {
     const config = requireBookingConfig();
     const db = getBookingDb();
     const now = opts.now ?? new Date();
+    // Domyślnie NIEZAUFANY: nowy publiczny endpoint jest bezpieczny, dopóki ktoś jawnie
+    // nie napisze `actor: 'staff'`. Zapomnienie tego parametru nie może otworzyć dziury.
+    const actor = opts.actor ?? 'public';
     const validationItems = input.items.map((it) => ({
         tripRef: it.tripRef,
         departureDate: it.departureDate,
@@ -62,8 +77,15 @@ export async function createBooking(input, opts = {}) {
         items: validationItems,
         customer: input.customer
     });
+    // Cena jest atrybutem katalogu, nie żądania. Wszystkie pozycje są tu nowe (brak
+    // snapshotów), więc dla klienta końcowego jedynym źródłem ceny jest szew `resolvePrice`.
+    const priced = await priceItemsFromCatalog(actor, input.items, new Map());
+    const pricedInput = {
+        ...input,
+        items: input.items.map((it, i) => ({ ...it, unitPrice: priced[i].unitPrice }))
+    };
     const ctx = await buildPricingContext(config, input.customer, input.items[0]?.tripRef);
-    const draft = buildBookingDraft(input, config, ctx, now);
+    const draft = buildBookingDraft(pricedInput, config, ctx, now);
     // Unique booking number with collision retry (~25 bits → rare).
     let number = generateBookingNumber();
     for (let i = 0; i < 5; i++) {
@@ -84,6 +106,9 @@ export async function createBooking(input, opts = {}) {
             currency: config.currency,
             customer: input.customer,
             totals: draft.totals,
+            // Zamrażamy moment wyceny: wszystkie późniejsze przeliczenia (edycja, korekta)
+            // liczą early-bird na TĘ datę, nie na dzisiejszą.
+            pricedAt: now,
             balanceDueAt: draft.balanceDueAt,
             holdExpiresAt: draft.holdExpiresAt,
             language: input.language ?? null
@@ -139,6 +164,10 @@ export async function editBooking(bookingId, changes, opts) {
     const config = requireBookingConfig();
     const db = getBookingDb();
     const now = opts.now ?? new Date();
+    // Katalog odpytujemy PRZED transakcją: szew `resolvePrice` należy do projektu i robi
+    // własne I/O. Wołany pod blokadą `FOR UPDATE` trzymałby wiersz rezerwacji przez cudzy
+    // odczyt i sięgał po drugie połączenie z tej samej puli — droga do zakleszczenia puli.
+    const catalogPrices = await fetchCatalogPrices(catalogRefsNeeded(opts.actor, changes.items ?? []));
     return db.transaction(async (tx) => {
         const [booking] = await tx
             .select()
@@ -151,14 +180,26 @@ export async function editBooking(bookingId, changes, opts) {
             .select()
             .from(bookingItemsTable)
             .where(eq(bookingItemsTable.bookingId, bookingId));
+        // Bramka cenowa. Portal nie dyktuje ceny: pozycja już w rezerwacji zachowuje swój
+        // zamrożony snapshot (dotknięcie rezerwacji nie może podnieść klientowi ceny, gdy
+        // cennik poszedł w górę), pozycja nowa dostaje cenę z katalogu.
+        const existingByRef = new Map(existingItems.map((i) => [i.tripRef, i.unitPriceSnapshot]));
+        const editItems = changes.items
+            ? pickItemPrices({
+                actor: opts.actor,
+                items: changes.items,
+                existingByRef,
+                catalogPrices
+            }).map((priced, i) => ({ ...changes.items[i], unitPrice: priced.unitPrice }))
+            : undefined;
         const customerForCtx = changes.customer ?? booking.customer;
-        const tripRefForSchema = changes.items?.[0]?.tripRef ?? existingItems[0]?.tripRef;
+        const tripRefForSchema = editItems?.[0]?.tripRef ?? existingItems[0]?.tripRef;
         const ctx = await buildPricingContext(config, customerForCtx, tripRefForSchema);
         // Pricing inputs: from the edit when items change, else from existing rows.
         let participants;
         let trips;
-        if (changes.items) {
-            const pi = pricingInputsFromCreate({ customer: customerForCtx, persons: changes.persons ?? [], items: changes.items }, ctx.identityFields);
+        if (editItems) {
+            const pi = pricingInputsFromCreate({ customer: customerForCtx, persons: changes.persons ?? [], items: editItems }, ctx.identityFields);
             participants = pi.participants;
             trips = pi.trips;
         }
@@ -178,8 +219,11 @@ export async function editBooking(bookingId, changes, opts) {
             participants = pi.participants;
             trips = pi.trips;
         }
-        const result = priceByParticipant(participants, trips, ctx.anchor, now, ctx.participantPricing);
-        const dates = (changes.items ?? existingItems).map((it) => it.departureDate);
+        // Wycena idzie z ZAMROŻONEJ daty rezerwacji, nie z `now` — inaczej poprawienie
+        // literówki tydzień przed wylotem skasowałoby early-bird sprzed trzech miesięcy.
+        // `now` zostaje tam, gdzie naprawdę znaczy „teraz": `updatedAt`, terminy, przypomnienia.
+        const result = priceByParticipant(participants, trips, ctx.anchor, pricingDateOf(booking), ctx.participantPricing);
+        const dates = (editItems ?? existingItems).map((it) => it.departureDate);
         const payments = (await tx
             .select()
             .from(bookingPaymentsTable)
@@ -194,8 +238,8 @@ export async function editBooking(bookingId, changes, opts) {
             assertPortalEditAllowed(booking.status, netOf(totals), payments);
         else
             assertEditAllowed(booking.status);
-        if (changes.items) {
-            const validationItems = changes.items.map((it) => ({
+        if (editItems) {
+            const validationItems = editItems.map((it) => ({
                 tripRef: it.tripRef,
                 departureDate: it.departureDate,
                 participantsCount: it.assignments.length
@@ -219,7 +263,7 @@ export async function editBooking(bookingId, changes, opts) {
                     .returning();
                 personIdByRef.set(p.ref, person.id);
             }
-            for (const it of changes.items) {
+            for (const it of editItems) {
                 const [item] = await tx
                     .insert(bookingItemsTable)
                     .values({
@@ -262,8 +306,12 @@ export async function editBooking(bookingId, changes, opts) {
  * edit). Shared by adjustment recompute — mirrors the "no items change" branch
  * of {@link editBooking}. Must run inside a transaction that has locked the
  * booking row.
+ *
+ * **Wycenia na zamrożoną datę rezerwacji (`pricedAt`), nie na dziś.** To jest ścieżka
+ * korekt: obsługa księguje dopłatę ustaloną telefonicznie, a przeliczenie nie może przy
+ * okazji odebrać klientowi rabatu za wczesną rezerwację.
  */
-export async function priceFromExistingRows(tx, bookingId, config, now) {
+export async function priceFromExistingRows(tx, bookingId, config) {
     const [booking] = await tx.select().from(bookingsTable).where(eq(bookingsTable.id, bookingId));
     if (!booking)
         throw new Error(`Booking ${bookingId} not found`);
@@ -284,5 +332,5 @@ export async function priceFromExistingRows(tx, bookingId, config, now) {
             .where(inArray(bookingItemPersonsTable.itemId, itemIds))
         : [];
     const pi = buildPricingInputs(persons.map((p) => ({ id: p.id, data: p.data })), existingItems.map((i) => ({ id: i.id, tripRef: i.tripRef, unitPrice: i.unitPriceSnapshot })), assignments.map((a) => ({ itemId: a.itemId, personId: a.personId })), ctx.identityFields);
-    return priceByParticipant(pi.participants, pi.trips, ctx.anchor, now, ctx.participantPricing);
+    return priceByParticipant(pi.participants, pi.trips, ctx.anchor, pricingDateOf(booking), ctx.participantPricing);
 }

package/dist/booking/server/http/create-handler.js

@@ -31,9 +31,11 @@ export function createBookingHandler() {
                         identity: p.identity && typeof p.identity === 'object' ? p.identity : {}
                     }))
                     : [];
+                // `unitPrice` z ciała żądania jest ŚWIADOMIE POMIJANY. Cenę ustala rdzeń z katalogu
+                // (szew `resolvePrice`) — inaczej każdy mógłby zamówić wyprawę za grosz.
                 const items = body.items.map((it) => ({
                     tripRef: String(it.tripRef),
-                    unitPrice: Number(it.unitPrice) || 0,
+                    unitPrice: 0, // nadpisywane przez bramkę cenową (`actor: 'public'`)
                     departureDate: it.departureDate ? new Date(it.departureDate) : null,
                     assignments: Array.isArray(it.assignments)
                         ? it.assignments.map((a) => ({
@@ -47,7 +49,7 @@ export function createBookingHandler() {
                     persons,
                     items,
                     language: body.language
-                });
+                }, { actor: 'public' });
                 const payment = await createDepositPayment(booking.id);
                 return json({
                     bookingId: booking.id,

package/dist/booking/server/http/portal-handler.js

@@ -77,8 +77,12 @@ export function createPortalHandler() {
                     return out ? json(out) : json({ error: 'Not found' }, { status: 404 });
                 }
                 if (action === 'add-trips') {
+                    // Cena NIE jest częścią żądania — ustala ją rdzeń z katalogu.
                     const additions = Array.isArray(body.additions)
-                        ? body.additions
+                        ? body.additions.map((a) => ({
+                            tripRef: String(a.tripRef),
+                            assignments: Array.isArray(a.assignments) ? a.assignments.map(String) : []
+                        }))
                         : [];
                     const out = await portalAddTrips(token, additions);
                     return out ? json(out) : json({ error: 'Not found' }, { status: 404 });

package/dist/booking/server/portal.d.ts

@@ -173,7 +173,6 @@ export declare function portalUpdateParticipant(token: string, assignmentId: str
  */
 export declare function portalAddTrips(token: string, additions: Array<{
     tripRef: string;
-    unitPrice: number;
     assignments: string[];
 }>): Promise<{
     number: string;

package/dist/booking/server/portal.js

@@ -223,10 +223,12 @@ export async function portalAddTrips(token, additions) {
     }));
     const arrivalRaw = booking.customer?.arrivalDate;
     const anchor = arrivalRaw ? new Date(arrivalRaw) : null;
+    // Bez `unitPrice`: cenę nowej pozycji ustala bramka cenowa w `editBooking` z katalogu
+    // (`actor: 'portal'`). Klient z ważnym tokenem nie może sobie dorzucić wyprawy za grosz.
     const newItems = additions.map((a) => ({
         tripRef: a.tripRef,
         departureDate: anchor,
-        unitPrice: a.unitPrice,
+        unitPrice: 0, // nadpisywane przez bramkę
         assignments: a.assignments.map((ref) => ({ personRef: ref }))
     }));
     await editBooking(booking.id, { persons: personInputs, items: [...existingItems, ...newItems] }, { actor: 'portal' });

package/dist/booking/server/price-source.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Kto pisze do rezerwacji. Steruje zaufaniem do ceny przyniesionej w żądaniu:
+ * `staff` jest zalogowaną obsługą (ręczna korekta ceny w adminie jest zamierzoną
+ * funkcją), `public`/`portal` to klient końcowy — jego ceny nie honorujemy nigdy.
+ */
+export type PriceActor = 'public' | 'portal' | 'staff';
+/** Cena nie do przyjęcia: brak w katalogu, ujemna albo w ułamku grosza. */
+export declare class PriceSourceError extends Error {
+    constructor(message: string);
+}
+/**
+ * Ustala cenę bazową każdej pozycji. **Niezmiennik: cena jest atrybutem katalogu,
+ * nie żądania.** Bez tego publiczny endpoint przyjmował `unitPrice` prosto z ciała
+ * żądania i rezerwację dało się złożyć za grosz.
+ *
+ * Kolejność źródeł:
+ * 1. `staff` z jawną ceną → jego cena (ręczna korekta w adminie),
+ * 2. pozycja już w rezerwacji → jej **snapshot** (zamrożony przy zakupie; dotknięcie
+ *    rezerwacji nie może podnieść klientowi ceny, gdy cennik poszedł w górę),
+ * 3. katalog przez szew `resolvePrice`.
+ *
+ * Czysta funkcja — I/O (odczyt katalogu) robi {@link fetchCatalogPrices}.
+ *
+ * @throws {PriceSourceError} gdy pozycji nie da się wycenić (fail-closed: brak ceny
+ * to odmowa, nigdy „zero").
+ */
+export declare function pickItemPrices(input: {
+    actor: PriceActor;
+    items: Array<{
+        tripRef: string;
+        unitPrice?: number;
+    }>;
+    /** `tripRef` → `unitPriceSnapshot` pozycji już zapisanych w tej rezerwacji. */
+    existingByRef: Map<string, number>;
+    /** `tripRef` → cena bazowa z katalogu (wynik szwu `resolvePrice`). */
+    catalogPrices: Map<string, number>;
+}): Array<{
+    tripRef: string;
+    unitPrice: number;
+}>;
+/**
+ * Odpytuje szew `resolvePrice` o cenę bazową podanych pozycji katalogu (równolegle,
+ * bez duplikatów). Szew jest **serwerowy** — czyta katalog projektu, więc przeglądarka
+ * nie ma na tę cenę wpływu.
+ *
+ * @throws {PriceSourceError} gdy `resolvePrice` nie jest skonfigurowany. Fail-closed:
+ * publiczny booking bez źródła cen musi odmówić, a nie po cichu zaufać żądaniu.
+ */
+export declare function fetchCatalogPrices(tripRefs: string[]): Promise<Map<string, number>>;
+/**
+ * Pozycje, o których trzeba zapytać katalog. Obsługa podająca cenę jawnie nie wymaga
+ * odczytu — dzięki temu instalacja bez publicznego bookingu (sam admin) działa bez
+ * skonfigurowanego `resolvePrice`.
+ *
+ * `existingByRef` bywa nieznane przed wejściem w transakcję (patrz `editBooking`) — wtedy
+ * pomiń je, a katalog zostanie odpytany też o pozycje, które ostatecznie wezmą snapshot.
+ * Kilka odczytów więcej jest tańsze niż odczyt katalogu pod blokadą wiersza.
+ */
+export declare function catalogRefsNeeded(actor: PriceActor, items: Array<{
+    tripRef: string;
+    unitPrice?: number;
+}>, existingByRef?: Map<string, number>): string[];
+/**
+ * Wycenia pozycje: odpytuje katalog **tylko o te, których nie da się wycenić inaczej**,
+ * a potem stosuje {@link pickItemPrices}. Wołaj poza transakcją — robi I/O.
+ */
+export declare function priceItemsFromCatalog(actor: PriceActor, items: Array<{
+    tripRef: string;
+    unitPrice?: number;
+}>, existingByRef: Map<string, number>): Promise<Array<{
+    tripRef: string;
+    unitPrice: number;
+}>>;

package/dist/booking/server/price-source.js

@@ -0,0 +1,94 @@
+import { requireBookingConfig } from './db.js';
+/** Cena nie do przyjęcia: brak w katalogu, ujemna albo w ułamku grosza. */
+export class PriceSourceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PriceSourceError';
+    }
+}
+function assertValidPrice(tripRef, value) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new PriceSourceError(`Niepoprawna cena pozycji ${tripRef}: ${value} (oczekiwano nieujemnej liczby całkowitej groszy)`);
+    }
+    return value;
+}
+/**
+ * Ustala cenę bazową każdej pozycji. **Niezmiennik: cena jest atrybutem katalogu,
+ * nie żądania.** Bez tego publiczny endpoint przyjmował `unitPrice` prosto z ciała
+ * żądania i rezerwację dało się złożyć za grosz.
+ *
+ * Kolejność źródeł:
+ * 1. `staff` z jawną ceną → jego cena (ręczna korekta w adminie),
+ * 2. pozycja już w rezerwacji → jej **snapshot** (zamrożony przy zakupie; dotknięcie
+ *    rezerwacji nie może podnieść klientowi ceny, gdy cennik poszedł w górę),
+ * 3. katalog przez szew `resolvePrice`.
+ *
+ * Czysta funkcja — I/O (odczyt katalogu) robi {@link fetchCatalogPrices}.
+ *
+ * @throws {PriceSourceError} gdy pozycji nie da się wycenić (fail-closed: brak ceny
+ * to odmowa, nigdy „zero").
+ */
+export function pickItemPrices(input) {
+    const { actor, items, existingByRef, catalogPrices } = input;
+    return items.map((it) => {
+        if (actor === 'staff' && it.unitPrice !== undefined) {
+            return { tripRef: it.tripRef, unitPrice: assertValidPrice(it.tripRef, it.unitPrice) };
+        }
+        const snapshot = existingByRef.get(it.tripRef);
+        if (snapshot !== undefined) {
+            return { tripRef: it.tripRef, unitPrice: assertValidPrice(it.tripRef, snapshot) };
+        }
+        const fromCatalog = catalogPrices.get(it.tripRef);
+        if (fromCatalog === undefined) {
+            throw new PriceSourceError(`Brak ceny w katalogu dla pozycji ${it.tripRef} — rezerwacji nie da się wycenić`);
+        }
+        return { tripRef: it.tripRef, unitPrice: assertValidPrice(it.tripRef, fromCatalog) };
+    });
+}
+/**
+ * Odpytuje szew `resolvePrice` o cenę bazową podanych pozycji katalogu (równolegle,
+ * bez duplikatów). Szew jest **serwerowy** — czyta katalog projektu, więc przeglądarka
+ * nie ma na tę cenę wpływu.
+ *
+ * @throws {PriceSourceError} gdy `resolvePrice` nie jest skonfigurowany. Fail-closed:
+ * publiczny booking bez źródła cen musi odmówić, a nie po cichu zaufać żądaniu.
+ */
+export async function fetchCatalogPrices(tripRefs) {
+    const refs = [...new Set(tripRefs)];
+    if (refs.length === 0)
+        return new Map();
+    const { resolvePrice } = requireBookingConfig();
+    if (!resolvePrice) {
+        throw new PriceSourceError('defineBooking({ resolvePrice }) nie jest skonfigurowany — publiczna rezerwacja nie ma z czego wziąć ceny. ' +
+            'Podaj szew czytający cenę z katalogu, np. ' +
+            '`resolvePrice: async (tripRef) => Math.round(Number((await resolveEntry({ id: tripRef, status: "published" }))?.price ?? 0) * 100)`.');
+    }
+    const prices = await Promise.all(refs.map(async (ref) => [ref, await resolvePrice(ref)]));
+    return new Map(prices);
+}
+/**
+ * Pozycje, o których trzeba zapytać katalog. Obsługa podająca cenę jawnie nie wymaga
+ * odczytu — dzięki temu instalacja bez publicznego bookingu (sam admin) działa bez
+ * skonfigurowanego `resolvePrice`.
+ *
+ * `existingByRef` bywa nieznane przed wejściem w transakcję (patrz `editBooking`) — wtedy
+ * pomiń je, a katalog zostanie odpytany też o pozycje, które ostatecznie wezmą snapshot.
+ * Kilka odczytów więcej jest tańsze niż odczyt katalogu pod blokadą wiersza.
+ */
+export function catalogRefsNeeded(actor, items, existingByRef) {
+    return items
+        .filter((it) => {
+        if (actor === 'staff' && it.unitPrice !== undefined)
+            return false;
+        return !existingByRef?.has(it.tripRef);
+    })
+        .map((it) => it.tripRef);
+}
+/**
+ * Wycenia pozycje: odpytuje katalog **tylko o te, których nie da się wycenić inaczej**,
+ * a potem stosuje {@link pickItemPrices}. Wołaj poza transakcją — robi I/O.
+ */
+export async function priceItemsFromCatalog(actor, items, existingByRef) {
+    const catalogPrices = await fetchCatalogPrices(catalogRefsNeeded(actor, items, existingByRef));
+    return pickItemPrices({ actor, items, existingByRef, catalogPrices });
+}

package/dist/db-postgres/schema/booking/bookings.d.ts

@@ -132,6 +132,23 @@ export declare const bookingsTable: import("drizzle-orm/pg-core/table", { with:
         }, {}, {
             $type: BookingTotals;
         }>;
+        pricedAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "priced_at";
+            tableName: "bookings";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         accessToken: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
             name: "access_token";
             tableName: "bookings";

package/dist/db-postgres/schema/booking/bookings.js

@@ -22,6 +22,18 @@ export const bookingsTable = pgTable('bookings', {
         perks: [],
         appliedRules: []
     }),
+    /**
+     * **Moment wyceny — zamrożony.** Każde przeliczenie istniejącej rezerwacji (edycja,
+     * korekta) liczy reguły zależne od czasu (early-bird) na tę datę, **nigdy na `new Date()`**.
+     *
+     * Bez tego cena bazowa była zamrożona, ale data — nie: obsługa księgowała dopłatę
+     * tydzień przed wylotem, `daysUntil(anchor, now)` spadało poniżej progu, early-bird
+     * cicho znikał i klient robił się winien pieniądze.
+     *
+     * NULL dla rezerwacji sprzed 0.37.1 ⇒ czytamy `createdAt`, czyli dokładnie to, czym
+     * było `now` w chwili ich wyceny (zero zmiany zachowania, brak migracji danych).
+     */
+    pricedAt: timestamp('priced_at', { withTimezone: true }),
     /** Unguessable token for the self-service portal (`/rezerwacja/[token]`). */
     accessToken: uuid('access_token').defaultRandom().notNull(),
     staffNotes: text('staff_notes'),

package/dist/updates/0.37.1/index.d.ts

@@ -0,0 +1,2 @@
+import type { CmsUpdate } from '../index.js';
+export declare const update: CmsUpdate;

package/dist/updates/0.37.1/index.js

@@ -0,0 +1,24 @@
+export const update = {
+    version: '0.37.1',
+    date: '2026-07-14',
+    description: 'Dwie łatki cenowe w bookingu. (1) Cena rezerwacji przestaje pochodzić z żądania HTTP — do 0.37.0 publiczne endpointy przyjmowały `unitPrice` prosto z ciała żądania i nikt nie konfrontował go z katalogiem, więc wyprawę dało się zarezerwować za grosz. (2) Data wyceny zostaje zamrożona na rezerwacji — dotąd każde jej dotknięcie (edycja, ale też zaksięgowanie korekty) przeliczało reguły zależne od czasu wg DZISIEJSZEJ daty, przez co early-bird sprzed miesięcy cicho znikał i klient robił się winien pieniądze.',
+    fixes: [
+        '**Bezpieczeństwo (data wyceny).** Nowa kolumna `bookings.priced_at` zamraża moment wyceny. `editBooking` i `priceFromExistingRows` (ścieżka korekt — `adjustments.ts:65` i `:155`) liczą teraz early-bird na tę datę, nie na `new Date()`. Wcześniej wystarczyło, że obsługa zaksięguje dopłatę ustaloną telefonicznie tydzień przed wylotem, a rabat za wczesną rezerwację przepadał. `priceFromExistingRows` straciło parametr `now` — kompilator nie pozwoli już podać tam zegara.',
+        'Rezerwacje sprzed 0.37.1 mają `priced_at = NULL` i wyceniają się z `created_at` — dokładnie tym, czym było wtedy `now`. Zero migracji danych, zero zmiany zachowania.',
+        '**Bezpieczeństwo (ceny).** Trzy publiczne drogi wpuszczały cenę z zewnątrz: tworzenie rezerwacji (`createBookingHandler`), dokładanie wycieczki przez portal (`add-trips`) i portalowa edycja pozycji (`portalEdit` → `editBooking`). Bramka stoi teraz w rdzeniu (`createBooking`/`editBooking`), nie w handlerach, więc każdy przyszły publiczny endpoint jest chroniony domyślnie.',
+        'Cena pozycji już zapisanej w rezerwacji jest brana z jej `unitPriceSnapshot`, a nie przeliczana z katalogu — dotknięcie rezerwacji przez portal nie podniesie klientowi ceny, gdy cennik w międzyczasie poszedł w górę.',
+        'Odczyt katalogu w `editBooking` odbywa się przed otwarciem transakcji: szew klienta robi własne I/O, a wołany pod blokadą `FOR UPDATE` trzymałby wiersz rezerwacji i sięgał po drugie połączenie z tej samej puli.',
+        'Ceny ujemne i niecałkowite (ułamek grosza) są odrzucane — również dla obsługi.'
+    ],
+    features: [
+        '`defineBooking({ resolvePrice })` — serwerowy szew zwracający cenę bazową (dorosłego) pozycji katalogu w groszach. Rdzeń nie zna kształtu katalogu, więc cenę podaje projekt: `resolvePrice: async (tripRef) => Math.round(Number((await resolveEntry({ id: tripRef, status: "published" }))?.price ?? 0) * 100)`.',
+        'Model zaufania oparty na aktorze: `createBooking(input, { actor })` przyjmuje `public | portal | staff`. Domyślny aktor to `public` (niezaufany) — pominięcie parametru nie otwiera dziury. Zalogowana obsługa (`staff`) nadal może podać cenę ręcznie: korekta i rabat negocjowany telefonicznie zostają możliwe.',
+        'Typ `PricedCreateInput` wymusza kolejność: rezerwacji nie da się zbudować z pozycji, której nie wyceniła bramka — pilnuje tego kompilator, nie dyscyplina.'
+    ],
+    breakingChanges: [
+        'Nowa kolumna `bookings.priced_at` — wymagana migracja (`drizzle-kit push`). Nullable, bez backfillu.',
+        '**`defineBooking({ resolvePrice })` jest teraz wymagany, gdy booking wystawia publiczne endpointy** (`createBookingHandler`, portal). Bez niego rdzeń odmawia wyceny (fail-closed) zamiast po cichu zaufać cenie z żądania. Instalacje używające wyłącznie panelu admina działają bez zmian.',
+        '`BookingItemInput.unitPrice` jest opcjonalne i **honorowane wyłącznie dla `actor: "staff"`**. Dla klienta końcowego jest ignorowane — cenę ustala katalog.',
+        'Publiczne API klienta: `createBookingClient().addTrips(token, additions)` oraz `useBooking().addTrips(additions)` nie przyjmują już `unitPrice` w pozycjach (`{ tripRef, assignments }`). Storefronty przekazujące cenę muszą ją usunąć z ładunku — była i tak ignorowana po stronie serwera.'
+    ]
+};

package/dist/updates/index.js

@@ -76,6 +76,7 @@ import { update as update0367 } from './0.36.7/index.js';
 import { update as update0368 } from './0.36.8/index.js';
 import { update as update0369 } from './0.36.9/index.js';
 import { update as update0370 } from './0.37.0/index.js';
+import { update as update0371 } from './0.37.1/index.js';
 export const updates = [
     update0065,
     update0066,
@@ -154,7 +155,8 @@ export const updates = [
     update0367,
     update0368,
     update0369,
-    update0370
+    update0370,
+    update0371
 ];
 export const getUpdatesFrom = (fromVersion) => {
     const fromParts = fromVersion.split('.').map(Number);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "includio-cms",
-	"version": "0.37.0",
+	"version": "0.37.1",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",