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

package/dist/lib/ownFiles.d.ts

@@ -0,0 +1,116 @@
+export type OwnFileName = 'pages' | 'home' | 'menu';
+/**
+ * How it went wrong: the file never arrived (it would not load, or it came
+ * without the named export), or it arrived and then stopped while it was
+ * drawn. Only a home page is ever the second: a menu that throws is put
+ * aside like one that never came, and a page's own file is only ever loaded.
+ */
+export type OwnFileHow = 'missing' | 'threw';
+/** Where each of the three lives in the owner's project. */
+export declare const OWN_FILE_PATH: Record<OwnFileName, string>;
+/** One thing of the owner's that could not open, remembered for the notice. */
+export interface OwnFileFailure {
+    /** Remembered under this; the same fault said again is not news. */
+    key: string;
+    /** 'page' is one page's own file, found out by lib/contentFallback.ts. */
+    which: OwnFileName | 'page';
+    how: OwnFileHow;
+    /** Where the file is, for the sentence to the assistant. Never shown. */
+    file: string;
+    /** The page's own name, for a page's file ("Shop"). */
+    page?: string;
+    /** What the browser said, tidied for the assistant. */
+    words: string;
+}
+/**
+ * How long start-up waits for the page list before drawing anyway. A list
+ * that is merely slow still registers its pages when it lands, and a page
+ * drawn before then asks for its own file meanwhile; what this stops is an
+ * import that never answers holding the whole app for ever. Well inside the
+ * eight seconds after which the loader starts saying it is slow
+ * (lib/waiting.ts).
+ */
+export declare const PAGE_FILES_WAIT_MS = 5000;
+/** The console's line for each, followed by what the browser said. */
+export declare const OWN_FILE_CONSOLE: Record<OwnFileName, string>;
+/** The console's line for a home page that loaded and then stopped. */
+export declare const HOME_THREW_CONSOLE = "Your AI Firebase drew the home page (src/your-ai-workflow-firebase-os/Home.tsx) and it stopped part-way:";
+/** What an admin reads, one sentence each. Never a file name. */
+export declare const OWN_FILE_WORDS: Record<OwnFileName, string>;
+/** A home page that loaded and then stopped: the starter page is NOT showing. */
+export declare const HOME_THREW_WORDS = "Your home page stopped part-way while it was being drawn.";
+/** A page of theirs by its own name, as the Pages screen shows it. */
+export declare const pageWords: (page?: string) => string;
+export declare const OWN_FILE_NEXT = "Everything else still works. Copy the fix and paste it to your assistant.";
+/**
+ * Is this tab running the PUBLISHED app — its own scripts built files under
+ * /assets/ with their contents stamped into their names? The development
+ * server serves /src/main.tsx, and AI Studio its /index.tsx.
+ *
+ * A published app has no /src files at all, so a file of the owner's it
+ * could not fetch there is a page with no file, or a stale copy — never one
+ * that is there and broken (components/OwnFile.tsx, lib/contentFallback.ts).
+ */
+export declare const runningPublished: () => boolean;
+/**
+ * The browser's words as the assistant is handed them: the app's own
+ * address in front of a file, and the marks a development server adds to
+ * one (?t= on every save, ?v=, ?import), are left off — the sentence names
+ * the file already — and only the first line is kept. Any OTHER address
+ * stays: every one used to go, and React's "visit
+ * https://react.dev/errors/130" reached the assistant as "visit /errors/130".
+ */
+export declare const browserWords: (error: unknown) => string;
+/**
+ * One of the three did not load, or threw. Said in the console once a page
+ * load — both menus and every visit to the home page meet the same failure,
+ * and one line says it — and remembered for the admin's notice below.
+ */
+export declare function ownFileFailed(which: OwnFileName, error: unknown, how?: OwnFileHow): void;
+/**
+ * One page's own file is there and would not load (lib/contentFallback.ts,
+ * which has said so in the console already). By the page's name: "one of
+ * your pages" leaves the owner to find which.
+ */
+export declare function pageFileFailed(file: string, page: string | undefined, error: unknown): void;
+/**
+ * What the owner pastes to their assistant for one failure: the file, what
+ * the browser said, and a repair of that and nothing else.
+ */
+export declare const repairSentence: (failure: OwnFileFailure) => string;
+/** The repair for one page's own file, for the page itself to hand over (pages/DynamicPage.tsx). */
+export declare const pageRepairSentence: (file: string, page: string | undefined, error: unknown) => string;
+/**
+ * Start loading the page list. Called while the app is first drawn
+ * (FirebaseOS.tsx), and ONCE: a second call — a second draw, a list handed
+ * over again — changes nothing, so the pages are never held a second time
+ * after they have been drawn.
+ */
+export declare function loadPageFiles(load: (() => Promise<unknown>) | undefined, wait?: number): void;
+/** False only while the page list is on its way. True when there is none. */
+export declare function usePageFilesReady(): boolean;
+/**
+ * What the admin reads for whatever failed, one clause each, then the way on.
+ * A page named by its own file says more than "one of your pages", so the
+ * list's own words step aside once one is known.
+ */
+export declare const ownFilesSentence: (failures: OwnFileFailure[]) => string;
+/**
+ * The notice, as one fault in the app's own words (lib/trouble.ts): `short`
+ * is what the admin reads, `message` the repairs to paste, one to a line.
+ */
+export declare const ownFilesTrouble: (failures: OwnFileFailure[]) => Error;
+/** Nothing new to say this session: the notice was copied or closed. */
+export declare function putAwayOwnFiles(failures: OwnFileFailure[]): void;
+/**
+ * What to tell an admin: everything of theirs that could not open and has
+ * not been put away this session, in the order the notice says it.
+ *
+ * Only an admin: a visitor is shown the app's own home page or menu and has
+ * nothing to do about it. And whenever they arrive — the home page and the
+ * menu are drawn for somebody signed OUT, so an owner who looked at their
+ * site first and signed in after is told then.
+ */
+export declare function useOwnFilesNotice(isAdmin: boolean): OwnFileFailure[];
+/** Start again from nothing. Tests only; nothing in the app calls it. */
+export declare function forgetOwnFiles(): void;

