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

package/dist/pages/Inbox.d.ts

@@ -37,6 +37,10 @@ export interface InboxItem {
  * is one line per item; an object is its facts side by side.
  */
 export declare const sayValue: (val: any) => string;
+/** How many of each collection's newest messages are read at a time. */
+export declare const INBOX_PAGE = 100;
+/** Said where the open message would be, when a link named one that is no longer there. */
+export declare const GONE_WORDS = "That message is gone.";
 /** Rows are keyed by collection + id, because the two collections can hand out the same document id. */
 export declare const rowKey: (item: InboxItem) => string;
 /**
@@ -78,7 +82,25 @@ export interface InboxView {
     formLook: (formId: unknown) => FormLook;
     /** The message to start on — the preview's, so the open shape can be looked at without a click. */
     initialOpen?: string | null;
+    /** There are older messages than `items` holds; `onShowMore` reads further back. */
+    more?: boolean;
+    loadingMore?: boolean;
+    onShowMore?: () => void;
+    /**
+     * A link named a message the list does not hold: `onFind` looks it up,
+     * once, and `found` says what came of that — still on its way, or gone,
+     * with the words to say so. Never a reason to read on page by page.
+     */
+    onFind?: (key: string) => void;
+    found?: FoundLink | null;
 }
-export declare function InboxScreen({ items, loading, refused, onArchive, onDelete, opensUsers, formLook: lookOf, initialOpen }: InboxView): import("react/jsx-runtime").JSX.Element;
+/** What looking up a linked message came to. */
+export interface FoundLink {
+    key: string;
+    gone: boolean;
+    /** Said in the reading pane when it is gone. */
+    words?: string;
+}
+export declare function InboxScreen({ items, loading, refused, onArchive, onDelete, opensUsers, formLook: lookOf, initialOpen, more, loadingMore, onShowMore, onFind, found, }: InboxView): import("react/jsx-runtime").JSX.Element;
 export declare function Inbox(): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/pages/PagesAdmin.d.ts

@@ -1,16 +1,28 @@
 import { ArrivalRoad } from '../lib/arrivalRoads';
+import { Readiness } from '../components/NeedsService';
 import { MediaFacts } from '../lib/mediaFacts';
 import { PageSpace, RoleGroup, PageType } from '../lib/access';
 import { CustomRole } from '../lib/roles';
-import { DeleteBy } from '../lib/recordLock';
+import { DeleteBy, HandOnBy } from '../lib/recordLock';
 import { PageLink, PaymentProduct, WiringPageRow } from '../lib/paymentProducts';
 import { CustomPayment } from '../lib/customPayments';
 import { EmailLook } from '../lib/email';
 import { PageBooking } from '../lib/schedule';
 import { pascalCase } from '../lib/pascalCase';
+export declare const setEmailReadiness: (r: Readiness) => void;
+/** On, or not set up — all a test or an older caller knows to say. */
 export declare const setEmailEnabled: (on: boolean) => void;
+export declare const emailReadiness: () => Readiness;
+/**
+ * Connected and on. 'practice' counts: mail reaches the owner already, and
+ * what a page is told to build is the same either way — the server holds
+ * what is for a customer until her domain is verified, and the row greys
+ * those switches (NeedsService audience="customer").
+ */
 export declare const emailEnabled: () => boolean;
+export declare const setPaymentsReadiness: (r: Readiness) => void;
 export declare const setPaymentsEnabled: (on: boolean) => void;
