your-ai-workflow-firebase-os 2.0.3 → 2.0.8

package/dist/lib/recordLock.d.ts

@@ -34,15 +34,90 @@ export declare const deleteSwitchApplies: (config: any) => boolean;
 export declare const deleteBy: (config: any) => DeleteBy;
 /** The list a record's `lock.delete` should hold under this row's answer — null when no lock. */
 export declare const lockFor: (config: any) => string[] | null;
+/**
+ * Who may hand an entry to somebody, or take it back: the admins alone, or
+ * whoever holds it — which is what the rules said of everybody until 2.0.8.
+ */
+export type HandOnBy = 'admin' | 'holder';
+/** The two answers, in the owner's words — the safer one first. */
+export declare const HAND_ON_CHOICES: {
+    value: HandOnBy;
+    label: string;
+}[];
+export declare const HAND_ON_HINTS: Record<HandOnBy, string>;
+/**
+ * Do these words give whoever they are about the handing on — "pass it on",
+ * "can reassign" — and not only the being handed? `own` is the name of the
+ * group whose box they are, so its own name in front of the verb is not read
+ * as somebody else.
+ *
+ * Wrong in ONE direction only, on purpose: words it cannot be sure of give
+ * nothing, the wall stays, and the row's choice shows the owner what was
+ * read — one press mends it. Read the other way, nobody would know.
+ */
+export declare const givesHandingOn: (words: unknown, own?: string | null) => boolean;
+/**
+ * The row's answer, read off a page config.
+ *
+ * It is asked of ONE kind of page: where a new arrival reaches nobody on the
+ * team until it is handed to a person (`arrivalsTo: 'handed'`). There,
+ * "nobody else on your team sees it" is only true while the person holding
+ * one cannot pass it round, so until the owner chooses it is the admins' —
+ * unless her own words give a group the passing on. Everywhere else it is
+ * whoever holds it, as it always was: a client portal's whole point is a card
+ * going from one person to the next, and a page whose own button sends what
+ * somebody just added to a role would be refused its own send.
+ */
+export declare const handOnBy: (config: any) => HandOnBy;
+/** The list a record's `lock.send` should hold under this row's answer — null when no lock. */
+export declare const sendLockFor: (config: any) => string[] | null;
+/** The whole lock a record should carry: who may delete it, who may hand it on — null when neither is kept. */
+export interface RecordLock {
+    delete?: string[];
+    send?: string[];
+}
+export declare const wholeLockFor: (config: any) => RecordLock | null;
+/**
+ * The lock a page's records should carry, as one word that moves whenever
+ * the lock does — what a template's catch-up waits on. The lock is read off
+ * more than its two switches: until the owner chooses, who hands one on comes
+ * from the words in each group's box and from who is ticked, so a catch-up
+ * that waited on the switches alone slept through a change of words.
+ */
+export declare const lockKey: (config: any) => string;
+/**
+ * Is this an entry the hand-on wall is ABOUT: one that arrived from another
+ * page, one that was handed to somebody, or one that carries the list
+ * already (an admin made it, or it was handed and taken back).
+ *
+ * What somebody ADDS on the page themselves is not. A buyer's note on their
+ * order is saved and then sent to whoever holds the order — two writes — and
+ * born locked, the second was refused to its own author (2026-09-27). The
+ * lock kept nothing from them either: whoever makes an entry chooses its
+ * lists as they make it, and the rules allow that. The wall is for what was
+ * handed to you, never for what you made.
+ */
+export declare const isHandedOut: (record: any) => boolean;
+/** The whole lock THIS record should carry: the page's, with the hand-on list only where the wall is about it. */
+export declare const lockForRecord: (record: any, config: any) => RecordLock | null;
 /**
  * What the templates write beside `uid` on every record saved through the
  * page: the lock, or nothing at all. Spread it into the record.
+ *
+ * `role` is whoever is saving. Only an admin's own entry is born with the
+ * hand-on list — it is theirs to hand out. Anybody else's is born without
+ * it, so the send that follows their save is not refused (isHandedOut).
  */
