includio-cms 0.37.0 → 0.37.2

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

@@ -65,7 +65,8 @@ export function createPortalHandler() {
             }
             try {
                 if (action === 'pay') {
-                    const out = await portalPay(token, Number(body.amount) || 0);
+                    // Kwota NIE pochodzi z żądania — serwer obciąża saldo (bramka kwotowa w rdzeniu).
+                    const out = await portalPay(token);
                     return out ? json(out) : json({ error: 'Not found' }, { status: 404 });
                 }
                 if (action === 'edit') {
@@ -77,8 +78,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/payments.d.ts

@@ -1,5 +1,6 @@
 import type { PaymentEvent } from '../../shop/types.js';
 import type { PaymentKind } from '../ledger.js';
+import { type PaymentActor } from '../payment-amount.js';
 /**
  * Create the deposit payment for a freshly-created booking: ask the first
  * configured adapter for a payment (charging only the deposit amount via an
@@ -22,12 +23,21 @@ export declare function applyWebhookPayment(event: PaymentEvent): Promise<{
     bookingId: string | null;
     kind: PaymentKind | null;
 }>;
+export interface InstallmentPaymentOptions {
+    /** Trust level of the caller. `portal` cannot dictate the amount; `staff` can. */
+    actor: PaymentActor;
+    /** Required for `staff` (positive minor units). Ignored for `portal` (server charges the balance). */
+    amount?: number;
+}
 /**
- * Generate an installment/balance payment link for an arbitrary amount (staff or
- * portal). Records a pending ledger row keyed by the provider ref; the webhook
- * settles it later.
+ * Generate an installment/balance payment link. Records a pending ledger row keyed
+ * by the provider ref; the webhook settles it later.
+ *
+ * The charged amount is gated by {@link resolveInstallmentAmount}: for `actor:'portal'`
+ * the browser cannot dictate it — the server charges the outstanding `totals.balance`
+ * (fail-closed when nothing is due); `actor:'staff'` may bill a custom `amount`.
  */
-export declare function createInstallmentPayment(bookingId: string, amount: number): Promise<{
+export declare function createInstallmentPayment(bookingId: string, opts: InstallmentPaymentOptions): Promise<{
     paymentLink: string | null;
 }>;
 /** Record a manual cash payment (staff). Settles immediately and recomputes status. */

package/dist/booking/server/payments.js

@@ -6,6 +6,7 @@ import { applyPaymentEvent } from '../webhook-logic.js';
 import { deriveStatus } from '../state-machine.js';
 import { netOf } from '../totals.js';
 import { buildPaymentContext } from '../payment-context.js';
+import { resolveInstallmentAmount } from '../payment-amount.js';
 /**
  * Create the deposit payment for a freshly-created booking: ask the first
  * configured adapter for a payment (charging only the deposit amount via an
@@ -127,11 +128,14 @@ export async function applyWebhookPayment(event) {
     });
 }
 /**
- * Generate an installment/balance payment link for an arbitrary amount (staff or
- * portal). Records a pending ledger row keyed by the provider ref; the webhook
- * settles it later.
+ * Generate an installment/balance payment link. Records a pending ledger row keyed
+ * by the provider ref; the webhook settles it later.
+ *
+ * The charged amount is gated by {@link resolveInstallmentAmount}: for `actor:'portal'`
+ * the browser cannot dictate it — the server charges the outstanding `totals.balance`
+ * (fail-closed when nothing is due); `actor:'staff'` may bill a custom `amount`.
  */
-export async function createInstallmentPayment(bookingId, amount) {
+export async function createInstallmentPayment(bookingId, opts) {
     const config = requireBookingConfig();
     const db = getBookingDb();
     const [booking] = await db.select().from(bookingsTable).where(eq(bookingsTable.id, bookingId));
@@ -140,6 +144,8 @@ export async function createInstallmentPayment(bookingId, amount) {
     const adapter = config.payment[0];
     if (!adapter)
         throw new Error('No payment adapter configured');
+    // Amount gate (payment-side twin of the 0.37.1 price gate).
+    const amount = resolveInstallmentAmount(booking.totals.balance, opts.actor, opts.amount);
     const ctx = {
         ...buildPaymentContext({
             accessToken: booking.accessToken,
@@ -165,7 +171,7 @@ export async function createInstallmentPayment(bookingId, amount) {
         status: 'pending',
         providerRef: result.providerRef ?? null,
         paymentLink: result.redirectUrl ?? null,
-        createdBy: 'staff'
+        createdBy: opts.actor
     });
     return { paymentLink: result.redirectUrl ?? null };
 }

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

@@ -123,8 +123,11 @@ export declare function portalEdit(token: string, changes: BookingEditChanges):
     }[];
     ledger: import("../ledger.js").LedgerSummary;
 } | null>;
-/** Portal: create an installment/balance payment link. */
-export declare function portalPay(token: string, amount: number): Promise<{
+/**
+ * Portal: create a balance payment link. The amount is NOT taken from the request —
+ * the server charges the outstanding `totals.balance` (see {@link createInstallmentPayment}).
+ */
+export declare function portalPay(token: string): Promise<{
     paymentLink: string | null;
 } | null>;
 /**
@@ -173,7 +176,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

@@ -2,6 +2,7 @@ import { and, eq, inArray, isNull } from 'drizzle-orm';
 import { getBookingDb } from './db.js';
 import { bookingsTable, bookingItemsTable, bookingPersonsTable, bookingItemPersonsTable, bookingPaymentsTable } from '../../db-postgres/schema/booking/index.js';
 import { ledgerSummary } from '../ledger.js';
+import { netOf } from '../totals.js';
 import { editBooking } from './bookings.js';
 import { createInstallmentPayment } from './payments.js';
 import { resolveItemSchema, saveParticipantData } from './participants.js';
@@ -29,7 +30,9 @@ export function toPortalView(booking, items, participants, payments, schemaByIte
             kind: p.kind,
             paidAt: p.paidAt ?? null
         })),
-        ledger: ledgerSummary(booking.totals.gross, payments)
+        // Ledger balance must fold in discounts/surcharges — feed NET (like `totals.balance`),
+        // not the pre-discount `gross`, so `ledger.balance === totals.balance`.
+        ledger: ledgerSummary(netOf(booking.totals), payments)
     };
 }
 /** Resolve a booking by its unguessable portal access token (active only). */
@@ -138,12 +141,15 @@ export async function portalEdit(token, changes) {
     await editBooking(booking.id, changes, { actor: 'portal' });
     return portalView(token);
 }
-/** Portal: create an installment/balance payment link. */
-export async function portalPay(token, amount) {
+/**
+ * Portal: create a balance payment link. The amount is NOT taken from the request —
+ * the server charges the outstanding `totals.balance` (see {@link createInstallmentPayment}).
+ */
+export async function portalPay(token) {
     const booking = await resolveByToken(token);
     if (!booking)
         return null;
-    return createInstallmentPayment(booking.id, amount);
+    return createInstallmentPayment(booking.id, { actor: 'portal' });
 }
 /**
  * Portal self-service: customer fills their own participant data. Verifies the
@@ -223,10 +229,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/components/ui/input-group/input-group-input.svelte.d.ts

@@ -2,7 +2,7 @@ declare const InputGroupInput: import("svelte").Component<(Omit<import("svelte/e
     type: "file";
     files?: FileList;
 } | {
-    type?: "number" | "image" | "url" | "text" | "date" | "search" | "radio" | "hidden" | "email" | "password" | (string & {}) | "reset" | "color" | "button" | "checkbox" | "tel" | "time" | "month" | "submit" | "datetime-local" | "range" | "week";
+    type?: "number" | "image" | "url" | "text" | "date" | "search" | "radio" | "email" | "hidden" | "password" | (string & {}) | "reset" | "color" | "button" | "checkbox" | "tel" | "time" | "month" | "submit" | "datetime-local" | "range" | "week";
     files?: undefined;
 })) & {
     ref?: HTMLElement | null | undefined;

package/dist/components/ui/sidebar/sidebar-input.svelte.d.ts

@@ -2,7 +2,7 @@ declare const SidebarInput: import("svelte").Component<(Omit<import("svelte/elem
     type: "file";
     files?: FileList;
 } | {
-    type?: "number" | "image" | "url" | "text" | "date" | "search" | "radio" | "hidden" | "email" | "password" | (string & {}) | "reset" | "color" | "button" | "checkbox" | "tel" | "time" | "month" | "submit" | "datetime-local" | "range" | "week";
+    type?: "number" | "image" | "url" | "text" | "date" | "search" | "radio" | "email" | "hidden" | "password" | (string & {}) | "reset" | "color" | "button" | "checkbox" | "tel" | "time" | "month" | "submit" | "datetime-local" | "range" | "week";
     files?: undefined;
 })) & {
     ref?: HTMLElement | null | undefined;

package/dist/core/fields/jsonLd/builders.d.ts

@@ -0,0 +1,74 @@
+import type { MediaFile } from '../../../types/media.js';
+import { type JsonLdNode } from './graph.js';
+export interface OrganizationInput {
+    name: string;
+    url?: string;
+    logo?: string | MediaFile;
+    sameAs?: string[];
+    description?: string;
+}
+export declare function organization(input: OrganizationInput): JsonLdNode;
+export interface PostalAddressInput {
+    streetAddress?: string;
+    addressLocality?: string;
+    postalCode?: string;
+    addressRegion?: string;
+    addressCountry?: string;
+}
+export interface GeoInput {
+    latitude?: number;
+    longitude?: number;
+}
+export interface LocalBusinessInput extends OrganizationInput {
+    telephone?: string;
+    email?: string;
+    image?: string | MediaFile;
+    address?: PostalAddressInput;
+    geo?: GeoInput;
+    openingHours?: string | string[];
+    priceRange?: string;
+}
+export declare function localBusiness(input: LocalBusinessInput): JsonLdNode;
+export interface WebSiteInput {
+    name: string;
+    url: string;
+    description?: string;
+    inLanguage?: string;
+    /** e.g. https://site/search?q={search_term_string} */
+    searchUrlTemplate?: string;
+}
+export declare function website(input: WebSiteInput): JsonLdNode;
+export interface WebPageInput {
+    name: string;
+    url: string;
+    description?: string;
+    inLanguage?: string;
+    isPartOf?: string;
+}
+export declare function webPage(input: WebPageInput): JsonLdNode;
+export declare function breadcrumbList(items: Array<{
+    name: string;
+    url: string;
+}>): JsonLdNode;
+export interface ArticleInput {
+    headline: string;
+    url?: string;
+    image?: string | MediaFile;
+    description?: string;
+    datePublished?: string;
+    dateModified?: string;
+    author?: string | {
+        name: string;
+        url?: string;
+    };
+    publisher?: OrganizationInput;
+    inLanguage?: string;
+    section?: string;
+    keywords?: string;
+}
+export declare function article(input: ArticleInput): JsonLdNode;
+export declare function blogPosting(input: ArticleInput): JsonLdNode;
+export declare function faqPage(items: Array<{
+    question: string;
+    answer: string;
+}>): JsonLdNode;