package/dist/lib/ownerMail.d.ts

@@ -0,0 +1,37 @@
+export type OwnerMailWho = 'me' | 'admins';
+export interface OwnerMailState {
+    /** Her own address, as the server read it off her sign-in. */
+    me: string;
+    who: OwnerMailWho;
+    /** How many addresses her own mail reaches now. */
+    count: number;
+}
+/**
+ * Ask the server who owner mail reaches and store its sealed answer. `who` is
+ * passed only when the owner presses the choice; left out, the choice stays
+ * as it is and the list is brought up to date. Words when it did not work.
+ */
+export declare function refreshOwnerMail(who?: OwnerMailWho): Promise<{
+    state: OwnerMailState | null;
+    error: string | null;
+}>;
+/** The people who are admins now, as one string: it changes exactly when owner mail may have to. */
+export declare const adminsSignature: (people: Array<{
+    id: string;
+    role?: unknown;
+    email?: unknown;
+    inactive?: unknown;
+}>) => string;
+/**
+ * On the Users screen: when the admins change (somebody made one, taken off,
+ * switched off or deleted), owner mail is worked out again. Not on the first
+ * read of the list, which is only the screen opening; and only for an admin,
+ * the one person the server will answer. Email not connected yet is not a
+ * problem here: the Email tab works it out once it is.
+ */
+export declare function useOwnerMailKeptRight(people: Array<{
+    id: string;
+    role?: unknown;
+    email?: unknown;
+    inactive?: unknown;
+}>, isAdmin: boolean, loaded: boolean): void;

package/dist/lib/pageDesignLines.d.ts

@@ -1,7 +1,13 @@
 /** Every page and tab, whatever the theme: room to breathe, few icons, smooth motion (contract rule 27). */
 export declare const ROOM_AND_MOTION_LINE = "Whatever look I have chosen \u2014 bold or soft, playful or luxurious \u2014 make it modern and minimal, with room to breathe: generous space around and between everything, nothing crowded, squeezed together or packed edge to edge, so the screen always feels calm and uncluttered. Icons are rare: never one on every heading, button, card or list item. And bring it to life with smooth animation that suits my app, everywhere \u2014 the app\u2019s own ready-made animations wherever it has one, never one written by hand in its place: sections and items ease in as they come into view, one after another; buttons, cards and links respond softly to hover and press; and anything that opens, closes, changes step or updates glides rather than jumps. Keep every animation quick, gentle and subtle \u2014 never bouncy, never slow, never in the way of using the page \u2014 and keep it still for anybody whose device asks for less motion.";