+export declare const paymentsReadiness: () => Readiness;
 export declare const paymentsEnabled: () => boolean;
 interface PageItem {
     id: string;
@@ -198,13 +210,22 @@ export declare const CAN_DO_PUT_UP_NOTIFY_EXAMPLES: Record<CanDoKey, string>;
  * Which set of examples this page's boxes carry — one place, three answers,
  * and each with its notification sentence on the end when the row said yes.
  */
-export declare const canDoExamples: (space: PageSpace, notifications?: boolean) => Record<CanDoKey, string>;
+/**
+ * With "Also send them by email?" on, one email of the owner's own in each
+ * example — her own emails are written in the boxes she already has, the
+ * way she said them ("email the user when they need to renew the
+ * contract"), and each is rung AND emailed through notify().
+ */
+export declare const CAN_DO_EMAIL_EXAMPLES: Record<CanDoKey, string>;
+export declare const canDoExamples: (space: PageSpace, notifications?: boolean, email?: boolean) => Record<CanDoKey, string>;
 /** The ONE group on a page that has no boxes — '' when there are boxes, or nobody is ticked yet. */
 export declare const notifyGroup: (config: any) => string;
 /** "What notifications will your team see?" — the group by the word the owner reads on the row. */
 export declare const notifyWishLabel: (config: any, roles?: CustomRole[]) => string;
 /** That box's placeholder — and a reminder that the owner can be one of the people told. */
 export declare const NOTIFY_WISH_EXAMPLES: Record<CanDoKey, string>;
+/** The one group's example, with one email of hers in it once email is on too. */
+export declare const notifyWishExample: (key: CanDoKey, email?: boolean) => string;
 /** The words in that box, trimmed — '' when the answer is no, or the groups' own boxes carry it. */
 export declare const notifyWishOf: (config: any) => string;
 /** The line under the question, which moves with the answer. */
@@ -271,14 +292,24 @@ export declare const deleteLockLines: (config: any) => string[];
  */
 export declare const notifyDefault: (config: any) => string;
 /**
- * How a notification is emailed as well — the two calls that can carry it,
- * and who each reaches. There is no third: emailPerson's one template says
- * "we got your message", which is not news of a job moving on, and a
- * member's page can mail nobody on the team but the admins.
+ * How a notification is emailed as well: one word on the call. The app
+ * finds the address and picks the road — the owner's own mail for her and
+ * her admins, the team's for anybody else, the bell alone from anybody who
+ * is not on the team (lib/notify.ts). It used to be two email calls beside
+ * each notify(), one of which led the assistant to read user_profiles for an
+ * address, which the build refuses; the page never handles an address now.
+ * Her own emails in her own words ("email them a month before their
+ * contract ends") are notifications too, and a dated one follows rule 33.
  */
-export declare const NOTIFY_EMAIL_HOW = "Each notification also goes out as an email, at the same moment and in the same words, with the app\u2019s own email calls and never email code of your own. To me and my admins: emailOwner('heads_up', { title, summary: body }), which anybody may send. To anybody else, only when the person it comes from is on my team or an admin: emailAnyone(address, title, body, { look: 'notification' }), to the address the record or their profile already holds for them \u2014 never one typed in for it. Where neither reaches somebody, the notification alone is enough.";
-export declare const NOTIFY_EMAIL_NOW_LINE = "The notifications this page already sends go out by email as well now. Each notification also goes out as an email, at the same moment and in the same words, with the app\u2019s own email calls and never email code of your own. To me and my admins: emailOwner('heads_up', { title, summary: body }), which anybody may send. To anybody else, only when the person it comes from is on my team or an admin: emailAnyone(address, title, body, { look: 'notification' }), to the address the record or their profile already holds for them \u2014 never one typed in for it. Where neither reaches somebody, the notification alone is enough.";
-export declare const NOTIFY_EMAIL_OFF_LINE = "Stop emailing this page\u2019s notifications: remove the email calls that go out beside them, and keep the notifications themselves.";
+export declare const NOTIFY_EMAIL_HOW = "Pass email: true to every notify() on this page, so each one is emailed as well, in the same words \u2014 my app finds the address itself, so never read one or write email code for it. Where my words say to EMAIL somebody, that is one of these notifications too; one that depends on a date follows my app\u2019s rule 33.";
+export declare const NOTIFY_EMAIL_NOW_LINE = "The notifications this page already sends go out by email as well now: add email: true to every notify() it makes, and change nothing else. Pass email: true to every notify() on this page, so each one is emailed as well, in the same words \u2014 my app finds the address itself, so never read one or write email code for it. Where my words say to EMAIL somebody, that is one of these notifications too; one that depends on a date follows my app\u2019s rule 33.";
+export declare const NOTIFY_EMAIL_OFF_LINE = "Stop emailing this page\u2019s notifications: take email: true off every notify() it makes, and any email call sent beside one, and keep the notifications themselves.";
+/**
+ * Said beside it while the page's own form switch already emails her each
+ * entry: a "somebody sent the form" notice to her, emailed as well, was the
+ * same entry in her inbox twice.
+ */
+export declare const NOTIFY_EMAIL_NOT_FORMS = "Except a notify() to me or my admins that this page\u2019s form was sent: my app already emails me each one, so that one carries no email: true.";
 /**
  * The switch, said to the assistant. Yes with not one word beside it is
  * still an ask — the decide line is the whole point of a reminder — and on a
@@ -390,9 +421,31 @@ export declare const startingPageConfig: (type: PageType) => any;
  * 2026-09-22: "newest tabs are first in the menu"), the way DashboardNav
  * already drew a tab the order had not caught up with. A new page of the
  * website goes last, after Home and the pages the site already has. The rows
- * on this screen are drawn the same way, so nothing jumps when it is written.
+ * on this screen are drawn the same way (orderSectionRows), so nothing jumps
+ * when it is written.
  */
 export declare const placeNewInOrder: <T>(order: T[], item: T, isPublic: boolean) => T[];
+/**
+ * A section's rows in the order they are drawn: Home pinned first, then the
+ * stored order — with a row the order has never named AHEAD of it among the
+ * tabs (the newest leads the menu) and after it among the pages of the
+ * website.
+ *
+ * A draft is not in the order yet either, but it is drawn where its first
+ * save will put it (placeNewInOrder): at the head of the order for a tab, at
+ * its foot for a page of the website. Drawn as a row never named, it moved
+ * the moment its name was typed: a new tab drawn above the shipped Dashboard,
+ * Support and Profile rows — which an owner's order seldom names — dropped
+ * below all three, and a new page drawn after Contact jumped up over it. Her
+ * words, 2026-09-26: "the page travels up instead of staying in the same
+ * position". A page named from a draft on this screen is drawn the same way
+ * until its entry is there — the caller says which rows those are.
+ */
+export declare const orderSectionRows: <P extends {
+    id: string;
+}>(rows: P[], order: readonly {
+    id: string;
+}[], newestFirst: boolean, isDraft: (row: P) => boolean) => P[];
 /**
  * Write a page's first document and put the page in its menu's order the way
  * the save path does — a new tab first, a new page of the website last
@@ -629,6 +682,12 @@ export declare const pageImages: (config: any) => PageImage[];
 export declare const pageImageRows: (config: any) => PageImage[];
 /** The owner's one note on how the pictures are used, by number. */
 export declare const imageNotes: (config: any) => string;
+/**
+ * Every picture handed over is DRAWN. The rehearsal's Shop had two pictures
+ * of each product, and the page drew the first and passed the second to
+ * <Picture preload>, which fetches a picture and shows nothing.
+ */
+export declare const ALL_DRAWN_LINE = "Every picture of mine above is DRAWN on the page: a thing with more than one shows them all \u2014 as a set on its card or in its pop-up \u2014 and preload never stands in for drawing one, because it only fetches a picture and shows nothing.";
 /**
  * The pictures, said to the assistant as links.
  *
@@ -668,6 +727,28 @@ export declare const mediaUses: (config: any) => {
 export declare const changedMedia: (config: any) => PageImage[];
 /** What a sentence carried that is no longer on the row — the owner took it off. */
 export declare const removedMedia: (config: any) => string[];
+export declare const PICTURE_OFF_WORDS: RegExp;
+/** Everything a change says about its pictures: the words, and the lines of the ones added since. */
+export declare const pictureChangeWords: (config: any, words: string) => string;
+/**
+ * Said where the Copy card would be, with one way through beside it.
+ *
+ * The Lotus Yoga rehearsal (2026-09-26): "take the second studio photo off
+ * the page", typed with the photo still on the row, went out in the same
+ * sentence as "already on the page and staying — put back any that has gone
+ * missing", and the fix card then asked for the photo back for good. The ✕
+ * is what tells this screen which picture it is. Words about a picture that
+ * is NOT on the row — the assistant's own stock hero — could never be cleared
+ * with a ✕, so the owner can say so once, for these words.
+ */
+export declare const PICTURE_OFF_NOTE = "Your words take a picture off the page or swap one. If it is one of the pictures in Media above, take it off there with the \u2715 on it first \u2014 otherwise this sentence hands it back as a picture that stays.";
+export declare const PICTURE_OFF_THROUGH = "It is not one of these";
+/**
+ * A change that takes a picture off in words alone. Held only when a picture
+ * a sentence already handed over is still on the row, none was taken off with
+ * its ✕ since, and the owner has not said these words are about another one.
+ */
+export declare const pictureWordsBlocker: (config: any, words: string) => string;
 /** Has the owner said anything at all about a page that ships with the app? */
 export declare const hasAnswers: (answers: any) => boolean;
 /** Only for tests: the line as the starter home page hears it. */
@@ -793,8 +874,40 @@ export declare const madeByLines: (config: any, words: string) => string[];
 export declare const DRAWN_NUMBERS_WORDS: RegExp;
 /** Numbers drawn side by side are <Bars> — on a page whose own numbers they are, where no tally is being counted (tallyLines says it there). */
 export declare const chartLines: (config: any, words: string) => string[];
-/** A count is nudged with the app's own stepper, and saved once they stop — not on every press. */
-export declare const countLines: (words: string) => string[];
+/**
+ * How many of a thing somebody BUYS, on a page with a basket: the basket's own.
+ * The Lotus Yoga rehearsal (2026-09-26): "visitors add them to a basket,
+ * choose how many" got the stepper line below AND the basket's "never
+ * quantity buttons of your own" in one sentence — and a <NumberStepper> the
+ * basket never read. The piece is not named here even as a "never": a name
+ * in a sentence is read as a part to build, and the closing recap would
+ * list it (CLOSE_PIECES).
+ */
+export declare const BASKET_COUNT_LINE = "How many of a thing somebody buys is set in my app's own basket: each line inside <Basket> has its own \u2212 and +, and pressing a thing's add button again puts one more in. So a card or a pop-up needs no count of its own \u2014 never a stepper, a box or a \u2212 and + of your own for how many to buy.";
+export declare const CONVERSATION_WORDS: RegExp;
+/** Said on the row, beside the sentence, when the words ask for a conversation. */
+export declare const CONVERSATIONS_OFF_NOTE = "Conversations on a page are switched off for now, so this page gets notes that go one way \u2014 from your team to the one person each is for, with the bell. Somebody who wants to answer writes to you through your contact form.";
+/**
+ * The one-way notes, spelled out: the write, the fields and the bell, on a
+ * page whose entries are sent to people — the only space where a note can be
+ * one person's alone. Anywhere else the sentence says only what not to build.
+ */
+export declare const conversationLines: (config: any, words: string) => string[];
+/**
+ * Words that ask a signed-in person's page to show what THEY have booked —
+ * "the classes they have booked", "their own bookings". A page with no hours
+ * attached had nothing that named the hook, and the rehearsal's Members page
+ * had only a guess. Never what "I" or "we" booked: "the rooms we have booked
+ * for events" is the owner's list, not the reader's.
+ */
+export declare const OWN_BOOKINGS_WORDS: RegExp;
+export declare const ownBookingsLines: (config: any, words: string) => string[];
+/**
+ * A count is nudged with the app's own stepper, and saved once they stop — not
+ * on every press. On a page with a basket, a count is how many to buy, and
+ * that is the basket's own.
+ */
+export declare const countLines: (words: string, basket?: boolean) => string[];
 /**
  * Words that ask for a COUNT of what visitors do — "the amount of views and
  * added to cart actions", "analytics on each product card", "how many people
@@ -1009,6 +1122,19 @@ export declare const FORM_CHANGE_EXAMPLE = "Ask for a phone number too, and add
 export declare const iconFromWords: (text: string) => string;
 /** A Heading: or Title: line in the description — the one line about the page the record, not the file, holds. */
 export declare const headingFromWords: (text: string) => string;
+export declare const asksToBook: (words: string) => boolean;
+/**
+ * Booking asked for while the Schedule is off in this version
+ * (lib/features.ts). Silence was not enough: the owner's words still say
+ * "people book a session", and Gemini, told nothing, builds a booking of its
+ * own — a calendar of made-up free times over a collection it invents. So the
+ * sentence says what the page does instead: the same request, asked on the
+ * page's form, landing in the Inbox like any entry; and the reply says
+ * booking is not in this version, so the owner is not left wondering why.
+ * Said only when the words mention booking, and conditionally even then,
+ * because "book" also means a book.
+ */
+export declare const bookingOffLines: (config: any, formType: string, text: string) => string[];
 /** The owner's words on the form — what it asks, what happens after — as one answer. */
 export declare const formWish: (config: any) => string;
 /**
@@ -1062,6 +1188,14 @@ export interface SentRecord {
     }[];
     emails: PageEmail[];
     paymentIds: string[];
+    /**
+     * The payments the page sells with its OWN buttons (soldOnPage): the ticked
+     * ones less any a booking link it attaches takes. The fix card reads it to
+     * know whether the page takes money; paymentIds alone told it to draw back
+     * a Buy button the link had taken over, and the class was sold twice.
+     * Absent on a record from before — paymentIds is read then.
+     */
+    soldIds?: string[];
     paymentNote: string;
     /** The page's own dynamic payments that had something said — [] on a record from before. */
     customPayments: CustomPayment[];
@@ -1104,6 +1238,13 @@ export interface SentRecord {
      * with the switch is where the page draws the button.
      */
     deleteBy: DeleteBy;
+    /**
+     * Who may hand an entry on (lib/recordLock.ts, handOnBy): 'admin' for the
+     * admins alone, 'holder' for whoever holds one — which is what every page
+     * built before the choice existed was, so a record from before reads that.
+     * Absent on a record from before.
+     */
+    handOnBy?: HandOnBy;
 }
 export declare const EMPTY_SENT: SentRecord;
 /** The sections as they stand right now, trimmed the way the record is. */
@@ -1139,8 +1280,24 @@ export type CopiedRecord = {
     sent: any;
     imagesSent: string[] | null;
     mediaSent: any;
+    /**
+     * The page whose sentence this was, when it was copied on ANOTHER row and
+     * built this page through a link (markLinkedBuilt). It is only this row's
+     * pictures' baseline (keptUploads): the row never showed that sentence or
+     * copied it, so it shows no "Copied" card and no sentence laid back over it.
+     */
+    linkedFrom?: string;
 };
 export declare const copiedOf: (config: any) => CopiedRecord | null;
+/**
+ * The copy a row shows as its own: never one its partner's sentence left
+ * there. Read as its own, the Clients row a copy on Invoices had built showed
+ * "Then copy this into your assistant's chat", "Copied — paste it" and a
+ * FRESH build sentence for a page that sentence had just built — pasted, it
+ * built Clients again from scratch (the review of the Lotus Yoga round,
+ * 2026-09-26).
+ */
+export declare const ownCopyOf: (config: any) => CopiedRecord | null;
 /** The row as it stood when its sentence was copied. */
 export declare const asCopied: (config: any) => any;
 /** Said on a sentence the row has already copied: where it goes, and the way on. */
@@ -1176,6 +1333,60 @@ export declare const changedSectionLines: (page: {
     lines: string[];
     linked: string[];
 };
+/**
+ * A page whose words make its payment the price of a booking on its hours —
+ * "each class is £18, paid when they book". A time booked on hours is free —
+ * only a booking link carries a price — so the sentence could only tell the
+ * assistant both "never a price for a booking" and "sell it with this
+ * button", and the owner got a page that took every booking for nothing (the
+ * Lotus Yoga rehearsal, 2026-09-26).
+ *
+ * Only the WORDS hold it. Free classes and a 10-class pass, a free taster and
+ * a basket of mats, opening times and a gift card all book on hours and sell
+ * something beside it, and holding each of them took a working page away
+ * (the review of that round): those get the sells line, sold on its own, and
+ * HOURS_FREE_NOTE on the row. The way through says every step — the owner
+ * who priced a link and left the payment ticked was sold the class twice.
+ */
+export declare const PAID_ON_HOURS_WORDS = "A time booked on the hours under Schedules is always free, and your words take a payment for it. To be paid for each booking, give a booking link its price on the Schedule screen, pick it under Booking links instead, take the hours off under Schedules and untick the payment here \u2014 or untick the payment to keep booking free.";
+/**
+ * The one way through the hold that is the owner's word, not the screen's:
+ * words can read as "paid when they book" and not be — a gift card "to pay
+ * for any class you book", class credits — and a hold nobody can clear locks
+ * the Copy button on a page that works (the review of the fix round). Pressed,
+ * those exact words are taken as a sale on its own; new words ask again.
+ */
+export declare const PAID_HOURS_THROUGH = "My payment is not the price of a booking";
+/** Said on the row, never a hold, where a page books on its hours and sells something beside it. */
+export declare const HOURS_FREE_NOTE = "A time booked on the hours under Schedules is always free. To be paid for each booking, give a booking link its price on the Schedule screen and pick it under Booking links.";
+/**
+ * The payments a page sells with its own buttons: those ticked for it, less
+ * any a booking link it attaches already takes. A team page sells nothing, so
+ * it keeps every one it follows.
+ */
+export declare const soldOnPage: (page: {
+    id?: string;
+    title: string;
+    path: string;
+}, config: any, products?: PaymentProduct[]) => PaymentProduct[];
+/**
+ * The owner's standing words the hold reads: the page's own boxes and each
+ * payment it sells — never the change box, which is read on its own (see
+ * paidOnHours).
+ */
+export declare const paidHoursWords: (page: {
+    id?: string;
+    path: string;
+}, config: any, products?: PaymentProduct[]) => string;
+export declare const paidBookingBlocker: (page: {
+    id?: string;
+    path: string;
+}, config: any) => string;
+/** The quiet note, never a hold: the page books on its hours and sells something beside it. */
+export declare const hoursFreeNote: (page: {
+    id?: string;
+    path: string;
+}, config: any, products?: PaymentProduct[]) => string;
 /**
  * What is still missing before the change sentence is worth pasting: a
  * section left half-finished, else — when no section has changed — the
@@ -1211,6 +1422,11 @@ export declare const changePagePrompt: (page: {
     path: string;
     type?: PageType;
 }, config: any, targets?: WiringPageRow[]) => string;
+/**
+ * A store's home page: selling is what it is FOR. Store words, and none of the
+ * words a page about something else uses — and a shop only named as the page
+ * it leads to does not make one.
+ */
 export declare const isStoreHome: (words: string) => boolean;
 export declare const storeHomeLine: (hasForm: boolean) => string;
 export declare const SYSTEM_PAGE_PROMPTS: Record<string, {
@@ -1409,16 +1625,43 @@ export declare const emailLook: (e: PageEmail) => EmailLook;
  * yet, so the switch is not lost and the question is asked.
  */
 export declare const pageEmails: (config: any) => PageEmail[];
-/** What is still missing before the page's emails can ride its sentence. */
-export declare const emailBlocker: (config: any) => string;
+/** A page's form emails, as stored. */
+export interface FormEmails {
+    owner: boolean;
+    confirm: boolean;
+    note: string;
+}
+/** Whether the row has been saved with the switches: from then on the app sends its form emails itself. */
+export declare const appSendsFormEmails: (config: any) => boolean;
+/**
+ * The switches as the row draws them. A page from before them shows what its
+ * old emails meant — "Let me know when something happens here" as the first,
+ * "Send the person a confirmation" as the second, its words as the note — and
+ * nothing is written until the owner touches one.
+ */
+export declare const formEmailsOf: (config: any) => FormEmails;
 /**
- * The emails, said to the assistant. The helpers are named because "send an
- * email" without them produced hand-rolled Resend code; the mechanics live in
- * the pasted contract (rule 10), and the owner's own words close each line —
- * after a "Here is what" lead-in, so the PromptCard picks them out. The look
- * rides the call itself: a card asks for `details` (the facts, as rows), a
- * note passes `look: 'text'` where the template's own default is a card. The
- * assistant never styles anything — the server dresses every email.
+ * What a change to the switches writes: the switches, and the page's old
+ * hand-sent emails taken off in the same save, so the app never sends one the
+ * page still sends too. The team's "write to anyone" is not a form email and
+ * stays.
+ */
+export declare const formEmailsPatch: (config: any, next: FormEmails) => {
+    formEmails: FormEmails;
+    emails: PageEmail[];
+};
+/** The one line a page's sentence says about its form emails. */
+export declare const FORM_EMAILS_LINE = "My app emails this page's forms itself once one is sent \u2014 to me, and a confirmation to whoever sent it, as I switched them on \u2014 so write no email code for them: no emailOwner, emailPerson or email of your own after a form is sent.";
+/** Said once, the first time the switches are saved on a page whose code sent its own. */
+export declare const FORM_EMAILS_TAKEN_OVER_LINE = "My app sends this page's form emails itself now. Take out the emails this page sends by hand \u2014 every emailOwner(\u2026) and emailPerson(\u2026) call \u2014 and change nothing else.";
+/** The team's "write to anyone", stored as the old 'send' entry so a page built with it keeps its sentence. */
+export declare const teamWriteOf: (config: any) => PageEmail | null;
+/**
+ * The emails, said to the assistant. A page with the switches says ONE line
+ * — the app sends its form emails, so no code for them — and a page from
+ * before them keeps its old lines until the owner changes its email
+ * settings. The team's "write to anyone" is said on a team page only.
+ * Nothing about email is said until email is connected and on.
  */
 export declare const emailLines: (config: any) => string[];
 /** The payments the owner has described and finished — the ones a page can carry. */
@@ -1431,6 +1674,16 @@ export declare const paymentsFor: (page: {
 }, config: any, products?: PaymentProduct[]) => PaymentProduct[];
 /** The owner's words on the payments on this page. */
 export declare const paymentNote: (config: any) => string;
+/**
+ * A hold the row says in words, where the Copy card would be: one no box
+ * above it explains. A Teachers page linked to an unbuilt Classes page that
+ * charged for booking on its hours was held by "On the page at /classes: a
+ * time booked…" — drawn nowhere, so its card just vanished (the review of
+ * the Lotus Yoga round, 2026-09-26).
+ */
+export declare const heldOnRow: (blockedBy: string) => string;
+/** Said after what a page sells when it also books on its hours. */
+export declare const SOLD_APART_CLAUSE = ", on its own: a time booked on this page\u2019s hours is always free, and no button here is ever the price of a booking";
 /**
  * The payments, said to the assistant: the button rule, each payment's own
  * selling lines from the Payments screen — its buttons with their ids or
@@ -1471,12 +1724,6 @@ export type { PageLink } from '../lib/paymentProducts';
  * disagree about which page an id names.
  */
 export declare const linkTarget: (link: PageLink, targets: WiringPageRow[]) => WiringPageRow | undefined;
-/**
- * What is still missing before a link can ride the page's sentence. A page
- * this sentence BUILDS — one of the owner's, not built yet — is held back by
- * its own unfinished sections too, exactly as it would be on its own row,
- * and the words say which page they mean.
- */
 export declare const linkBlocker: (link: PageLink, targets: WiringPageRow[]) => string;
 /**
  * The first unanswered question across a page's links — what holds the page's
@@ -1614,6 +1861,8 @@ export declare const roadBlocker: (config: any, targets: WiringPageRow[]) => str
  * control is asked for by name, with the three calls it is made of.
  */
 export declare const handedOutLines: (config: any, where?: string) => string[];
+export declare const HAND_ON_ADMIN_LINE = "From now on only me and my admins hand an entry on this page to somebody, or take it back. My app enforces it \u2014 my database refuses everybody else\u2019s, and <HandOver> draws its picker for nobody else \u2014 so somebody who was handed an entry works on it and never passes it on. Wherever this page has a picker, an Assign or Unassign button, a usePeople, a sendTo or a takeBack of its own for handing an entry to a person, replace the lot with my app\u2019s own <HandOver entry={entry} collection={\u2026} name={\u2026} /> from 'your-ai-workflow-firebase-os' \u2014 on each entry\u2019s card (compact) and inside the opened entry (label='Assigned to') \u2014 and take out anything that writes who holds an entry by hand. Change nothing else.";
+export declare const HAND_ON_HOLDER_LINE = "Whoever holds an entry on this page may pass it on again \u2014 my app has lifted the lock, and <HandOver> now draws its picker for them too. Where my words keep the handing over from a group, draw that group <HandOver readOnly \u2026 />. Change nothing else.";
 /**
  * Every road the owner's links make: a page anybody can open, linked to a
  * page whose entries are sent to people. The same two halves, the same form
@@ -1674,8 +1923,11 @@ export declare const arrivalRoads: (rows: WiringPageRow[]) => ArrivalRoad[];
  * one ANYBODY can open there is nothing to bridge at all: a visitor is not
  * that person and was sent no entry, so the honest answer is that the public
  * page does not show it and the person signs in.
+ *
+ * `rows` are the other pages of the app, so a basket's line can name the copy
+ * its page reads through a link that is not this one.
  */
-export declare const sharedDataLines: (config: any, target: WiringPageRow, how?: string) => string[];
+export declare const sharedDataLines: (config: any, target: WiringPageRow, how?: string, rows?: WiringPageRow[]) => string[];
 /**
  * This page's half of every finished link, inside its OWN fill or change
  * sentence. What is particular to a link:
@@ -1734,6 +1986,12 @@ export declare const pageLinkSources: (page: {
  * record compares against, all three from this one place.
  */
 export declare const bookingDraft: (config: any) => PageBooking;
+/**
+ * The hint under "what should they be asked?". It also says a time booked on
+ * hours is free — before the Lotus Yoga rehearsal (2026-09-26) nothing on the
+ * row did, and "£18, paid when they book" built a page that charged nothing.
+ */
+export declare const ASK_BOX_HINT = "Optional \u2014 leave it empty and nothing is booked on this page unless your words above ask for it. In your own words, not fields: their name and their email are always taken, and a visitor already signed in is never asked for them. A time booked on these hours is free; for a paid one, pick a booking link with its price under Booking links instead.";
 /**
  * A tab's icon comes from the owner's words ("use a camera icon"), else from
  * its name — and, since the tile on its row became a button, from the owner's
@@ -1769,6 +2027,15 @@ export declare const TYPED_HOLD_MS = 300;
  * nothing needs to move, so an arrival that changes nothing re-renders nothing.
  */
 export declare const adoptNewer: (typed: Record<string, any>, before: Record<string, any>, now: Record<string, any>) => Record<string, any>;
+/** What a new page's Name and Web address say, before the name makes the page and after. */
+export declare const NAME_HINTS: {
+    before: string;
+    after: string;
+};
+export declare const ADDRESS_HINTS: {
+    before: string;
+    after: string;
+};
 /**
  * How long a save that did not get through waits before it is tried again,
  * and again. A refused write used to be a line in the console and nothing

package/dist/pages/PaymentsGoLive.d.ts

@@ -1,3 +1,4 @@
+import { ResendStatus } from '../lib/serviceStatus';
 /**
  * The one chip this card wears, pure so the reading is testable. The switch
  * being on is not "live" — live is the server holding an sk_live_ key.
@@ -10,6 +11,17 @@ export declare function goLiveChip(intent: boolean, mode: 'live' | 'test' | null
     state: 'saved' | 'saving' | 'off';
     label: string;
 };
+/**
+ * Whether buyers get a receipt once this is live, read off the Email tab's
+ * answer. Pure, so every case is testable. `fix`: the Email screen is where
+ * it is put right.
+ */
+export declare function receiptsReach(email: Pick<ResendStatus, 'configured' | 'enabled' | 'receipts' | 'senderVerified' | 'from'> | null): {
+    state: 'saved' | 'saving' | 'off';
+    label: string;
+    line: string;
+    fix: boolean;
+};
 /** The two events the server acts on — see the webhook in server/index.ts. */
 export declare const WEBHOOK_EVENTS: readonly ["checkout.session.completed", "checkout.session.async_payment_succeeded"];
 export declare function GoLiveCard(): import("react/jsx-runtime").JSX.Element;

package/dist/pages/ScheduleAdmin.d.ts

@@ -60,18 +60,4 @@ export declare function ScheduleFields({ schedule, onChange }: {
 export declare function SchedulesCard({ isAdmin }?: {
     isAdmin?: boolean;
 }): import("react/jsx-runtime").JSX.Element;
-/**
- * The Schedule screen — the whole team's, not only the admin's.
- *
- * Anyone marked Internal runs their OWN meetings here: their hours, their
- * length, what the booking page asks, the emails it sends, a payment their
- * admin has set up, their own link to send out and their own booking pages
- * gathering those links under one address. What they do not get is anybody
- * else's — no team card, no team member's diary, nobody else's pages. The
- * rules say the same thing rather than trusting this screen to: a person may
- * write a sys_schedules or sys_bookingpages document whose memberId is their
- * own uid, and no other.
- *
- * The admin's screen is unchanged, with everything on it.
- */
 export declare function ScheduleAdmin(): import("react/jsx-runtime").JSX.Element;

package/dist/pages/SetupPayments.d.ts

@@ -22,14 +22,13 @@ export interface EmailSetupStatus extends ResendStatus {
 /** Polls /api/email/status the way payments are polled: a pasted key turns
     its own step green without a refresh. */
 export declare function useEmailSetupStatus(intervalMs?: number): EmailSetupStatus;
-/** The email key's one chip: key found, or not yet. */
+/**
+ * The email key's one chip: what Resend says of the key, not just that one is
+ * there. A mistyped or revoked key is not green, and a key made the narrow
+ * way (sending only) is told apart, because the domain card needs Full access.
+ */
 export declare function emailChip(s: EmailSetupStatus): {
-    state: 'saved' | 'saving' | 'off';
-    label: string;
-};
-/** The sender step's chip: a domain of the owner's own, or still the practice address. */
-export declare function senderChip(s: EmailSetupStatus): {
-    state: 'saved' | 'saving' | 'off';
+    state: 'saved' | 'saving' | 'off' | 'error';
     label: string;
 };
 /**
@@ -99,11 +98,11 @@ export declare function StripeSetupSteps({ onConfirm }: {
     onConfirm: () => void;
 }): import("react/jsx-runtime").JSX.Element;
 /**
- * The email steps — a Resend account, its key, the two secrets, and the
- * domain of the owner's own. The domain is not an afterthought: until one is
- * verified, Resend delivers only to the address the Resend account was made
- * with, so a customer's confirmation or receipt never arrives. The steps say
- * so where it matters.
+ * The email steps: a Resend account and a key made with Full access, then
+ * that ONE key pasted as RESEND_KEY. Nothing else is asked for here: her
+ * domain is typed and verified on the Email tab itself once the key is in
+ * (the key's Full access is what lets the app add it for her), and her own
+ * mail goes to her sign-in address with nothing to set.
  */
 export declare function EmailSetupSteps({ onConfirm }: {
     onConfirm: () => void;

package/dist/pages/TransactionsAdmin.d.ts

@@ -1,4 +1,8 @@
 import { TransactionRow } from '../lib/transactions';
+/** How many of each Inbox collection's newest entries the admin's read holds, and each "Show older" adds. */
+export declare const ENTRY_PAGE = 100;
+/** The entry id a payment names, when it names one that could be a document's id. */
+export declare const namedEntryId: (collected: Record<string, string> | undefined) => string;
 /**
  * The row a payment's id names. The bell carries Stripe's own id — a charge's
  * ch_… or py_…, a subscription's sub_… — and a row here is keyed by its kind