-export declare const lockStamp: (config: any) => {
-    lock?: {
-        delete: string[];
-    };
+export declare const lockStamp: (config: any, role?: string | null) => {
+    lock?: RecordLock;
 };
+/**
+ * May somebody with this role hand this entry on, or take it back — the
+ * answer the pasted rules give to a change of its lists. An entry with no
+ * such lock: yes, where they may change it at all. A locked one: admins, and
+ * anybody the list names.
+ */
+export declare const maySend: (record: any, role: string | null | undefined) => boolean;
 /**
  * May somebody with this role delete this record — the answer the pasted
  * rules give. An unlocked record: yes (whatever else the page's space says
@@ -55,7 +130,7 @@ export declare const lockStamp: (config: any) => {
  * anybody at all, the owner included, which is what the words say.
  */
 export declare const mayDelete: (record: any, role: string | null | undefined) => boolean;
-/** Does this record carry exactly the lock the row asks for? */
+/** Does this record carry exactly the lock the row asks of IT — both of its lists? */
 export declare const lockIsRight: (record: any, config: any) => boolean;
 /**
  * Stamp the records that were saved before the switch moved, and unstamp

package/dist/lib/recordPrice.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The price a record asks — read the same way on both sides of a payment.
+ *
+ * The server checks every line of a basket that names its collection against
+ * the record before anything is charged (server/prices.ts), and `<Basket>`
+ * keeps the lines it holds at that same price (lib/basket.ts withRecordPrice).
+ * Two readings of one price would refuse a basket the page thought was right,
+ * so there is one, here, with no Stripe and no database in it.
+ */
+/**
+ * A price as the app writes one: a number, or words around one — "$48",
+ * "48 USD", "1,200.00", "12,50" — read the way lib/bookingHold.ts onceTotal
+ * reads a booking's price, so a shop is never refused for how its owner
+ * typed a price. null when there is no number in it at all.
+ */
+export declare const asPrice: (value: unknown) => number | null;
+/**
+ * The price a record asks for one of it — its variant's when a variant is
+ * named and carries one, else the record's own — or null when it names none.
+ */
+export declare function priceOnRecord(record: Record<string, unknown> | null | undefined, variant?: string): number | null;

package/dist/lib/registrationFields.d.ts

@@ -68,8 +68,14 @@ export interface RegistrationField {
      * never hidden.
      */
     editable: boolean;
-    /** `select` only: what it offers. */
+    /** `select` only: what it offers — each one what is saved when it is picked. */
     options?: string[];
+    /**
+     * `select` only, and only where the file gave a choice words of its own
+     * ({ value: 'sole', label: 'Sole trader' }): those words, by the value they
+     * stand for. What the person picks from and what an answer reads as.
+     */
+    optionLabels?: Record<string, string>;
     /** The grey words in an empty box, where the owner's file gives one. */
     placeholder?: string;
 }
@@ -138,6 +144,12 @@ export declare const fieldsForProfile: (profile: Record<string, any> | null | un
 export declare function isAnswered(profile: Record<string, any> | null | undefined, field: RegistrationField): boolean;
 /** One answer as it reads on a screen. */
 export declare function answerWords(profile: Record<string, any> | null | undefined, field: RegistrationField): string;
+/**
+ * The words a choice of a `select` question is picked by: the label the file
+ * gave it, or the value itself when it gave none. Only a string counts, so a
+ * choice called "constructor" is never read as something every object has.
+ */
+export declare const choiceWords: (field: RegistrationField, value: string) => string;
 /**
  * A locked answer: the owner said this one is fixed, and it has been given.
  * Before it is given it is an ordinary question — a box nobody can ever fill

package/dist/lib/reservedAddresses.d.ts

@@ -9,8 +9,13 @@
  *
  * reservedAddresses.test.ts reads App.tsx and fails when a fixed route is
  * missing here, so a new screen cannot be forgotten. Routes that only match
- * with something after them (/book/{id}, /pay/{id}) reserve nothing: a page
- * at /book is a page of the owner's, and the app's route never answers it.
+ * with something after them (/pay/{id}) reserve nothing: a page at /pay is a
+ * page of the owner's, and the app's route never answers it.
+ *
+ * /calendar, /bookings, /book and /booking are held for the bookings rebuild
+ * before it ships (BOOKINGS-DESIGN-2026-09-27.md), so no owner builds a page
+ * there that the new screens would then take over. Until then each lands on
+ * the dashboard or the home page, as /schedule does.
  */
 export declare const RESERVED_ADDRESSES: ReadonlySet<string>;
 /** Whether an address — with or without its leading slash — is one of the app's own. */

package/dist/lib/schedule.d.ts

@@ -349,6 +349,12 @@ export interface TakenTime {
     start: string;
     end: string;
     createdAt?: number;
+    /**
+     * A paid hold that no longer keeps its time — let go, or run out unpaid
+     * (bookingHold.ts). Only ever on a list asked for with `keepOpen`: every
+     * other reader is never handed such a hold at all.
+     */
+    open?: boolean;
 }
 /** Whether two stretches of time share a minute — touching ends (10:00–11:00 and 11:00–12:00) do not. */
 export declare const overlaps: (a: {
@@ -852,8 +858,30 @@ export declare const wantsBooking: (words: string) => boolean;
  * nothing is booked here.
  */
 export declare const asksForBooking: (config: any, booking?: PageBooking | null) => boolean;
+/**
+ * Whether a page's visitors book straight on the HOURS it was given — the
+ * booking sentence's own test, so the row and the sentence agree on it.
+ *
+ * A time booked on hours is always free: a week carries no price, only a
+ * booking link does, so the form has nothing to charge and ContactPopup takes
+ * no money. A page that books on hours AND is ticked for a payment was told
+ * both "never a PayButton or a price for a booking" and "<BuyButton
+ * amount={18}>", and the owner who wrote "paid when they book" got a page
+ * that took bookings for nothing (the Lotus Yoga rehearsal, 2026-09-26).
+ */
+export declare const booksOnHours: (config: any, hours: MemberSchedule[], meetings?: MemberSchedule[]) => boolean;
+export declare const PAID_BOOKING_WORDS: RegExp;
+/**
+ * Whether the owner's words make the payment the price of the booking (see
+ * PAID_BOOKING_WORDS). Read one part of a sentence at a time — split at a
+ * stop (never the point in "£12.50"), a line, a colon, a bracket, a dash or
+ * a comma — so "the first class is free, the rest are paid when they book"
+ * ties, "no booking fee" never does, and "book a free class and pay by card
+ * for your mat" no longer held the page and took its mats away.
+ */
+export declare const tiesPaymentToBooking: (words: string) => boolean;
 /** The one rule every booking sentence carries, word for word, wherever it is built. */
-export declare const BOOKING_RULE = "Booking goes through the app's own form system: the page's form gets ONE question of type 'schedule', and the built-in form draws the picker \u2014 never build a calendar, a time picker, a list of times or a bookings collection of your own. The app shows every visitor the free times in their own time zone, stops two people taking the same time, and lists every booking on my Schedule screen. It also tells the people it was booked with \u2014 the booking is in their bell and on their own calendar the moment it is made \u2014 so never send a notification of your own about a booking.";
+export declare const BOOKING_RULE = "Booking goes through the app's own form system: the page's form gets ONE question of type 'schedule', and the built-in form draws the picker \u2014 never build a calendar, a time picker, a list of times or a bookings collection of your own. The app shows every visitor the free times in their own time zone, stops two people taking the same time, and lists every booking on my Schedule screen. It also tells the people it was booked with \u2014 the booking is in their bell and on their own calendar the moment it is made \u2014 so never send a notification of your own about a booking. When the time booked takes a payment, the same form sends the visitor to pay before it is theirs \u2014 so never add a PayButton, a checkout or a price of your own for a booking.";
 /**
  * The exact question the assistant adds to the form's fields — copied
  * verbatim, ids and all. It carries no `look`: that is the assistant's call,
@@ -899,9 +927,15 @@ export declare const CHOOSE_RULE = "With party: 'choose' the built-in picker sho
  */
 export declare const togetherChoiceLine: () => string;
 /**
- * What the page asks before the time is picked, in the owner's words. The
- * owner writes what they need to know, not fields — the assistant chooses
- * the kind of box each answer takes, the way it does everywhere else.
+ * What the page asks when somebody books, in the owner's words. The owner
+ * writes what they need to know, not fields — the assistant chooses the kind
+ * of box each answer takes, the way it does everywhere else.
+ *
+ * It never says WHEN they are asked. It used to say "before the time is
+ * picked", two lines under BOOKING_LOOK_LINE's calendar, which puts the other
+ * questions AFTER the time — the Lotus Yoga rehearsal (2026-09-26) read the
+ * order both ways in one sentence. Where they sit is the look's: the built-in
+ * form leads with a calendar and follows it with the rest.
  */
 export declare const askLine: (ask: string) => string;
 /**
@@ -913,6 +947,27 @@ export declare const askLine: (ask: string) => string;
 export declare const BOOKING_LOOK_LINE = "Decide how the picker looks from my words and add a look to that question. look: 'calendar' when the page is about booking \u2014 the question draws a whole calendar with the free times under it, so show the form inline with <ContactPopup formId='\u2026' isInline /> and give it the full width of the page, the other questions following once a time is picked. look: 'compact' when booking is one question among others \u2014 the question draws a compact picker of days and times and sits among the other questions like any of them, and the form shows the way any other form on the page does. If my words do not say, a page that is about nothing but booking gets the calendar and every other page gets the compact picker.";
 /** The hook line a team page reads bookings with — the ONE way, named the same everywhere. */
 export declare const USE_BOOKINGS_RULE = "Read them with useBookings() from 'your-ai-workflow-firebase-os' \u2014 { loading, bookings, error }, each booking with id, start and end (ISO, UTC), memberId, memberName, name, email, answers and formId \u2014 the upcoming ones, soonest first; show error when it is set, format times in the reader's own zone, and cancel one with cancelBooking(id, { reason, side: 'host' }) from the same package \u2014 always with a reason, because it is what the other side reads. Never read mem_bookings or pub_bookings by hand, and never write to them. An entry with own:true is an event the owner put on their own calendar rather than a booking: it has no name or email, so title every entry with eventName(booking) from the same package. An entry with cancelled:true was called off \u2014 its time is free again, so keep it in the list greyed out and struck through rather than dropping it, and show its cancelReason when it has one. An entry with pending:true is booked but NOT yet agreed to by the person whose hour it is: mark it Pending and never draw it as a settled meeting. They accept their own with acceptBooking(id) \u2014 offer that only when booking.memberId is the signed-in person's own uid, because a meeting in somebody else's diary is not theirs to agree to. Turning a booking down is cancelBooking with a reason, never a state of its own.";
+/**
+ * Words that make a team page about bookings that have ENDED — today's, who
+ * came, what happened. useBookings() drops a booking the moment it ends, so a
+ * page for "today's classes at a glance … a tick beside each student to mark
+ * who came" lost each class as it finished (the Lotus Yoga rehearsal,
+ * 2026-09-26). The option that keeps them was named nowhere a page is built
+ * from.
+ */
+export declare const PAST_BOOKINGS_WORDS: RegExp;
+/** Said beside USE_BOOKINGS_RULE when the words are about bookings that end while the page is open. */
+export declare const PAST_BOOKINGS_LINE = "useBookings() drops a booking the moment it ends, and this page is about ones that have: read them with useBookings({ includePast: true }) instead \u2014 the upcoming ones soonest first, then the past ones, most recent first \u2014 and pick the day or the stretch it shows by each booking's start, in the reader's own zone. A class that has finished is still on today's list.";
+/**
+ * Words that put something ON a booking from a team page — a tick for who
+ * came, a note, a mark. The Lotus Yoga rehearsal (2026-09-26) built its
+ * Teachers page with the ticks and the notes in useState, so a reload lost
+ * every one: nothing said where they are saved, and the booking itself is
+ * not the page's to write.
+ */
+export declare const BOOKING_MARK_WORDS: RegExp;
+/** Where a team page keeps what it marks on a booking: its own records, one per booking. */
+export declare const BOOKING_MARKS_LINE = "What this page puts ON a booking \u2014 who came, a note, a tick \u2014 is never written onto the booking, which is not the page's to write: it is ONE record of this page's own per booking, carrying bookingId: booking.id, added with await actions.saveRecord({ bookingId: booking.id, \u2026 }) the first time something is marked and changed with actions.updateRecord(id, change) after, and found again in actions.records by that bookingId. So a reload keeps every tick and every note, and everybody on this page sees the same ones. Never keep them only in state.";
 /**
  * The OTHER window on the bookings, and the one that had none.
  *
@@ -967,4 +1022,4 @@ export declare function bookingLines(config: any, hours: MemberSchedule[], teamP
  * What a page LINKED to a booking page is told — the other half of the
  * counter. Times are taken over there; here the team reads them.
  */
-export declare function linkedBookingLine(partnerPath: string, config: any, hours: MemberSchedule[], teamPage: boolean, meetings?: MemberSchedule[]): string;
+export declare function linkedBookingLine(partnerPath: string, config: any, hours: MemberSchedule[], teamPage: boolean, meetings?: MemberSchedule[], ownWords?: string): string;

package/dist/lib/scheduleData.d.ts

@@ -137,7 +137,9 @@ export declare function useTeamMembers(): {
  * is still running is kept too, so a long meeting under way blocks the slots
  * inside it.
  */
-export declare function useTakenSlots(memberIds: string[], from: Date): TakenTime[];
+export declare function useTakenSlots(memberIds: string[], from: Date, options?: {
+    keepOpen?: boolean;
+}): TakenTime[];
 export declare const SLOT_TAKEN_MESSAGE = "That time was just taken \u2014 pick another.";
 /**
  * The ids a taken time of this member could carry and still overlap the
@@ -161,8 +163,40 @@ export declare function overlappingIds(slot: Slot): string[];
  * write, which is most of the wait between pressing Book and being booked.
  * A transaction may read in any order as long as every read happens before
  * the first write, so one Promise.all costs one round trip instead.
+ *
+ * A PAID hold that was let go, or ran out unpaid, is no hold at all: its
+ * time is taken over, the new hold carrying the server's pass for the old
+ * one. One that ran out is asked about first — see bookingHold.ts.
  */
 export declare function claimSlot(slot: Slot): Promise<string | null>;
+/**
+ * Take a time somebody is about to PAY for: held until `holdUntil`, and free
+ * again after it unless the payment is written on. Answers the deadline it
+ * really holds until — 0 when the app's pasted rules predate paid holds and
+ * refused the deadline, in which case the time is held for good, the way
+ * every paid booking was before, rather than not booked at all.
+ */
+export declare function holdSlot(slot: Slot, holdUntil: number): Promise<{
+    error: string;
+} | {
+    holdUntil: number;
+}>;
+/**
+ * Write the server's passes onto holds: `paid` keeps each for good, `letGo`
+ * gives each time back. Anybody may, guests included — the pass is the
+ * permission. Never throws.
+ *
+ * Answers which were `written` — the hold now says it, or no longer stands to
+ * say anything — and which the rules `refused` while the hold still stands
+ * unmarked. That second list is not noise: the rules check a pass against a
+ * key only an admin's visit puts in (admin_keys/plans), and until then every
+ * pass is refused. Swallowed, a PAID hour ran out an hour later and was
+ * offered to everybody as free; now the caller keeps the pass and tries again.
+ */
+export declare function markHolds(passes: Record<string, string>, as: 'paid' | 'letGo'): Promise<{
+    written: string[];
+    refused: string[];
+}>;
 /** Give a claimed time back — used when the form entry after it could not be saved. */
 export declare function releaseSlot(slot: Slot): Promise<void>;
 export interface BookingDetails {
@@ -174,6 +208,8 @@ export interface BookingDetails {
     /** The one-off payment the schedule asked for, or '' — and the checkout session that pays it, or ''. */
     paymentId?: string;
     paymentSession?: string;
+    /** When a paid booking's hold runs out unpaid — the hold's own deadline; absent for a booking kept for good. */
+    holdUntil?: number;
     /** The zone the person booked in — their clock, for the confirmation. */
     timeZone: string;
     name: string;
@@ -203,6 +239,11 @@ export interface Booking extends Slot {
     /** The payment the schedule asked for, and the checkout session that pays it — '' when the booking was free. */
     paymentId: string;
     paymentSession: string;
+    /**
+     * When the time goes back if this booking is never paid for — set on a
+     * paid booking whose hold can run out (bookingHold.ts), absent otherwise.
+     */
+    holdUntil?: number;
     /**
      * Called off, but still on the calendar. Cancelling gives the time back and
      * leaves the booking where it was, marked — a booking that vanishes takes

package/dist/lib/sentInPlace.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Where the thank-you's top goes, as a distance from the top of the screen.
+ *
+ * `top` is the form's top and `height` its height before the swap, `thanks`
+ * the thank-you's own height, `head` the room a pinned menu takes at the top
+ * and `view` the height of the screen. Pure, so it can be tested without a
+ * browser.
+ */
+export declare function thanksSpot({ top, height, thanks, head, view }: {
+    top: number;
+    height: number;
+    thanks: number;
+    head: number;
+    view: number;
+}): number;
+/**
+ * The element that scrolls the page a form sits in: the nearest ancestor
+ * that scrolls now, or the window. Null inside something pinned to the
+ * screen that does not scroll (a pop-up whose content fits): nothing there
+ * may be scrolled, and the page behind it must not move.
+ */
+export declare function scrollerOf(el: HTMLElement): HTMLElement | null;
+/**
+ * Close `box` from the form's height (`formHeight`, measured before the swap)
+ * down to the thank-you it now holds, keeping `thanks` still on the screen.
+ * Call it in a layout effect, in the commit that put the thank-you in, so
+ * the first frame painted is already the right one. Hands back a stop that
+ * lands everything at its end state at once.
+ */
+export declare function settleSent(box: HTMLElement, thanks: HTMLElement, formHeight: number, still: boolean): () => void;

package/dist/lib/serviceStatus.d.ts

@@ -10,9 +10,11 @@ export interface ServerAnswer<T> {
 }
 /**
  * One status route, read on mount — and every `every` ms when asked, for
- * the chips that should notice a paste made in another tab.
+ * the chips that should notice a paste made in another tab. `authed` sends
+ * the signed-in person's token: the Email tab's read, which is told the last
+ * email that could not go when the reader is an admin.
  */
-export declare function useServerStatus<T>(path: string, parse: (body: any) => T, every?: number): ServerAnswer<T>;
+export declare function useServerStatus<T>(path: string, parse: (body: any) => T, every?: number, authed?: boolean): ServerAnswer<T>;
 export interface StripeStatus {
     /** A Stripe secret key is in the server's environment. */
     configured: boolean;
@@ -21,20 +23,42 @@ export interface StripeStatus {
     webhookConfigured: boolean;
 }
 export declare const parseStripeStatus: (body: any) => StripeStatus;
+/** The last email that could not go: when, to whom (masked), and why in plain words. */
+export interface EmailRefusal {
+    at: number;
+    to: string;
+    cause: string;
+    reason: string;
+}
 export interface ResendStatus {
     /** A Resend key is in the server's environment. */
     configured: boolean;
-    /** The address mail goes out as — resend.dev until the owner sets their own. */
+    /** The owner's Send email switch. */
+    enabled: boolean;
+    /** What the key may do; null with no key. */
+    key: 'works' | 'sending-only' | 'refused' | null;
+    /** The address mail goes out as — Resend's practice address until her domain is verified. */
     from: string | null;
-    /** How many addresses owner mail reaches — VITE_ADMIN_EMAILS, or the signed-in admins. */
+    /** Mail reaches customers: false for the practice address and for a domain not verified yet. */
+    senderVerified: boolean;
+    /** The domain she added on the Email tab, or null. */
+    domain: string | null;
+    /** How many addresses her own mail reaches. */
+    ownerCount: number;
+    /** The old name for ownerCount, the same number. */
     adminCount: number;
+    /** "Email buyers a receipt" and "Email me each sale", on the Email tab. */
+    receipts: boolean;
+    saleAlerts: boolean;
+    /** Only an admin's read is told this. */
+    lastRefusal: EmailRefusal | null;
 }
 export declare const parseResendStatus: (body: any) => ResendStatus;
 export declare const STATUS_PATH: Record<ConnectedService, string>;
 /** /api/payments/status — once, or every `every` ms. */
 export declare const useStripeStatus: (every?: number) => ServerAnswer<StripeStatus>;
-/** /api/email/status — once, or every `every` ms. */
-export declare const useResendStatus: (every?: number) => ServerAnswer<ResendStatus>;
+/** /api/email/status — once, or every `every` ms; `authed` for the Email tab's own read. */
+export declare const useResendStatus: (every?: number, authed?: boolean) => ServerAnswer<ResendStatus>;
 export interface ServiceState {
     /** Until the server has answered once — a screen shows nothing for the service meanwhile. */
     loading: boolean;
@@ -42,5 +66,11 @@ export interface ServiceState {
     configured: boolean;
     /** The owner's switch on the service's own screen. */
     on: boolean;
+    /**
+     * Email only: the key is in but mail goes out from Resend's practice
+     * address or a domain not verified yet, so it reaches the owner and
+     * nobody else. What is meant for a customer waits; her own alerts work.
+     */
+    practice?: boolean;
 }
 export declare function useServiceStatus(which: ConnectedService): ServiceState;

package/dist/lib/serviceSwitches.d.ts

@@ -32,3 +32,19 @@ export interface ServiceSwitchState {
  * why, so "the switch does nothing" can never be the reading.
  */
 export declare function useServiceSwitch(which: ServiceSwitch): ServiceSwitchState;
+/** "Email buyers a receipt" and "Email me each sale", on the Email tab. */
+export type PaymentMail = 'receipts' | 'saleAlerts';
+export interface PaymentMailState {
+    loading: boolean;
+    receipts: boolean;
+    saleAlerts: boolean;
+    /** Flip one. Writes at once; the snapshot confirms. Words when the write is refused. */
+    set: (which: PaymentMail, on: boolean) => Promise<string | null>;
+}
+/**
+ * The two payment emails, one pair for the whole app, stored beside the Send
+ * email switch on sys_configs/email and read by the server when a payment
+ * comes in (paymentMailOn), so a flip works on the next sale with nothing to
+ * paste again. Anything but an explicit false is on, as the server reads it.
+ */
+export declare function usePaymentMail(): PaymentMailState;

package/dist/lib/soldLines.d.ts

@@ -0,0 +1,80 @@
+/**
+ * What a checked basket was charged for, line by line — written onto the
+ * payment by the server and read back by the owner's browser, the same way
+ * on both sides of it (as lib/recordPrice.ts is one reading of a price).
+ *
+ * The checkout route writes it for a basket whose prices it checked against
+ * the records (server/sold.ts): `sold`, then `sold2`… up to five values,
+ * `record:variant:quantity` per line, comma-joined. The stock is counted off
+ * it (/payments/sold), and since 2026-09-27 so is an order: only an order's
+ * TOTAL used to be checked against its payment, so a checked basket of one
+ * €5 candle beside an order entry saying "Blazer, €5" arrived on the Orders
+ * page as a paid €5 blazer. Now an order is let in only when its lines are
+ * the lines this list says were charged (lib/paidInFull.ts).
+ *
+ * Every line of the basket is carried, in the basket's order:
+ *   - a free one too, marked `:free` — it is never counted off the stock
+ *     (sending one costs nothing), but an order cannot add one of its own;
+ *   - an id that is not letters, figures, `-` and `_` is carried
+ *     percent-encoded, so an honest variant called "Sand, 50 ml" still
+ *     matches its order instead of holding it back for good;
+ *   - a basket too long for five values keeps its first lines and says how
+ *     many more there were (`+12`), so an honest long basket still arrives:
+ *     its order has to have exactly that many lines, the first of them these.
+ *
+ * No database, no Stripe.
+ */
+export declare const SOLD_KEY = "sold";
+/** A Stripe metadata value holds 500 characters; the list is split over `sold`, `sold2`… when a basket is longer. */
+export declare const SOLD_VALUE_MAX = 500;
+export declare const SOLD_KEYS_MAX = 5;
+/** Every key the list is written under. The server's alone: whatever a page sends under them is thrown away. */
+export declare const SOLD_KEYS: readonly string[];
+export declare const isSoldKey: (key: string) => boolean;
+/** One line of a checked basket, as the payment carries it. */
+export interface SoldLine {
+    record: string;
+    /** '' when the line names none. */
+    variant: string;
+    quantity: number;
+    /** Charged nothing: a free gift. */
+    free?: true;
+}
+/**
+ * One line as it is counted — its record, its variant, how many, and whether
+ * it cost anything — or null for a line that names no record, or none of it.
+ * The server reads a checkout line through this and the browser an order's,
+ * so the two can never be told apart by how they were read. Pure.
+ */
+export declare function soldLine(record: unknown, variant: unknown, quantity: unknown, price: unknown): SoldLine | null;
+/**
+ * An order's lines as <Checkout> names them to the server
+ * (components/Checkout.tsx): the record is the line's `id`, the variant its
+ * `variantId`, else its `variant`. Null when a line names no record: such a
+ * line was never one of a checked basket's. Pure.
+ */
+export declare function orderLines(items: unknown): SoldLine[] | null;
+/**
+ * The metadata that carries them, cut into values Stripe will take. A basket
+ * too long for five values keeps its first lines and says how many it left
+ * out — the sale is never sunk over a count. Pure.
+ */
+export declare function soldMetadata(lines: SoldLine[]): Record<string, string>;
+/**
+ * The list back out of a payment's metadata, with how many lines it left
+ * out — or null when the payment carries none: a fee, a deposit, a basket
+ * that named no collection. Pure.
+ */
+export declare function readSold(metadata: Record<string, string> | null | undefined): {
+    lines: SoldLine[];
+    leftOut: number;
+} | null;
+/** The lines alone — none for a payment that carries no list. */
+export declare const parseSold: (metadata: Record<string, string> | null | undefined) => SoldLine[];
+/**
+ * Whether an order's items are the lines a payment carries: the same
+ * records, the same variants, the same quantities, the same free ones, in
+ * the same order — and, where the list was cut, exactly as many more. Null
+ * when the payment carries no list, so there is nothing to compare. Pure.
+ */
+export declare function sameAsSold(items: unknown, metadata: Record<string, string> | null | undefined): boolean | null;

package/dist/lib/stock.d.ts

@@ -16,6 +16,19 @@ export interface Stocked {
 }
 /** record → variant ('' for the record's own count) → sold since it was set. */
 export type SoldCounts = Record<string, Record<string, number>>;
+/**
+ * The stamp each count was ANSWERED for, by `record|variant`. A count is the
+ * sales since one particular stamp; right after the team saves a new count
+ * the record carries the new stamp while the counts on hand are still the
+ * sales since the old one — and the new count minus the OLD sales is too low,
+ * so a second press of the stepper in that moment saved a count short by
+ * every earlier sale. A count answered for another stamp than the record's
+ * own is read as nothing sold yet, until the re-ask (which the new stamp
+ * sets off at once) answers for the right one.
+ */
+export type AnsweredFor = Record<string, number>;
+/** The stamps a set of wants asks about — what their answer will be FOR. */
+export declare const answeredFor: (wants: StockWant[]) => AnsweredFor;
 export interface StockWant {
     record: string;
     variant: string;
@@ -32,6 +45,13 @@ export interface Stock {
     sold: (record: Stocked | null | undefined, variantId?: string) => number;
     /** When the counts were last read, in milliseconds — 0 before the first. */
     asOf: number;
+    /**
+     * The server stopped before it had read every sale (it reads a bounded
+     * number of pages): the counts are right for what was read, and the oldest
+     * sales since a count was set may be missing — so `left` may be HIGH. Be
+     * careful with the last few: say "only a few left" rather than a number.
+     */
+    partial: boolean;
 }
 /**
  * The counts to ask the server for: every record with a count and a stamp,
@@ -40,8 +60,8 @@ export interface Stock {
  */
 export declare function stockWants(records: Array<Stocked | null | undefined>): StockWant[];
 /** What is left, given the counts the server answered. Pure; the hook's `left` is this. */
-export declare function stockLeft(counts: SoldCounts, record: Stocked | null | undefined, variantId?: string): number | null;
-export declare function stockSold(counts: SoldCounts, record: Stocked | null | undefined, variantId?: string): number;
+export declare function stockLeft(counts: SoldCounts, record: Stocked | null | undefined, variantId?: string, answered?: AnsweredFor): number | null;
+export declare function stockSold(counts: SoldCounts, record: Stocked | null | undefined, variantId?: string, answered?: AnsweredFor): number;
 /**
  * The stamp. Called by the page templates on every save and every change,
  * with the record as it was: a count that is new, or that moved, is stamped
@@ -59,6 +79,7 @@ export declare const stockReads: {
 export declare function readSold(wants: StockWant[]): Promise<{
     sold: SoldCounts;
     error: string;
+    partial: boolean;
 }>;
 /**
  * What is left of each of these records — see the top of the file. Hand it

package/dist/lib/trouble.d.ts

@@ -9,7 +9,9 @@ export type TroubleKind = 'missingPart'
 /** The app stopped on purpose and said why, in its own words. */
  | 'said' | 'offline' | 'signedOut' | 'notAllowed' | 'unreachable' | 'slow' | 'busy' | 'gone' | 'noRoom' | 'notReady' | 'stopped' | 'tooBig'
 /** A picture on a page the AI wrote is drawn without <Picture>. */
- | 'drawnByHand' | 'unknown';
+ | 'drawnByHand'
+/** A file the AI wrote — the home page, the menu, a page — could not open. */
+ | 'ownFileBroken' | 'unknown';
 export interface Trouble {
     /** Which of the answers below this is. Never shown. */
     kind: TroubleKind;
@@ -84,6 +86,17 @@ export declare const deviceOffline: () => boolean;
 export declare const HAND_DRAWN_TITLE = "A picture here is drawn the slow way";
 export declare const HAND_DRAWN_SHORT = "A picture on this page is drawn by hand. Paste the message to your assistant.";
 export declare function pictureDrawnByHand(message: string): Error;
+/**
+ * A file the AI wrote that could not open: the home page, the menu, the
+ * page-content list or one page's own file (lib/ownFiles.ts). The app still
+ * stands — the starter home page, the standard menu, every other page — so
+ * this is not "that did not work" either. `short` is what the admin reads;
+ * the message is the repair to paste to the assistant, because the Pages
+ * screen's card reads files as they are written and cannot see one that
+ * only stops once it runs. Nothing to press will mend it, so `none`.
+ */
+export declare const OWN_FILE_TITLE = "Something your assistant wrote could not open";
+export declare function ownFileBroken(short: string, repair: string): Error;
 export declare function saidPlainly(message: string, next?: NextStep): Error;
 /**
  * Words this app wrote for a person to read.