-/** Website pages only: a picture not given yet is drawn as a placeholder, never a bare section — never a fact. */
-export declare const PLACEHOLDER_LINE = "Never leave an empty spot or a bare, bland section because I have not given you something yet. Where a section needs a picture I have not given you \u2014 or more pictures than I gave \u2014 draw a clean, neutral placeholder there: a soft tint of my theme in the shape the design wants there, with a simple line drawing of what belongs there in my theme\u2019s own colours, drawn in the code itself, so the section already looks designed. Keep each placeholder one plain frame with only the drawing inside it \u2014 any words about it go under the frame, never inside. When I give you a picture for a placeholder, it takes that placeholder\u2019s whole frame \u2014 same place, same size, same shape \u2014 and fills it corner to corner: the tint, the drawing and any padding inside the frame go, and the picture is never a smaller one sitting in the middle of it. The section never changes shape to suit the picture. A placeholder has no words on it, is never a photo from the internet and never a grey box with a picture icon in the middle, and it only ever stands in for a picture: products, prices, names and claims still come only from me.";
+/**
+ * Website pages only: a picture not given yet is drawn as a placeholder, never a bare section — never a fact.
+ * Nor one of the owner's pictures drawn again: her store home came back with a
+ * showcase piece reused as the large picture band (2026-09-27), because a spot
+ * that wanted a picture had one of hers to hand. Her word: a spot she gave no
+ * picture for is a placeholder unless she says which picture goes there.
+ */
+export declare const PLACEHOLDER_LINE = "Never leave an empty spot or a bare, bland section because I have not given you something yet. Where a section needs a picture I have not given you \u2014 or more pictures than I gave \u2014 draw a clean, neutral placeholder there: a soft tint of my theme in the shape the design wants there, with a simple line drawing of what belongs there in my theme\u2019s own colours, drawn in the code itself, so the section already looks designed. And never one of my pictures a second time to fill it: each picture I gave you is drawn ONCE, in its own spot, and every other spot that wants a picture \u2014 a band, a background, a second hero \u2014 gets a placeholder, unless my words name the picture that goes there. Keep each placeholder one plain frame with only the drawing inside it \u2014 any words about it go under the frame, never inside. When I give you a picture for a placeholder, it takes that placeholder\u2019s whole frame \u2014 same place, same size, same shape \u2014 and fills it corner to corner: the tint, the drawing and any padding inside the frame go, and the picture is never a smaller one sitting in the middle of it. The section never changes shape to suit the picture. A placeholder has no words on it, is never a photo from the internet and never a grey box with a picture icon in the middle, and it only ever stands in for a picture: products, prices, names and claims still come only from me.";
 /**
  * Easy to use — contract rule 32.
  *
@@ -137,6 +143,8 @@ export declare const CHANGE_KEEP_LINE = "This is a change to a page that is alre
  * nobody asked for is REPORTED, not done.
  */
 export declare const CHANGE_CLOSE_LINE = "One last time, because it is what goes wrong most: that is the whole change \u2014 all of it, taken as far as my words reach, and nothing outside them. Everything else in the file comes back exactly as it went in \u2014 every other section, its words, every picture with its link, the same order, the same sizes, the same styling and spacing. Nothing else rewritten, nothing re-ordered, nothing removed to make room for what is new, nothing tidied up along the way. If something else looks wrong to you, leave it as it is and tell me about it in a line at the end instead of changing it. And what you add still follows every rule of my app, as the first build did: wherever the app has its own piece for the job, use it \u2014 never one you made yourself in its place.";
+/** The same line in a sentence that builds a page: the sections it names arrive named, and designed. */
+export declare const NAMED_SECTION_LINE = "A section I ask for arrives with my own word for it as its heading \u2014 \u201CCollection section \u2014 \u2026\u201D or \u201Cadd a collection section\u201D is a section headed Collection, in the style of the page\u2019s other headings. That word is mine: not an invention of yours, and not an extra nobody asked for. And design it the way the rest of the page was designed \u2014 its own shape, its own rhythm, real space round it, and motion like everything else. If it is a set of my pictures, arrange them: vary how much room each one takes, let one carry the weight, break or offset the row, and let a picture somebody can press answer the pointer \u2014 never three equal tiles side by side. Each picture still keeps its own shape and fills its own frame.";
 /** What a change carries in place of the whole design brief: the new part follows the page it joins. */
 export declare const changeNewWorkLine: (website: boolean) => string;
 /** Rides with pictures added to a built website page: the picture fills the placeholder's whole frame, never sits inside it. */

package/dist/lib/paidInFull.d.ts

@@ -0,0 +1,37 @@
+/** A payment as far as this is concerned: which kind, what the server asked for, and what Stripe charged. */
+export interface AskedPayment {
+    kind: 'charge' | 'subscription';
+    asked?: string | null;
+    /** What Stripe charged, in the currency's main unit (240, not 24000). */
+    amount?: number | null;
+    currency?: string | null;
+    /** What the page and the server put on the payment: among it, the lines a checked basket was charged for. */
+    collected?: Record<string, string> | null;
+}
+type Others = Array<Record<string, any> | null | undefined>;
+/**
+ * Whether this payment may stand as the payment for this entry. Any entry
+ * that is not an order is let in as before. An order is never paid for by a
+ * subscription. Otherwise what the server asked for has to cover it, or what
+ * Stripe charged — with `alongside`, the other entries the same payment
+ * names, covered too — and where the payment carries the lines it was
+ * charged for, they are the order's lines. A payment from before the server
+ * said what it asked, that Stripe charged less than the order (a promotion
+ * code, or a request written by hand: nobody can tell which), does not
+ * count. Pure, tested.
+ */
+export declare function paidInFull(entry: Record<string, any> | null | undefined, sale: AskedPayment, alongside?: Others): boolean;
+/**
+ * Whether a payment is KNOWN to have asked for less than its order says —
+ * what the Transactions screen warns of. A payment from before the server
+ * said what it asked is not called short: nobody can tell. Nor is one whose
+ * order's currency is not known yet. Pure, tested.
+ */
+export declare function paidShort(entry: Record<string, any> | null | undefined, sale: AskedPayment, alongside?: Others): boolean;
+/**
+ * Whether a payment is KNOWN to have been charged for other things than its
+ * order says — the Transactions screen warns of it beside "Paid less". Only
+ * a payment that carries its lines can say. Pure, tested.
+ */
+export declare function paidForOther(entry: Record<string, any> | null | undefined, sale: AskedPayment, alongside?: Others): boolean;
+export {};

