@proveanything/smartlinks 2.1.1 → 2.1.2

package/dist/api/bookings.d.ts

@@ -1,4 +1,4 @@
-import type { Booking, BookingSlot, BookingAllocation, CreateBookingInput, UpdateBookingInput, MoveBookingInput, BookingListQueryParams, CreateSlotInput, UpdateSlotInput, SlotListQueryParams, CreateBlockInput, BlockListQueryParams, FreeBusyQuery, FreeBusyResponse, BookingAccessOptions } from '../types/bookings.js';
+import type { Booking, BookingSlot, BookingAllocation, CreateBookingInput, UpdateBookingInput, MoveBookingInput, BookingListQueryParams, CreateSlotInput, UpdateSlotInput, SlotListQueryParams, CreateBlockInput, BlockListQueryParams, FreeBusyQuery, FreeBusyResponse, BookingAccessOptions, MessageBookersInput, MessageBookersResult } from '../types/bookings.js';
 import type { PaginatedResponse } from '../types/appObjects.js';
 export declare namespace bookings {
     /**
@@ -55,6 +55,12 @@ export declare namespace bookings {
      * GET /bookings/freebusy
      */
     function freebusy(collectionId: string, appId: string, q: FreeBusyQuery, admin?: boolean): Promise<FreeBusyResponse>;
+    /**
+     * Message the people booked (admin): a template to everyone on a slot, or everyone booked in a date
+     * range (optionally with one person / room), each send hydrated with their booking ({{ booking }}).
+     * No segment to make. POST /bookings/message
+     */
+    function message(collectionId: string, appId: string, input: MessageBookersInput): Promise<MessageBookersResult>;
     namespace slots {
         /** Create a slot (admin). POST /bookings/slots */
         function create(collectionId: string, appId: string, input: CreateSlotInput): Promise<BookingSlot>;

package/dist/api/bookings.js

@@ -122,6 +122,15 @@ export var bookings;
         return request(`${basePath(collectionId, appId, admin)}/freebusy${query(params)}`);
     }
     bookings.freebusy = freebusy;
+    /**
+     * Message the people booked (admin): a template to everyone on a slot, or everyone booked in a date
+     * range (optionally with one person / room), each send hydrated with their booking ({{ booking }}).
+     * No segment to make. POST /bookings/message
+     */
+    async function message(collectionId, appId, input) {
+        return post(`${basePath(collectionId, appId, true)}/message`, input);
+    }
+    bookings.message = message;
     // ==================== SLOTS ====================
     let slots;
     (function (slots_1) {

package/dist/docs/API_SUMMARY.md

@@ -1,6 +1,6 @@
 # Smartlinks API Summary
 
-Version: 2.1.1  |  Generated: 2026-10-25T08:26:22.390Z
+Version: 2.1.2  |  Generated: 2026-10-26T14:58:53.408Z
 
 This is a concise summary of all available API functions and types.
 
@@ -2816,6 +2816,7 @@ interface ServerFunctionBookings {
   complete(bookingId: string): Promise<Booking>;
   noShow(bookingId: string): Promise<Booking>;
   freebusy(q: FreeBusyQuery): Promise<FreeBusyResponse>;
+  message(input: MessageBookersInput): Promise<MessageBookersResult>;
   slots: {
   create(input: CreateSlotInput): Promise<BookingSlot>;
   createMany(inputs: CreateSlotInput[], opts?: { seriesId?: string }): Promise<BookingSlot[]>;
@@ -5366,6 +5367,32 @@ interface FreeBusyResponse {
 }
 ```
 
+**MessageBookersInput** (interface)
+```typescript
+interface MessageBookersInput {
+  templateId: string
+  channel?: 'email' | 'sms' | 'whatsapp' | 'push' | 'preferred'
+  props?: Record<string, any>
+  slotId?: string
+  from?: string | Date
+  to?: string | Date
+  resourceType?: string
+  resourceId?: string
+  statuses?: BookingStatus[]
+  ref?: string
+}
+```
+
+**MessageBookersResult** (interface)
+```typescript
+interface MessageBookersResult {
+  matched: number
+  sent: number
+  skipped: { noContact: number; duplicate: number; failed: number }
+  failures: Array<{ bookingId: string; error: string }>
+}
+```
+
 **BookingAccessOptions** (interface)
 ```typescript
 interface BookingAccessOptions {
@@ -11902,6 +11929,9 @@ confirmed → no_show (admin).
 **freebusy**(collectionId: string, appId: string, q: FreeBusyQuery, admin: boolean = false) → `Promise<FreeBusyResponse>`
 Busy intervals per resource (bookings, blocks, slots' own blocks) — never booking details. Public only when the app sets `publicRead.bookings.freebusy: true`. GET /bookings/freebusy
 
+**message**(collectionId: string, appId: string, input: MessageBookersInput) → `Promise<MessageBookersResult>`
+Message the people booked (admin): a template to everyone on a slot, or everyone booked in a date range (optionally with one person / room), each send hydrated with their booking ({{ booking }}). No segment to make. POST /bookings/message
+
 ### bookings.blocks
 
 **create**(collectionId: string, appId: string, input: CreateBlockInput) → `Promise<BookingAllocation>`

package/dist/docs/bookings.md

@@ -324,8 +324,80 @@ Recorded after each write commits, for flows and app functions (`trigger: { type
 `booking.no_show`, `booking.hold_expired`, `slot.full`, `slot.place_freed` (for waitlist promotion).
 Context: `{ appId, status, slotIds }` (bookings) / `{ appId, remaining }` (slots).
 
-Reminders before a booking (`booking.starts_in`) are coming; until then, use a cron function that lists
-upcoming bookings.
+Reminders before a booking (`booking.starts_in`) are coming; until then, send a reminder template to
+tomorrow's bookers with `bookings.message` (below) from a cron function.
+
+---
+
+## Confirmations and messages
+
+Nothing is emailed by default: your app decides what goes out, in **flows on booking events**, with
+**templates the business can reword in Studio** (Comms → Templates). The platform does the sending,
+the hydration and the consent.
+
+### Flows on booking events
+
+A site, or an app on behalf of a business, sets them up through the cloud blueprint
+(`cloud/flows.json` in a site; `POST /admin/collection/:cId/blueprint/apply` with
+`{ appId, blueprint: { templates, flows } }` from an app's admin screen). Additive: re-applying never
+removes what is there, and a template edited in Studio keeps its edits unless the blueprint sends new
+wording.
+
+```json
+{
+  "templates": {
+    "booking-confirmed": { "name": "You're booked", "email": { "subject": "{{ booking.serviceName }} on {{ booking.when.date }}", "body": "<p>Hi {{ contact.firstName }}, see you at {{ booking.when.time }}.</p>" }, "sms": { "body": "Booked: {{ booking.when.shortDate }} {{ booking.when.time }}" } },
+    "booking-requested": { "name": "Request received", "email": { "subject": "We got your request", "body": "<p>We'll confirm shortly.</p>" } },
+    "staff-new-booking": { "name": "You've been booked", "email": { "subject": "New appointment", "body": "<p>{{ booking.customer.name }}, {{ booking.when.dateTime }}</p>" } }
+  },
+  "flows": [
+    { "when": { "event": "booking.confirmed" }, "do": [{ "send": "booking-confirmed", "to": "contact" }, { "send": "staff-new-booking", "to": "resource" }, { "send": "team-new-booking", "to": "team" }] },
+    { "when": { "event": "booking.created", "status": "pending" }, "do": [{ "send": "booking-requested", "to": "contact" }] }
+  ]
+}
+```
+
+- `when.event`: `booking.created` / `confirmed` / `cancelled` / `moved` / `completed` / `no_show` /
+  `hold_expired`, `slot.full` / `slot.place_freed`; `when.status` narrows to the booking's status at the
+  time (`"pending"` for "request received").
+- `to`: `contact` — the booker, by their preferred channel (`channel` to force one; a template needs an
+  `sms` part to go by text); `team` — the collection's team addresses; `resource` — the booked
+  person or room: a resource that is a contact, or a record with `data.email` / `data.contactId`.
+  A **public** resource record (a staff profile the booking page lists) keeps its address on a
+  **private child record** instead (`visibility: 'admin'`, `parentType: 'record'`, `parentId` = the
+  resource) — the platform looks there too, and the address never ships with the public listing.
+- Who gets what, in templates: `{{ booking }}` is the booking **ready-formatted**: its fields and
+  `data`, plus `serviceName`, `staffName`, `customer`, `durationMinutes`, `when` (`date`,
+  `shortDate`, `time`, `endTime`, `dateTime`, `timezone` — in the business's timezone) and, when the
+  recipient's timezone is known and differs, `whenFor` (the same in theirs); `editToken` only when the
+  recipient is the booker (a guest's manage link). `{{ contact }}` is the recipient; `{{ appConfig }}`
+  the app's public config (a booking page's address, the business name) for sends to the contact.
+
+### Who is reachable
+
+A **guest** who books with an email or phone gets a **contact** (found by that identity or made,
+filling only empty fields: a form's details never overwrite a known contact), and so does a customer
+**staff book in by hand** (`customer: { name, email, phone }` on the body or in `data`). Admin
+creates may pass `contactId` instead. A booking with no contact gets no messages: show the booker why
+an email is worth giving.
+
+### Messaging everyone booked — `bookings.message`
+
+No list to build, no segment to save: send a template to everyone on a slot, or everyone booked in a
+window (optionally with one resource), each hydrated with **their own** booking.
+
+```ts
+// Everyone on tomorrow's 10:00 class
+await SL.bookings.message(collectionId, appId, { templateId, slotId })
+// Everyone booked with Sam next week, by email even if they prefer texts
+await SL.bookings.message(collectionId, appId, { templateId, channel: 'email', from, to, resourceType: 'record', resourceId: samId })
+// → { matched, sent, skipped: { noContact, duplicate, failed }, failures: [{ bookingId, reason }] }
+```
+
+Statuses default to held, pending and confirmed; at most 500 recipients per call (narrow the window
+for more). One message per contact on a slot, one per booking in a window. Also
+`ctx.sl.bookings.message(input)` in a server function (`sl:bookings:write`) — a cron function that
+messages tomorrow's bookers is a reminder system in five lines.
 
 ---
 
@@ -343,6 +415,7 @@ All take `(collectionId, appId, …)`; `admin` is the last parameter where both
 | `bookings.confirm / cancel / move(…, admin?, { editToken }?)` | ✓ | per `ownerActions.bookings` |
 | `bookings.extendHold / complete / noShow` | ✓ | — |
 | `bookings.freebusy(q, admin?)` | ✓ | if `publicRead.bookings.freebusy` |
+| `bookings.message(input)` | ✓ | — |
 | `bookings.slots.create / createMany / update / remove` | ✓ | — |
 | `bookings.slots.list / get(…, admin?)` | ✓ | open, public slots |
 | `bookings.blocks.create / list / remove` | ✓ | — |

package/dist/docs/server-functions.md

@@ -517,7 +517,7 @@ Prefer the platform primitives above over a dependency; when you do need one, pi
 | Check a tapped tag is real | `ctx.sl.tags.resolve(proofId)` → `{ id, claimSetId, code }` or `null` | `sl:tags:read` |
 | Put a visitor's details on a contact | `ctx.sl.contacts.upsert({ email, firstName, … })` → `{ contactId, created }` (fills empty fields only) | `sl:contacts:write` |
 | Record "they did X" | `ctx.sl.interactions.record({ interactionId, contactId, outcome, metadata })` | `sl:interactions:write` |
-| Take a booking with your own checks (hours, queue token, payment) | `ctx.sl.bookings.create({ slotId \| resource + time, contactId, status, idempotencyKey })` — never oversold, never double-booked; also `confirm` / `cancel` / `move` / `mine` / `freebusy` / `slots.*` / `blocks.*` (see [bookings.md](bookings.md)) | `sl:bookings:write` (`sl:bookings:read` to read) |
+| Take a booking with your own checks (hours, queue token, payment) | `ctx.sl.bookings.create({ slotId \| resource + time, contactId, status, idempotencyKey })` — never oversold, never double-booked; also `confirm` / `cancel` / `move` / `mine` / `freebusy` / `message` (everyone booked, hydrated) / `slots.*` / `blocks.*` (see [bookings.md](bookings.md)) | `sl:bookings:write` (`sl:bookings:read` to read) |
 
 Notes:
 - **Talking to the SmartLinks core is `ctx.sl`, not HTTP.** The common pattern — *validate /
@@ -636,6 +636,18 @@ try {
 }
 ```
 
+`ctx.sl.bookings.message({ templateId, slotId | from, to, resourceType?, resourceId?, channel? })` sends a
+template to everyone booked (each hydrated with their own booking) — the five-line reminder cron:
+
+```ts
+// manifest: { name: 'remind', trigger: { type: 'cron', schedule: '0 17 * * *' }, capabilities: ['sl:bookings:write'] }
+export async function remind(ctx) {
+  const from = new Date(); from.setDate(from.getDate() + 1); from.setHours(0, 0, 0, 0)
+  const to = new Date(from); to.setDate(to.getDate() + 1)
+  return ctx.sl.bookings.message({ templateId: 'bp.' + ctx.collectionId + '.reminder', from, to })
+}
+```
+
 The local harness runs bookings in memory with the same rules (capacity, per-person limits, no
 overlaps, idempotency, holds): `ctx.memory.bookings`.
 

package/dist/openapi.yaml

@@ -10291,6 +10291,32 @@ paths:
           description: Unauthorized
         404:
           description: Not found
+  /message:
+    post:
+      tags:
+        - bookings
+      summary: "Message the people booked (admin): a template to everyone on a slot, or everyone booked in a date range (optionally with one person / room), each send hydrated with their booking ({{ booking }})."
+      operationId: bookings_message
+      security: []
+      responses:
+        200:
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/MessageBookersResult"
+        400:
+          description: Bad request
+        401:
+          description: Unauthorized
+        404:
+          description: Not found
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/MessageBookersInput"
   /platform/location:
     post:
       tags:
@@ -24706,6 +24732,62 @@ components:
         - from
         - to
         - resources
+    MessageBookersInput:
+      type: object
+      properties:
+        templateId:
+          type: string
+        channel:
+          type: string
+          enum:
+            - email
+            - sms
+            - whatsapp
+            - push
+            - preferred
+        props:
+          type: object
+          additionalProperties: true
+        slotId:
+          type: string
+        from:
+          type: object
+          additionalProperties: true
+        to:
+          type: object
+          additionalProperties: true
+        resourceType:
+          type: string
+        resourceId:
+          type: string
+        statuses:
+          type: array
+          items:
+            $ref: "#/components/schemas/BookingStatus"
+        ref:
+          type: string
+      required:
+        - templateId
+    MessageBookersResult:
+      type: object
+      properties:
+        matched:
+          type: number
+        sent:
+          type: number
+        skipped:
+          type: object
+          additionalProperties: true
+        failures:
+          type: array
+          items:
+            type: object
+            additionalProperties: true
+      required:
+        - matched
+        - sent
+        - skipped
+        - failures
     BookingAccessOptions:
       type: object
       properties:

package/dist/testing/bookingsMemory.d.ts

@@ -32,6 +32,17 @@ export declare function bookingsMemoryImpl(mem: BookingsMemory, caller?: {
     cancel(bookingId: string, opts?: any): Promise<any>;
     move(bookingId: string, input?: any): Promise<any>;
     extendHold(bookingId: string, holdMinutes: number): Promise<any>;
+    /** Counts who would be messaged (no sends in memory); inject `sl.bookings.message` to assert sends. */
+    message(input?: any): Promise<{
+        matched: number;
+        sent: number;
+        skipped: {
+            noContact: number;
+            duplicate: number;
+            failed: number;
+        };
+        failures: any[];
+    }>;
     complete(bookingId: string): Promise<any>;
     noShow(bookingId: string): Promise<any>;
     freebusy(q?: any): Promise<{

package/dist/testing/bookingsMemory.js

@@ -280,6 +280,28 @@ export function bookingsMemoryImpl(mem, caller = {}) {
             b.holdExpiresAt = iso(Math.min(now() + (holdMinutes !== null && holdMinutes !== void 0 ? holdMinutes : 15) * 60000, ms(b.createdAt) + 24 * 3600000));
             return copy(withAllocations(b));
         },
+        /** Counts who would be messaged (no sends in memory); inject `sl.bookings.message` to assert sends. */
+        async message(input = {}) {
+            const list = input.slotId
+                ? (await this.query({ slotId: input.slotId, status: (input.statuses || ['held', 'pending', 'confirmed']).join(',') })).data
+                : (await this.query({ from: input.from, to: input.to, status: (input.statuses || ['held', 'pending', 'confirmed']).join(',') })).data;
+            const seen = new Set();
+            const out = { matched: list.length, sent: 0, skipped: { noContact: 0, duplicate: 0, failed: 0 }, failures: [] };
+            for (const b of list) {
+                if (!b.contactId) {
+                    out.skipped.noContact++;
+                    continue;
+                }
+                const key = input.slotId ? b.contactId : `${b.contactId}:${b.id}`;
+                if (seen.has(key)) {
+                    out.skipped.duplicate++;
+                    continue;
+                }
+                seen.add(key);
+                out.sent++;
+            }
+            return out;
+        },
         async complete(bookingId) { return outcome(find(bookingId), 'completed'); },
         async noShow(bookingId) { return outcome(find(bookingId), 'no_show'); },
         async freebusy(q = {}) {

package/dist/testing/index.js

@@ -274,7 +274,7 @@ export function createFunctionTestContext(opts) {
     const bkFn = (obj, name) => (obj && typeof obj[name] === 'function' ? obj[name].bind(obj) : undefined);
     const BOOKING_READS = new Set(['get', 'query', 'mine', 'freebusy']);
     sl.bookings = {};
-    for (const m of ['create', 'get', 'query', 'mine', 'update', 'confirm', 'cancel', 'move', 'extendHold', 'complete', 'noShow', 'freebusy']) {
+    for (const m of ['create', 'get', 'query', 'mine', 'update', 'confirm', 'cancel', 'move', 'extendHold', 'complete', 'noShow', 'freebusy', 'message']) {
         sl.bookings[m] = gated('bookings', BOOKING_READS.has(m) ? 'read' : 'write', bkFn(bk, m), `bookings.${m}`);
     }
     sl.bookings.slots = {};

package/dist/types/appManifest.d.ts

@@ -4,7 +4,7 @@ import type { AppDataDeclaration, AppHeadlessDeclaration } from './headless.js';
 import type { RealtimeChannelDeclaration } from './realtime.js';
 import type { AppManifestAdminCards } from './adminCards.js';
 import type { PaginatedResponse } from './appObjects.js';
-import type { Booking, BookingSlot, BookingAllocation, CreateBookingInput, UpdateBookingInput, MoveBookingInput, BookingListQueryParams, CreateSlotInput, UpdateSlotInput, SlotListQueryParams, CreateBlockInput, BlockListQueryParams, FreeBusyQuery, FreeBusyResponse } from './bookings.js';
+import type { Booking, BookingSlot, BookingAllocation, CreateBookingInput, UpdateBookingInput, MoveBookingInput, BookingListQueryParams, CreateSlotInput, UpdateSlotInput, SlotListQueryParams, CreateBlockInput, BlockListQueryParams, FreeBusyQuery, FreeBusyResponse, MessageBookersInput, MessageBookersResult } from './bookings.js';
 /**
  * A bundle (widget or container) as returned by the collection widgets endpoint.
  *
@@ -449,6 +449,8 @@ export interface ServerFunctionBookings {
     noShow(bookingId: string): Promise<Booking>;
     /** Busy intervals per resource — feed them to `utils.freeTimes` with your schedule. */
     freebusy(q: FreeBusyQuery): Promise<FreeBusyResponse>;
+    /** A template to everyone booked on a slot / in a range, each hydrated with their booking. */
+    message(input: MessageBookersInput): Promise<MessageBookersResult>;
     slots: {
         create(input: CreateSlotInput): Promise<BookingSlot>;
         createMany(inputs: CreateSlotInput[], opts?: {

package/dist/types/bookings.d.ts

@@ -266,6 +266,37 @@ export interface FreeBusyResponse {
         busy: FreeBusyInterval[];
     }>;
 }
+/** `bookings.message`: a template to everyone booked on a slot, or in a date range. */
+export interface MessageBookersInput {
+    /** A comms template of the collection (edited in Studio). */
+    templateId: string;
+    channel?: 'email' | 'sms' | 'whatsapp' | 'push' | 'preferred';
+    /** Extra Liquid variables, on top of {{ booking }}, {{ contact }} and {{ appConfig }}. */
+    props?: Record<string, any>;
+    /** Everyone on this slot … */
+    slotId?: string;
+    /** … or everyone booked in [from, to), optionally with one resource. */
+    from?: string | Date;
+    to?: string | Date;
+    resourceType?: string;
+    resourceId?: string;
+    /** Default: held, pending, confirmed. */
+    statuses?: BookingStatus[];
+    ref?: string;
+}
+export interface MessageBookersResult {
+    matched: number;
+    sent: number;
+    skipped: {
+        noContact: number;
+        duplicate: number;
+        failed: number;
+    };
+    failures: Array<{
+        bookingId: string;
+        error: string;
+    }>;
+}
 /** Public calls on a booking made by an anonymous guest: pass the edit token returned at create. */
 export interface BookingAccessOptions {
     editToken?: string;

package/docs/API_SUMMARY.md

@@ -1,6 +1,6 @@
 # Smartlinks API Summary
 
-Version: 2.1.1  |  Generated: 2026-10-25T08:26:22.390Z
+Version: 2.1.2  |  Generated: 2026-10-26T14:58:53.408Z
 
 This is a concise summary of all available API functions and types.
 
@@ -2816,6 +2816,7 @@ interface ServerFunctionBookings {
   complete(bookingId: string): Promise<Booking>;
   noShow(bookingId: string): Promise<Booking>;
   freebusy(q: FreeBusyQuery): Promise<FreeBusyResponse>;
+  message(input: MessageBookersInput): Promise<MessageBookersResult>;
   slots: {
   create(input: CreateSlotInput): Promise<BookingSlot>;
   createMany(inputs: CreateSlotInput[], opts?: { seriesId?: string }): Promise<BookingSlot[]>;
@@ -5366,6 +5367,32 @@ interface FreeBusyResponse {
 }
 ```
 
+**MessageBookersInput** (interface)
+```typescript
+interface MessageBookersInput {
+  templateId: string
+  channel?: 'email' | 'sms' | 'whatsapp' | 'push' | 'preferred'
+  props?: Record<string, any>
+  slotId?: string
+  from?: string | Date
+  to?: string | Date
+  resourceType?: string
+  resourceId?: string
+  statuses?: BookingStatus[]
+  ref?: string
+}
+```
+
+**MessageBookersResult** (interface)
+```typescript
+interface MessageBookersResult {
+  matched: number
+  sent: number
+  skipped: { noContact: number; duplicate: number; failed: number }
+  failures: Array<{ bookingId: string; error: string }>
+}
+```
+
 **BookingAccessOptions** (interface)
 ```typescript
 interface BookingAccessOptions {
@@ -11902,6 +11929,9 @@ confirmed → no_show (admin).
 **freebusy**(collectionId: string, appId: string, q: FreeBusyQuery, admin: boolean = false) → `Promise<FreeBusyResponse>`
 Busy intervals per resource (bookings, blocks, slots' own blocks) — never booking details. Public only when the app sets `publicRead.bookings.freebusy: true`. GET /bookings/freebusy
 
+**message**(collectionId: string, appId: string, input: MessageBookersInput) → `Promise<MessageBookersResult>`
+Message the people booked (admin): a template to everyone on a slot, or everyone booked in a date range (optionally with one person / room), each send hydrated with their booking ({{ booking }}). No segment to make. POST /bookings/message
+
 ### bookings.blocks
 
 **create**(collectionId: string, appId: string, input: CreateBlockInput) → `Promise<BookingAllocation>`

package/docs/bookings.md

@@ -324,8 +324,80 @@ Recorded after each write commits, for flows and app functions (`trigger: { type
 `booking.no_show`, `booking.hold_expired`, `slot.full`, `slot.place_freed` (for waitlist promotion).
 Context: `{ appId, status, slotIds }` (bookings) / `{ appId, remaining }` (slots).
 
-Reminders before a booking (`booking.starts_in`) are coming; until then, use a cron function that lists
-upcoming bookings.
+Reminders before a booking (`booking.starts_in`) are coming; until then, send a reminder template to
+tomorrow's bookers with `bookings.message` (below) from a cron function.
+
+---
+
+## Confirmations and messages
+
+Nothing is emailed by default: your app decides what goes out, in **flows on booking events**, with
+**templates the business can reword in Studio** (Comms → Templates). The platform does the sending,
+the hydration and the consent.
+
+### Flows on booking events
+
+A site, or an app on behalf of a business, sets them up through the cloud blueprint
+(`cloud/flows.json` in a site; `POST /admin/collection/:cId/blueprint/apply` with
+`{ appId, blueprint: { templates, flows } }` from an app's admin screen). Additive: re-applying never
+removes what is there, and a template edited in Studio keeps its edits unless the blueprint sends new
+wording.
+
+```json
+{
+  "templates": {
+    "booking-confirmed": { "name": "You're booked", "email": { "subject": "{{ booking.serviceName }} on {{ booking.when.date }}", "body": "<p>Hi {{ contact.firstName }}, see you at {{ booking.when.time }}.</p>" }, "sms": { "body": "Booked: {{ booking.when.shortDate }} {{ booking.when.time }}" } },
+    "booking-requested": { "name": "Request received", "email": { "subject": "We got your request", "body": "<p>We'll confirm shortly.</p>" } },
+    "staff-new-booking": { "name": "You've been booked", "email": { "subject": "New appointment", "body": "<p>{{ booking.customer.name }}, {{ booking.when.dateTime }}</p>" } }
+  },
+  "flows": [
+    { "when": { "event": "booking.confirmed" }, "do": [{ "send": "booking-confirmed", "to": "contact" }, { "send": "staff-new-booking", "to": "resource" }, { "send": "team-new-booking", "to": "team" }] },
+    { "when": { "event": "booking.created", "status": "pending" }, "do": [{ "send": "booking-requested", "to": "contact" }] }
+  ]
+}
+```
+
+- `when.event`: `booking.created` / `confirmed` / `cancelled` / `moved` / `completed` / `no_show` /
+  `hold_expired`, `slot.full` / `slot.place_freed`; `when.status` narrows to the booking's status at the
+  time (`"pending"` for "request received").
+- `to`: `contact` — the booker, by their preferred channel (`channel` to force one; a template needs an
+  `sms` part to go by text); `team` — the collection's team addresses; `resource` — the booked
+  person or room: a resource that is a contact, or a record with `data.email` / `data.contactId`.
+  A **public** resource record (a staff profile the booking page lists) keeps its address on a
+  **private child record** instead (`visibility: 'admin'`, `parentType: 'record'`, `parentId` = the
+  resource) — the platform looks there too, and the address never ships with the public listing.
+- Who gets what, in templates: `{{ booking }}` is the booking **ready-formatted**: its fields and
+  `data`, plus `serviceName`, `staffName`, `customer`, `durationMinutes`, `when` (`date`,
+  `shortDate`, `time`, `endTime`, `dateTime`, `timezone` — in the business's timezone) and, when the
+  recipient's timezone is known and differs, `whenFor` (the same in theirs); `editToken` only when the
+  recipient is the booker (a guest's manage link). `{{ contact }}` is the recipient; `{{ appConfig }}`
+  the app's public config (a booking page's address, the business name) for sends to the contact.
+
+### Who is reachable
+
+A **guest** who books with an email or phone gets a **contact** (found by that identity or made,
+filling only empty fields: a form's details never overwrite a known contact), and so does a customer
+**staff book in by hand** (`customer: { name, email, phone }` on the body or in `data`). Admin
+creates may pass `contactId` instead. A booking with no contact gets no messages: show the booker why
+an email is worth giving.
+
+### Messaging everyone booked — `bookings.message`
+
+No list to build, no segment to save: send a template to everyone on a slot, or everyone booked in a
+window (optionally with one resource), each hydrated with **their own** booking.
+
+```ts
+// Everyone on tomorrow's 10:00 class
+await SL.bookings.message(collectionId, appId, { templateId, slotId })
+// Everyone booked with Sam next week, by email even if they prefer texts
+await SL.bookings.message(collectionId, appId, { templateId, channel: 'email', from, to, resourceType: 'record', resourceId: samId })
+// → { matched, sent, skipped: { noContact, duplicate, failed }, failures: [{ bookingId, reason }] }
+```
+
+Statuses default to held, pending and confirmed; at most 500 recipients per call (narrow the window
+for more). One message per contact on a slot, one per booking in a window. Also
+`ctx.sl.bookings.message(input)` in a server function (`sl:bookings:write`) — a cron function that
+messages tomorrow's bookers is a reminder system in five lines.
 
 ---
 
@@ -343,6 +415,7 @@ All take `(collectionId, appId, …)`; `admin` is the last parameter where both
 | `bookings.confirm / cancel / move(…, admin?, { editToken }?)` | ✓ | per `ownerActions.bookings` |
 | `bookings.extendHold / complete / noShow` | ✓ | — |
 | `bookings.freebusy(q, admin?)` | ✓ | if `publicRead.bookings.freebusy` |
+| `bookings.message(input)` | ✓ | — |
 | `bookings.slots.create / createMany / update / remove` | ✓ | — |
 | `bookings.slots.list / get(…, admin?)` | ✓ | open, public slots |
 | `bookings.blocks.create / list / remove` | ✓ | — |

package/docs/server-functions.md

@@ -517,7 +517,7 @@ Prefer the platform primitives above over a dependency; when you do need one, pi
 | Check a tapped tag is real | `ctx.sl.tags.resolve(proofId)` → `{ id, claimSetId, code }` or `null` | `sl:tags:read` |
 | Put a visitor's details on a contact | `ctx.sl.contacts.upsert({ email, firstName, … })` → `{ contactId, created }` (fills empty fields only) | `sl:contacts:write` |
 | Record "they did X" | `ctx.sl.interactions.record({ interactionId, contactId, outcome, metadata })` | `sl:interactions:write` |
-| Take a booking with your own checks (hours, queue token, payment) | `ctx.sl.bookings.create({ slotId \| resource + time, contactId, status, idempotencyKey })` — never oversold, never double-booked; also `confirm` / `cancel` / `move` / `mine` / `freebusy` / `slots.*` / `blocks.*` (see [bookings.md](bookings.md)) | `sl:bookings:write` (`sl:bookings:read` to read) |
+| Take a booking with your own checks (hours, queue token, payment) | `ctx.sl.bookings.create({ slotId \| resource + time, contactId, status, idempotencyKey })` — never oversold, never double-booked; also `confirm` / `cancel` / `move` / `mine` / `freebusy` / `message` (everyone booked, hydrated) / `slots.*` / `blocks.*` (see [bookings.md](bookings.md)) | `sl:bookings:write` (`sl:bookings:read` to read) |
 
 Notes:
 - **Talking to the SmartLinks core is `ctx.sl`, not HTTP.** The common pattern — *validate /
@@ -636,6 +636,18 @@ try {
 }
 ```
 
+`ctx.sl.bookings.message({ templateId, slotId | from, to, resourceType?, resourceId?, channel? })` sends a
+template to everyone booked (each hydrated with their own booking) — the five-line reminder cron:
+
+```ts
+// manifest: { name: 'remind', trigger: { type: 'cron', schedule: '0 17 * * *' }, capabilities: ['sl:bookings:write'] }
+export async function remind(ctx) {
+  const from = new Date(); from.setDate(from.getDate() + 1); from.setHours(0, 0, 0, 0)
+  const to = new Date(from); to.setDate(to.getDate() + 1)
+  return ctx.sl.bookings.message({ templateId: 'bp.' + ctx.collectionId + '.reminder', from, to })
+}
+```
+
 The local harness runs bookings in memory with the same rules (capacity, per-person limits, no
 overlaps, idempotency, holds): `ctx.memory.bookings`.
 

package/openapi.yaml

@@ -10291,6 +10291,32 @@ paths:
           description: Unauthorized
         404:
           description: Not found
+  /message:
+    post:
+      tags:
+        - bookings
+      summary: "Message the people booked (admin): a template to everyone on a slot, or everyone booked in a date range (optionally with one person / room), each send hydrated with their booking ({{ booking }})."
+      operationId: bookings_message
+      security: []
+      responses:
+        200:
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/MessageBookersResult"
+        400:
+          description: Bad request
+        401:
+          description: Unauthorized
+        404:
+          description: Not found
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/MessageBookersInput"
   /platform/location:
     post:
       tags:
@@ -24706,6 +24732,62 @@ components:
         - from
         - to
         - resources
+    MessageBookersInput:
+      type: object
+      properties:
+        templateId:
+          type: string
+        channel:
+          type: string
+          enum:
+            - email
+            - sms
+            - whatsapp
+            - push
+            - preferred
+        props:
+          type: object
+          additionalProperties: true
+        slotId:
+          type: string
+        from:
+          type: object
+          additionalProperties: true
+        to:
+          type: object
+          additionalProperties: true
+        resourceType:
+          type: string
+        resourceId:
+          type: string
+        statuses:
+          type: array
+          items:
+            $ref: "#/components/schemas/BookingStatus"
+        ref:
+          type: string
+      required:
+        - templateId
+    MessageBookersResult:
+      type: object
+      properties:
+        matched:
+          type: number
+        sent:
+          type: number
+        skipped:
+          type: object
+          additionalProperties: true
+        failures:
+          type: array
+          items:
+            type: object
+            additionalProperties: true
+      required:
+        - matched
+        - sent
+        - skipped
+        - failures
     BookingAccessOptions:
       type: object
       properties:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proveanything/smartlinks",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "description": "Official JavaScript/TypeScript SDK for the Smartlinks API",
   "type": "module",
   "main": "dist/index.js",