package/dist/lib/paidSessions.d.ts

@@ -0,0 +1,38 @@
+import { Booking } from './scheduleData';
+import { CheckoutAnswer } from './bookingState';
+/** Only for tests — forget every answer kept for the visit. */
+export declare function resetPaidSessions(): void;
+/**
+ * How often a pass the rules refused is tried again while the screen is
+ * open. The usual refusal is the key an admin's visit puts in (admin_keys/
+ * plans) not being there yet; the admin's own visit writes it a moment later.
+ */
+export declare const PASS_RETRY_MS: number;
+/**
+ * Whether each booking on screen is paid for, by booking id — answered by the
+ * SERVER, since the browser's own word for "paid" is never enough.
+ *
+ * Paid for THIS booking, not merely "a paid session". Anyone may make a
+ * booking, and the session id on it is whatever its writer put there: one
+ * carrying another booking's paid session used to read Paid. A session counts
+ * only for the bookings the checkout was made for — every leg it names, or
+ * the one `bookingId` of an older checkout, matched against the booking and
+ * the copies of its meeting (hand this the party-merged list, so `copyIds`
+ * is filled).
+ *
+ * Each ask is a Stripe lookup on the server. The calendar holds every
+ * booking ever made, so this used to fire one lookup per paid booking at the
+ * same instant on every open (past Stripe's rate limit on a busy calendar,
+ * so paid bookings came back unpaid), and a snapshot landing mid-way threw
+ * every answer away and fired the whole batch again. Now each session is
+ * asked once per visit, a few at a time, and an answer is kept whatever
+ * arrives meanwhile.
+ *
+ * A pass the rules refuse is never forgotten: it is kept and written again on
+ * the next change to the bookings and every PASS_RETRY_MS, and the session is
+ * remembered as settled only once every pass is on.
+ */
+export declare function usePaidSessions(bookings: Booking[]): {
+    paid: Record<string, boolean>;
+    checkouts: Record<string, CheckoutAnswer>;
+};

package/dist/lib/paymentProducts.d.ts

@@ -79,10 +79,6 @@ export interface PaymentProduct {
      * or more separate answers reads back with them folded into this one.
      */
     how: string;
-    /** The button's metadata flags — both default ON: every payment confirms
-        itself to the buyer and announces itself to the owner unless turned off. */
-    emailReceipt: boolean;
-    notifyOwner: boolean;
     /**
      * WHERE this payment goes: the pages it is on, as document ids (or a
      * shipped page's id). Ticked from each page's own Payments section on the
@@ -187,6 +183,18 @@ export declare function productSummary(p: PaymentProduct): string;
 export declare function stripePlanSteps(product: PaymentProduct, plan: ProductPlan, live?: boolean): string[];
 /** A value said inside a button tag, quoted around any apostrophe it holds. */
 export declare const buttonAttr: (v: string) => string;
+/**
+ * The owner's currency on a price piece a sentence names — ` currency='gbp'`,
+ * the Stripe account's own (lib/accountCurrency) — or nothing while that is
+ * not known. Contract rule 31 has every price a page SHOWS written in the
+ * currency it passes to its <Basket> or <BuyButton>, so naming it here keeps
+ * the money() beside the button on the same one. Never 'usd' by default: the
+ * basket sentence said currency='usd' on every page, and an owner who priced
+ * in pounds showed "$18" and was charged in dollars (the Lotus Yoga
+ * rehearsal, 2026-09-26). Said with nothing known, the pieces and money()
+ * fall back to the account's currency themselves.
+ */
+export declare const currencyProp: (code?: string | null) => string;
 /** The one rule every money sentence carries, word for word, wherever it is built. */
 export declare const PAYBUTTON_RULE = "Every payment goes through the app's own pieces \u2014 a <BuyButton> for one thing bought, a <Basket> for a basket of them \u2014 never a checkout, a card form or Stripe code of your own. The button's words, colour and place on the page are yours to design.";
 /**
@@ -208,8 +216,12 @@ export declare const productLines: (product: PaymentProduct, live?: boolean) =>
  * asked for the name and the address twice: once by <BuyerDetails address>,
  * and once by a delivery step the assistant drew beside it, because the
  * address rule still named "a checkout" as the place for <AddressField>.
+ *
+ * "No form" is about who is PAYING, and says so. Said bare — "never a form,
+ * never a *Form.config.ts" — it sat under a line creating the page's own
+ * form, and a page may have both: an enquiry form and a Buy button.
  */
-export declare const BUYER_ANSWERS_RULE = "Who is paying is asked by the button ITSELF: the press of a <BuyButton> from 'your-ai-workflow-firebase-os' opens one small window that says what is being bought, asks who is paying and goes straight on to Stripe. So NEVER a <BuyerDetails> and a <PayButton> put together by you, never a form, never a *Form.config.ts, never a name, email, phone or <AddressField> box of your own, and no delivery step of your own: that asks the buyer twice. It asks a buyer who is not signed in for their name and email, and for a phone number or the address when you pass phone / address on the button (true to require it, 'optional' to offer it \u2014 pass them when my words ask for them, and address whenever something is delivered), and makes them an account there and then, signed in on this device; a signed-in buyer is asked only for what is missing, and one the app already knows sees one line saying who is paying and the button. Who they are rides onto the payment by itself and reads beside it on my Transactions screen. Anything else my words ask before paying \u2014 a note, a chosen session, a size \u2014 is a box or a choice of your own on the page (it is not a form: nothing is sent anywhere) whose answer goes into the button's metadata as a plain string, and disabled on the button holds it back until it is chosen. Never ask for their email twice, and never build a backend of your own for it: the app tells them and me in the bell when the payment happens.";
+export declare const BUYER_ANSWERS_RULE = "Who is paying is asked by the button ITSELF: the press of a <BuyButton> from 'your-ai-workflow-firebase-os' opens one small window that says what is being bought, asks who is paying and goes straight on to Stripe. So NEVER a <BuyerDetails> and a <PayButton> put together by you, never a form or a *Form.config.ts to ask who is paying, never a name, email, phone or <AddressField> box of your own, and no delivery step of your own: that asks the buyer twice. It asks a buyer who is not signed in for their name and email, and for a phone number or the address when you pass phone / address on the button (true to require it, 'optional' to offer it \u2014 pass them when my words ask for them, and address whenever something is delivered), and makes them an account there and then, signed in on this device; a signed-in buyer is asked only for what is missing, and one the app already knows sees one line saying who is paying and the button. Who they are rides onto the payment by itself and reads beside it on my Transactions screen. Anything else my words ask before paying \u2014 a note, a chosen session, a size \u2014 is a box or a choice of your own on the page (it is not a form: nothing is sent anywhere) whose answer goes into the button's metadata as a plain string, and disabled on the button holds it back until it is chosen. Never ask for their email twice, and never build a backend of your own for it: the app tells them and me in the bell when the payment happens.";
 /**
  * What the money was FOR rides on the payment too. The Transactions screen
  * reads the button's metadata, and a row that says only "Store Order — £240"
@@ -250,7 +262,7 @@ export declare const PLAN_SIGN_IN_RULE = "This plan gives its buyer a role, and
 /**
  * `productLines` plus how the owner wants the payment to WORK — their one
  * answer, start to finish — the buyer-answers rule, the gating rule for a
- * subscription, where the buyer lands after paying, and the email flags.
+ * subscription, and where the buyer lands after paying.
  */
 export declare function productSellingLines(product: PaymentProduct, address?: string, live?: boolean): string[];
 /**
@@ -259,15 +271,16 @@ export declare function productSellingLines(product: PaymentProduct, address?: s
  * another device is the emailed link or Reset password. The app's own bell
  * says "Order placed" to them and "New payment" to the owner by itself.
  */
-export declare const AFTER_PAYING_RULE = "What happens when they come back from paying is my app's own as well: write <CheckoutReturn /> from the same package ONCE near the top of the page, outside any window or step. It asks the server whether the money really moved and only then thanks them; give it orderPath='/billing' \u2014 the app's own page where what they bought is \u2014 unless my words name another page of mine they go to afterwards, and then that page's address. Never read session_id off the web address, never call confirmPayment, and never build a thank-you, an order confirmation, a receipt or a notification of your own: the bell tells them their order is placed and tells me a payment came in. Never send them to /login or /register after paying, and never make anybody sign in BEFORE they pay: somebody whose email already has an account pays as a guest and is emailed their way in afterwards.";
+export declare const AFTER_PAYING_RULE = "What happens when they come back from paying is my app's own as well: write <CheckoutReturn /> from the same package ONCE near the top of the page, outside any window or step. It asks the server whether the money really moved and only then thanks them; give it orderPath='/billing' \u2014 the app's own page where what they bought is \u2014 unless my words name another page of mine they go to afterwards, and then that page's address. Never read session_id off the web address, never call confirmPayment, and never build a thank-you, an order confirmation, a receipt or a notification of your own: my app emails the buyer their receipt and me my sale alert by itself, and the bell tells them their order is placed and tells me a payment came in \u2014 so nothing about email goes in the button's metadata. Never send them to /login or /register after paying, and never make anybody sign in BEFORE they pay: somebody whose email already has an account pays as a guest and is emailed their way in afterwards.";
 /**
- * Where the buyer lands, and the two emails the button's metadata switches
- * on — the same words for a product and for a page's dynamic payment.
+ * Where the buyer lands, and what happens then — the same words for a
+ * product and for a page's dynamic payment. The receipt and the sale alert
+ * are not in them: the Email screen's switches decide those at the moment
+ * of sale, so a page puts nothing in metadata for them (until 2.0.8 each
+ * payment wrote its own flags into the page, and flipping one changed
+ * nothing on pages already built).
  */
-export declare function afterPaymentLines(address: string, flags: {
-    emailReceipt: boolean;
-    notifyOwner: boolean;
-}): string[];
+export declare function afterPaymentLines(address: string): string[];
 /**
  * A page row as the Pages screen's shared lookups read it — the link targets
  * a page can point at, and the pages a payment is attached to.

package/dist/lib/payments.d.ts

@@ -23,6 +23,7 @@ export interface CheckoutOptions {
         record?: string;
         variant?: string;
         options?: string;
+        collection?: string;
     }[];
     extras?: {
         label: string;
@@ -79,8 +80,17 @@ export interface SaleCharge extends MyPayment {
      * buyer gave before paying, and the id of the form entry an order went
      * back through (whatever key the page chose for it). A team page that
      * takes stock only once an order is PAID looks for its entry ids here.
+     * From a checked basket it also holds the lines the server charged
+     * (`sold`, lib/soldLines.ts), which the order has to match to arrive.
      */
     collected?: Record<string, string>;
+    /**
+     * What the server asked Stripe for — "240 eur", before any promotion code
+     * the buyer typed — in the server's own words, which no page can write
+     * (server/prices.ts ASKED_KEY). What an order is checked against before
+     * it arrives as paid; null on a payment made before it was written.
+     */
+    asked?: string | null;
     /** "Visa ending 4242", or the method's own name. */
     paidWith?: string | null;
     /** Where it is going, when Stripe collected that; else where the card lives. */
@@ -102,9 +112,29 @@ export interface PaymentConfirmation {
     amountTotal: number | null;
     currency: string | null;
     customerEmail: string | null;
+    /**
+     * The buyer's receipt WENT to `customerEmail`: the server sent it, now or
+     * before. The only thing "A receipt is on its way" is ever said off: an
+     * address, the page's metadata or the Email tab's switch promise nothing,
+     * because the mail may still be refused or never reach a buyer at all.
+     */
+    receipt?: boolean;
+    /**
+     * The payment is still clearing (stillClearing) and its receipt will be
+     * emailed once it arrives: said only where a webhook will hear that.
+     */
+    receiptLater?: boolean;
     metadata: Record<string, string>;
     /** Set when the server could not be asked — paid stays false. */
     error: string | null;
+    /** Stripe's own word for the checkout: 'open', 'complete' or 'expired' — null when not asked. */
+    status?: string | null;
+    /**
+     * A booking's checkout, once complete: the server's pass for each hold it
+     * paid for, by booking id — written on with markHolds(…, 'paid') so the
+     * time is kept for good. Empty for anything else.
+     */
+    holdPasses?: Record<string, string>;
 }
 /**
  * Only for tests — jsdom cannot navigate, so the one real page load in this
@@ -143,9 +173,9 @@ export declare const webhookEndpointUrl: (publishedBase: string) => string;
 export declare function startCheckout(options: CheckoutOptions): Promise<string | null>;
 /**
  * The checkout session alone — its id and the address to send the payer to —
- * for a page that has something to write down BEFORE leaving for Stripe: a
- * booking keeps the session that pays for it, so the team's calendar can ask
- * the server whether it was paid. Resolves to the session, or to words.
+ * for a page that has something to write down BEFORE leaving for Stripe.
+ * (A booking has its own, priced by the server: createBookingCheckout.)
+ * Resolves to the session, or to words.
  */
 export declare function createCheckout(options: CheckoutOptions): Promise<{
     sessionId: string;
@@ -157,6 +187,13 @@ export declare function createCheckout(options: CheckoutOptions): Promise<{
  * begins, or to a message the page can show.
  */
 export declare function openBillingPortal(): Promise<string | null>;
+/**
+ * A payment that went through Stripe's checkout but whose money has not
+ * arrived yet: a bank debit, which settles days later. Neither paid nor
+ * failed. Called a failure, it kept the basket and the buyer paid twice; the
+ * buyer is told it is on its way.
+ */
+export declare const stillClearing: (confirmation: Pick<PaymentConfirmation, "paid" | "error" | "status" | "paymentStatus">) => boolean;
 /**
  * Ask the server whether a checkout session was actually paid.
  *
@@ -175,8 +212,11 @@ options?: {
     quiet?: boolean;
 }): Promise<PaymentConfirmation>;
 export interface PaymentsStatus {
+    /** Stripe is in AND the Take payments switch is on — what a Pay button gates on. */
     configured: boolean;
     mode: 'live' | 'test' | null;
+    /** Stripe is in, switched on or not — how the Pages screen tells "switched off" from "not set up". */
+    connected?: boolean;
 }
 /** How often a watching screen asks again while the key is still not in. */
 export declare const STATUS_WATCH_MS = 5000;
@@ -205,6 +245,7 @@ export declare function usePaymentsEnabled(watch?: boolean): {
     loading: boolean;
     configured: boolean;
     mode: 'live' | 'test' | null;
+    connected?: boolean;
 };
 export interface MyPaymentsState {
     loading: boolean;
@@ -246,12 +287,6 @@ export declare function useHasBought(uid: string | null | undefined): {
     loading: boolean;
     bought: boolean;
 };
-/**
- * What the signed-in person has bought, read live from Stripe. Signed out is
- * an ordinary answer — `active: false` with empty lists — never a throw.
- * Read afresh on every mount: this is the Billing page's own list, and a
- * refund or a cancellation made in Stripe reads here the moment it is made.
- */
 export declare function useMyPayments(): MyPaymentsState;
 export interface SalesState {
     loading: boolean;
@@ -271,3 +306,38 @@ export interface SalesState {
  * reads Stripe itself, not a copy.
  */
 export declare function useSales(): SalesState;
+/** One person's part of the meeting being paid for: the hold, and the link it was taken on. */
+export interface BookingCheckoutLeg {
+    bookingId: string;
+    scheduleId: string;
+}
+export interface BookingCheckoutOptions {
+    legs: BookingCheckoutLeg[];
+    /** The booked time in words, for the receipt: "Tue 3 Oct, 10:00 (London) with Anna". */
+    when: string;
+    name?: string;
+    email?: string;
+    /** Where the payer lands after paying — the checkout's id is added to it. */
+    successPath: string;
+    /** Where the payer lands on pressing Back on Stripe's page. */
+    cancelPath: string;
+}
+/** The checkout for a held time: its id, where to send the payer, and what it charges. Or words. */
+export declare function createBookingCheckout(options: BookingCheckoutOptions): Promise<{
+    sessionId: string;
+    url: string;
+    amount: number;
+} | string>;
+/** What the server says has become of a paid hold — with its pass, when there is one to write on. */
+export type HoldAnswer = {
+    state: 'gone' | 'kept' | 'open';
+} | {
+    state: 'paid' | 'free';
+    pass: string;
+};
+/**
+ * Ask what has become of a paid hold. With the checkout the payer just came
+ * back from unpaid, that checkout is closed first, so the answer is 'free'.
+ * Resolves to the answer, or to words when the server could not be asked.
+ */
+export declare function checkBookingHold(bookingId: string, sessionId?: string): Promise<HoldAnswer | string>;

package/dist/lib/pictureLine.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The order pictures arrive in: the way a page is read, never the order the
+ * bytes happened to come back in.
+ *
+ * A gallery of twelve pictures asks for all twelve at once, and the bucket
+ * answers them in whatever order it likes — from here every Firebase Storage
+ * file takes anywhere from one to two and a half seconds to start. Measured on
+ * a grid of twelve (2026-09-26), half of every pair of pictures came in the
+ * wrong way round: the third, then the ninth, then the first. That is what the
+ * owner saw as loading that is "random" rather than "consequential".
+ *
+ * So a picture arriving into an EMPTY box on screen takes its place in a line
+ * and is shown when its turn comes: top row first, left to right along each
+ * row, one after the next with a short step between them, so a screen of
+ * pictures fills in as a sweep rather than a scatter.
+ *
+ * Three things keep the line from ever being the reason a page is slow:
+ *
+ * - A picture that has landed waits at most LINE_HOLD_MS for the ones before
+ *   it. A slow one is then passed over and shows whenever it lands, so one
+ *   bad file cannot hold a whole gallery back.
+ * - A screen of pictures that are all in at once (they were in the browser
+ *   already) sweeps in within LINE_BUDGET_MS however many there are — the
+ *   step between them shortens, down to a frame each.
+ * - Only what is ON SCREEN takes part. A picture below the fold, or hidden,
+ *   is shown the moment it lands, because nobody is watching its order, and
+ *   it never holds up one that is being looked at.
+ * - Nor does anything small: a face beside a name, a thumbnail on a row.
+ *   The line is for pictures that are LOOKED AT, and a slow face must never
+ *   hold up the gallery beside it. The logo and a page's opening picture are
+ *   `priority`, and do not queue at all (Picture.tsx).
+ *
+ * Only a first arrival queues. A picture changing to another (a colour
+ * swatch) or sharpening into a bigger file already has something on screen
+ * and crosses over at once; a picture this tab has already drawn is drawn
+ * straight away. See components/media/Picture.tsx.
+ */
+/** Between one picture appearing and the next, when they are all waiting. */
+export declare const LINE_STEP_MS = 50;
+/** A whole screen of pictures that are all in sweeps in within this. */
+export declare const LINE_BUDGET_MS = 400;
+/** The longest a picture that has landed waits for the ones before it. */
+export declare const LINE_HOLD_MS = 700;
+export interface LineTicket {
+    /** This picture has something it can show. */
+    landed(): void;
+    /** It no longer needs a turn — gone from the page, or failed. */
+    leave(): void;
+}
+/**
+ * Take a place in the line for a picture about to arrive in `el`.
+ * `show` is called once, when it is this picture's turn to be seen.
+ */
+export declare function joinLine(el: Element, showIt: () => void): LineTicket;
+/** Everything forgotten — for tests, which must not leak a turn between them. */
+export declare function forgetLine(): void;

package/dist/lib/planRoles.d.ts

@@ -58,7 +58,11 @@ export declare function syncPlanRole(uid: string, known?: Record<string, any> |
  * buyer from then on failed the rules' check, and nobody who paid after
  * going live got their role until an admin happened to reopen Payments.
  */
-export declare function usePlanKeySync(mode?: unknown): void;
+export declare function usePlanKeySync(mode?: unknown): {
+    ready: boolean;
+};
+/** The longest a screen waits on the key before drawing what it has. */
+export declare const KEY_SYNC_WAIT_MS = 5000;
 /** Role id → the names of the plans that give it. Pure. */
 export declare function plansByRole(products: PaymentProduct[]): Record<string, string[]>;
 /** Which plans give each role, live — role id → plan names. */

package/dist/lib/plans.d.ts

@@ -28,7 +28,9 @@ export interface PlanOnOffer {
 }
 /**
  * An amount as the page says it. The owner's own symbol wins — "£25" is
- * pounds whatever the page thinks — and a bare "25" is said in `currency`.
+ * pounds whatever the page thinks — and a bare "25" is said in `currency`,
+ * which is the owner's own Stripe currency when the page names none. A plan
+ * is charged by its Stripe price, so only these words were ever in dollars.
  * Pure, tested.
  */
 export declare function amountFigure(raw: string, currency?: string): string;
@@ -52,8 +54,14 @@ export interface PlansState {
     plans: PlanOnOffer[];
     /** Whether any plan of this product is the visitor's already. */
     subscribed: boolean;
-    /** For each button's `metadata` — the emails the owner left switched on. */
+    /** For each button's `metadata`: nothing about email, which the Email screen decides. */
     metadata: Record<string, string>;
+    /**
+     * Whether this person already has a plan could not be found out (the read
+     * of their payments failed). `subscribed` is false then only because nothing
+     * is known, so a Choose button would risk a second subscription.
+     */
+    unsure: boolean;
 }
 /**
  * The plans of ONE subscription the owner described — `productId` is the id

package/dist/lib/publicCopy.d.ts

@@ -25,11 +25,25 @@ export declare const LINGER_MS = 20000;
  * one that did would otherwise be written again on every answer, for ever) is
  * sent once and then left.
  */
-export declare function matchPublicCopy(to: string, records: Held, copies: Held, leaveOut: string[], written?: Map<string, string>): Promise<number>;
+export declare function matchPublicCopy(to: string, records: Held, copies: Held, leaveOut: string[], written?: Map<string, string>, from?: string): Promise<number>;
 /** Say this collection is being copied; the answer takes it back out again. */
 export declare function declarePublicCopy(from: string, leaveOut: string[]): () => void;
 /** What a declared copy leaves out — null when this collection takes no copy at all. */
 export declare const copyLeavesOut: (from: string) => string[] | null;
+/**
+ * The field a copy carries saying which private collection it is a copy of.
+ *
+ * It is what keeps the copy the team's. Every `pub_` document is writable by
+ * anybody signed in — that is what lets members post on a public board — and
+ * for a while that included the copies too: any registered account could
+ * rewrite a product's price or delete the whole shop. The pasted rules now
+ * read this mark, and a document carrying it may only be written by whoever
+ * may write the original (the team for mem_ and admin_, that role for
+ * role_<id>_). A copy written before the mark existed picks it up the next
+ * time the page that owns it is open: the shape differs, so it is written
+ * again, once.
+ */
+export declare const COPY_OF = "copyOf";
 /**
  * Put one record in the public copy now, as it is saved.
  *

package/dist/lib/recordArgs.d.ts

@@ -34,3 +34,15 @@ export declare function idPassed(first: unknown, second?: unknown): string;
 export declare function recordsFromDocs<T = Record<string, any>>(docs: any[]): T[];
 /** What the page asked to write, minus the `id` that is the document's to say. */
 export declare function withoutStaleId(data: Record<string, any>): Record<string, any>;
+/**
+ * The document id a record COPIED IN from somewhere else is written under —
+ * an Inbox entry mirrored onto a leads page carries the entry's id as
+ * `sourceId` — or null for an ordinary record, which gets a fresh id.
+ *
+ * One id per source is what makes the copy happen once. The contract's
+ * mirror used to skip an entry when `actions.records` already held its copy,
+ * but that list is the newest 150: past 150 every older entry looked new and
+ * was copied again on every change, and two open tabs copied each new entry
+ * twice. Written under this id, a second save finds the first and stops.
+ */
+export declare function mirroredId(record: Record<string, any> | null | undefined): string | null;