@fayz-ai/plugin-agenda 0.2.1 → 0.3.0

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkGAJVIEXM_cjs = require('./chunk-GAJVIEXM.cjs');
+var chunkLFUELUIT_cjs = require('./chunk-LFUELUIT.cjs');
 var chunkSYDBDI3Q_cjs = require('./chunk-SYDBDI3Q.cjs');
 var React12 = require('react');
 var core = require('@fayz-ai/core');
@@ -1726,8 +1726,8 @@ function AppointmentModal({ open, mode, bookingId, prefill, initialTab, external
           onCancel: () => setClientEditing(false),
           onSubmit: async (data) => {
             try {
-              const { getSupabaseClientOptional: getSupabaseClientOptional3 } = await import('@fayz-ai/core');
-              const supabase = getSupabaseClientOptional3();
+              const { getSupabaseClientOptional: getSupabaseClientOptional4 } = await import('@fayz-ai/core');
+              const supabase = getSupabaseClientOptional4();
               if (!supabase) return;
               const dbData = {};
               for (const [k, v] of Object.entries(data)) {
@@ -1888,10 +1888,10 @@ function AppointmentModal({ open, mode, bookingId, prefill, initialTab, external
                     onClick: async () => {
                       setCreatingClient(true);
                       try {
-                        const { getSupabaseClientOptional: getSupabaseClientOptional3 } = await import('@fayz-ai/core');
-                        const { getAgendaTenantId } = await import('./tenant-222EHYUC.cjs');
-                        const supabase = getSupabaseClientOptional3();
-                        const tenantId = getAgendaTenantId();
+                        const { getSupabaseClientOptional: getSupabaseClientOptional4 } = await import('@fayz-ai/core');
+                        const { getAgendaTenantId: getAgendaTenantId2 } = await import('./tenant-222EHYUC.cjs');
+                        const supabase = getSupabaseClientOptional4();
+                        const tenantId = getAgendaTenantId2();
                         if (!supabase || !tenantId) throw new Error("Not initialized");
                         const { data: personRow, error: personError } = await supabase.schema("saas_core").from("persons").insert({
                           tenant_id: tenantId,
@@ -3473,6 +3473,448 @@ function AgendaPage({ config, provider: provider2, store }) {
   }, [tenantId]);
   return /* @__PURE__ */ jsxRuntime.jsx(AgendaContextProvider, { config, provider: provider2, store, children: /* @__PURE__ */ jsxRuntime.jsx(CalendarView, {}) });
 }
+function getTenantId() {
+  return chunkSYDBDI3Q_cjs.getAgendaTenantId() ?? core.getActiveTenantId();
+}
+function snakeToCamel(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    result[key.replace(/_([a-z])/g, (_, c) => c.toUpperCase())] = value;
+  }
+  return result;
+}
+function getClients() {
+  const supabase = core.getSupabaseClientOptional();
+  if (!supabase) throw new Error("Supabase not initialized");
+  return { core: supabase.schema("saas_core"), pub: supabase };
+}
+function mapBooking(row) {
+  return snakeToCamel(row);
+}
+function mapSchedule(row) {
+  return snakeToCamel(row);
+}
+function addMinutes(iso, minutes) {
+  const d = new Date(iso);
+  d.setMinutes(d.getMinutes() + minutes);
+  return d.toISOString();
+}
+function unique(values) {
+  return Array.from(new Set(values.filter((value) => !!value)));
+}
+function indexById(rows) {
+  return new Map((rows ?? []).filter((row) => row?.id).map((row) => [row.id, row]));
+}
+function groupBy(rows, getKey) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = getKey(row);
+    if (!key) continue;
+    grouped.set(key, [...grouped.get(key) ?? [], row]);
+  }
+  return grouped;
+}
+function getDurationMinutes(startsAt, endsAt) {
+  if (!endsAt) return null;
+  return Math.round((new Date(endsAt).getTime() - new Date(startsAt).getTime()) / 6e4);
+}
+function mergeBookings(viewBookings, canonicalBookings) {
+  const canonicalIds = new Set(canonicalBookings.map((booking) => booking.id));
+  const canonicalOrderIds = new Set(canonicalBookings.map((booking) => booking.orderId).filter(Boolean));
+  const merged = [
+    ...canonicalBookings,
+    ...viewBookings.filter((booking) => {
+      if (canonicalIds.has(booking.id)) return false;
+      if (booking.orderId && canonicalOrderIds.has(booking.orderId)) return false;
+      if (canonicalOrderIds.has(booking.id)) return false;
+      return true;
+    })
+  ];
+  return merged.sort((a, b) => new Date(a.startsAt).getTime() - new Date(b.startsAt).getTime());
+}
+async function hydrateCanonicalBookings(core, bookings) {
+  const personIds = unique(bookings.flatMap((booking) => [booking.party_id, booking.assignee_id]));
+  const locationIds = unique(bookings.map((booking) => booking.location_id));
+  const orderIds = unique(bookings.map((booking) => booking.order_id));
+  unique(bookings.map((booking) => booking.id));
+  const [
+    { data: persons, error: personsError },
+    { data: locations, error: locationsError },
+    { data: orders, error: ordersError },
+    { data: items, error: itemsError }
+  ] = await Promise.all([
+    personIds.length ? core.from("persons").select("id, name, phone, email, avatar_url").in("id", personIds) : Promise.resolve({ data: [], error: null }),
+    locationIds.length ? core.from("locations").select("id, name").in("id", locationIds) : Promise.resolve({ data: [], error: null }),
+    orderIds.length ? core.from("orders").select("id, total, status").in("id", orderIds) : Promise.resolve({ data: [], error: null }),
+    orderIds.length ? core.from("order_items").select("id, order_id, service_id, name, duration_minutes, unit_price, assignee_id, sort_order").in("order_id", orderIds) : Promise.resolve({ data: [], error: null })
+  ]);
+  if (personsError) throw personsError;
+  if (locationsError) throw locationsError;
+  if (ordersError) throw ordersError;
+  if (itemsError) throw itemsError;
+  const personsById = indexById(persons);
+  const locationsById = indexById(locations);
+  const ordersById = indexById(orders);
+  const itemsByOrderId = groupBy(items ?? [], (item) => item.order_id);
+  return bookings.map((booking) => {
+    const client = booking.party_id ? personsById.get(booking.party_id) : null;
+    const professional = booking.assignee_id ? personsById.get(booking.assignee_id) : null;
+    const location = booking.location_id ? locationsById.get(booking.location_id) : null;
+    const order = booking.order_id ? ordersById.get(booking.order_id) : null;
+    const bookingItems = ((booking.order_id ? itemsByOrderId.get(booking.order_id) : null) ?? []).sort((a, b) => (a.sort_order ?? 0) - (b.sort_order ?? 0)).map((item) => ({
+      id: item.id,
+      serviceId: item.service_id,
+      name: item.name,
+      durationMinutes: item.duration_minutes,
+      price: item.unit_price,
+      assigneeId: item.assignee_id
+    }));
+    const itemDuration = bookingItems.reduce((sum, item) => sum + (item.durationMinutes ?? 0), 0);
+    return {
+      id: booking.id,
+      tenantId: booking.tenant_id,
+      kind: booking.kind,
+      startsAt: booking.starts_at,
+      endsAt: booking.ends_at,
+      status: booking.status,
+      notes: booking.notes,
+      orderId: booking.order_id,
+      locationId: booking.location_id,
+      metadata: booking.metadata ?? {},
+      clientId: booking.party_id,
+      // Simple events (no party) fall back to the title stored in metadata.
+      clientName: client?.name ?? booking.metadata?.title ?? null,
+      clientPhone: client?.phone ?? null,
+      clientEmail: client?.email ?? null,
+      clientAvatarUrl: client?.avatar_url ?? null,
+      professionalId: booking.assignee_id,
+      professionalName: professional?.name ?? null,
+      professionalAvatarUrl: professional?.avatar_url ?? null,
+      locationName: location?.name ?? null,
+      orderTotal: order?.total ?? null,
+      orderStatus: order?.status ?? null,
+      services: bookingItems.length ? bookingItems : null,
+      totalDurationMinutes: itemDuration || getDurationMinutes(booking.starts_at, booking.ends_at),
+      createdAt: booking.created_at,
+      updatedAt: booking.updated_at
+    };
+  });
+}
+async function getCanonicalBookings(core, query) {
+  let q = core.from("bookings").select("id, tenant_id, kind, starts_at, ends_at, status, notes, order_id, location_id, metadata, party_id, assignee_id, created_at, updated_at").gte("starts_at", query.dateRange.start).lte("starts_at", query.dateRange.end);
+  if (query.kind) q = q.eq("kind", query.kind);
+  if (query.statuses?.length) q = q.in("status", query.statuses);
+  if (query.professionalIds?.length) q = q.in("assignee_id", query.professionalIds);
+  if (query.locationId) q = q.eq("location_id", query.locationId);
+  const { data, error } = await q.order("starts_at", { ascending: true });
+  if (error) throw error;
+  return hydrateCanonicalBookings(core, data ?? []);
+}
+async function getCanonicalBookingById(core, id) {
+  const columns = "id, tenant_id, kind, starts_at, ends_at, status, notes, order_id, location_id, metadata, party_id, assignee_id, created_at, updated_at";
+  let { data, error } = await core.from("bookings").select(columns).eq("id", id).maybeSingle();
+  if (error) throw error;
+  if (!data) {
+    const fallback = await core.from("bookings").select(columns).eq("order_id", id).maybeSingle();
+    if (fallback.error) throw fallback.error;
+    data = fallback.data;
+  }
+  if (!data) return null;
+  const [booking] = await hydrateCanonicalBookings(core, [data]);
+  return booking ?? null;
+}
+function createSupabaseAgendaProvider() {
+  return {
+    // v_bookings is in public schema (PostgREST default)
+    async getBookings(query) {
+      const { core, pub } = getClients();
+      let q = pub.from("v_bookings").select("*").gte("starts_at", query.dateRange.start).lte("starts_at", query.dateRange.end);
+      if (query.kind) q = q.eq("kind", query.kind);
+      if (query.statuses?.length) q = q.in("status", query.statuses);
+      if (query.professionalIds?.length) q = q.in("professional_id", query.professionalIds);
+      if (query.locationId) q = q.eq("location_id", query.locationId);
+      q = q.order("starts_at", { ascending: true });
+      const { data, error } = await q;
+      if (error) throw error;
+      const viewBookings = (data ?? []).map(mapBooking);
+      const canonicalBookings = await getCanonicalBookings(core, query);
+      return mergeBookings(viewBookings, canonicalBookings);
+    },
+    async getBookingById(id) {
+      const { core, pub } = getClients();
+      const { data, error } = await pub.from("v_bookings").select("*").eq("id", id).maybeSingle();
+      if (error) throw error;
+      if (data) return mapBooking(data);
+      return getCanonicalBookingById(core, id);
+    },
+    async createBooking(input) {
+      const { core } = getClients();
+      const tenantId = getTenantId();
+      if (!tenantId) throw new Error("No active tenant");
+      const hasServices = input.services.length > 0;
+      const totalDuration = input.services.reduce((sum, s) => sum + s.durationMinutes, 0);
+      const totalPrice = input.services.reduce((sum, s) => sum + s.price, 0);
+      const endsAt = addMinutes(input.startsAt, totalDuration || 30);
+      const serviceNames = input.services.map((s) => s.name).join(", ");
+      let contactName;
+      if (input.clientId) {
+        const { data: person } = await core.from("persons").select("name").eq("id", input.clientId).single();
+        contactName = person?.name;
+      }
+      const eventTitle = input.title?.trim() || void 0;
+      const { data: order, error: orderErr } = await core.from("orders").insert({
+        tenant_id: tenantId,
+        kind: input.kind ?? "appointment",
+        status: "scheduled",
+        party_id: input.clientId || null,
+        assignee_id: input.professionalId,
+        location_id: input.locationId ?? null,
+        subtotal: totalPrice,
+        total: totalPrice,
+        notes: input.notes ?? null,
+        metadata: {
+          source: "agenda",
+          ...serviceNames ? { serviceNames, itemsSummary: serviceNames } : {},
+          ...contactName ? { contactName } : {},
+          ...eventTitle ? { title: eventTitle } : {}
+        }
+      }).select("id").single();
+      if (orderErr) throw orderErr;
+      const { data: booking, error: bookingErr } = await core.from("bookings").insert({
+        tenant_id: tenantId,
+        kind: input.kind ?? "appointment",
+        party_id: input.clientId || null,
+        assignee_id: input.professionalId,
+        location_id: input.locationId ?? null,
+        order_id: order.id,
+        starts_at: input.startsAt,
+        ends_at: endsAt,
+        status: "scheduled",
+        notes: input.notes ?? null,
+        metadata: {
+          source: "agenda",
+          ...serviceNames ? { serviceNames, itemsSummary: serviceNames } : {},
+          ...contactName ? { contactName } : {},
+          ...eventTitle ? { title: eventTitle } : {}
+        }
+      }).select("id").single();
+      if (bookingErr) throw bookingErr;
+      if (hasServices) {
+        const orderItems = input.services.map((s, i) => ({
+          order_id: order.id,
+          service_id: s.serviceId,
+          name: s.name,
+          quantity: 1,
+          unit_price: s.price,
+          total: s.price,
+          sort_order: i,
+          duration_minutes: s.durationMinutes,
+          assignee_id: s.assigneeId ?? input.professionalId
+        }));
+        const { error: oiErr } = await core.from("order_items").insert(orderItems);
+        if (oiErr) throw oiErr;
+      }
+      const createdBooking = await this.getBookingById(booking.id);
+      if (!createdBooking) throw new Error("Created booking did not resolve from agenda read model");
+      return createdBooking;
+    },
+    async updateBooking(id, data) {
+      const { core } = getClients();
+      const { data: existing, error: existingErr } = await core.from("bookings").select("id, order_id, starts_at, assignee_id, metadata").eq("id", id).single();
+      if (existingErr) throw existingErr;
+      const updates = {};
+      if (data.startsAt) updates.starts_at = data.startsAt;
+      if (data.endsAt) updates.ends_at = data.endsAt;
+      if (data.title !== void 0) {
+        updates.metadata = { ...existing?.metadata ?? {}, title: data.title };
+      }
+      if (data.status) {
+        updates.status = data.status;
+      }
+      if (data.notes !== void 0) updates.notes = data.notes;
+      if (data.professionalId) updates.assignee_id = data.professionalId;
+      if (data.clientId) updates.party_id = data.clientId;
+      if (data.locationId) updates.location_id = data.locationId;
+      if (data.services) {
+        const totalDuration = data.services.reduce((s, svc) => s + svc.durationMinutes, 0);
+        data.services.reduce((s, svc) => s + svc.price, 0);
+        const startsAt = data.startsAt ?? existing?.starts_at;
+        if (startsAt) {
+          const ends = new Date(new Date(startsAt).getTime() + totalDuration * 6e4);
+          updates.ends_at = ends.toISOString();
+        }
+      }
+      const effectiveAssigneeId = data.professionalId ?? existing?.assignee_id ?? null;
+      const { error } = await core.from("bookings").update(updates).eq("id", id);
+      if (error) throw error;
+      const orderId = existing?.order_id;
+      if (orderId) {
+        const orderUpdates = {};
+        if (data.notes !== void 0) orderUpdates.notes = data.notes;
+        if (data.professionalId) orderUpdates.assignee_id = data.professionalId;
+        if (data.clientId) orderUpdates.party_id = data.clientId;
+        if (data.locationId) orderUpdates.location_id = data.locationId;
+        if (data.services) {
+          const totalPrice = data.services.reduce((s, svc) => s + svc.price, 0);
+          orderUpdates.subtotal = totalPrice;
+          orderUpdates.total = totalPrice;
+        }
+        if (Object.keys(orderUpdates).length > 0) {
+          const { error: orderErr } = await core.from("orders").update(orderUpdates).eq("id", orderId);
+          if (orderErr) throw orderErr;
+        }
+        if (data.services) {
+          await core.from("order_items").delete().eq("order_id", orderId);
+          if (data.services.length > 0) {
+            const items = data.services.map((svc, idx) => ({
+              order_id: orderId,
+              service_id: svc.serviceId || null,
+              name: svc.name,
+              quantity: 1,
+              unit_price: svc.price,
+              total: svc.price,
+              sort_order: idx,
+              duration_minutes: svc.durationMinutes,
+              assignee_id: svc.assigneeId ?? effectiveAssigneeId
+            }));
+            const { error: itemErr } = await core.from("order_items").insert(items);
+            if (itemErr) throw itemErr;
+          }
+        }
+      }
+      return await this.getBookingById(id);
+    },
+    async deleteBooking(id) {
+      const { core, pub } = getClients();
+      const { data: booking, error: bookingErr } = await core.from("bookings").select("order_id").eq("id", id).single();
+      if (bookingErr) throw bookingErr;
+      const orderId = booking?.order_id;
+      const { count, error: movementErr } = orderId ? await pub.from("financial_movements").select("id", { count: "exact", head: true }).eq("invoice_id", orderId) : { count: 0, error: null };
+      if (movementErr) throw movementErr;
+      if (orderId && (count ?? 0) > 0) {
+        await pub.from("financial_movements").update({ status: "cancelled" }).eq("invoice_id", orderId);
+        await core.from("orders").update({ status: "cancelled" }).eq("id", orderId);
+        const { error } = await core.from("bookings").update({ status: "cancelled" }).eq("id", id);
+        if (error) throw error;
+      } else {
+        if (orderId) {
+          await pub.from("financial_movements").delete().eq("invoice_id", orderId);
+        }
+        const { error } = await core.from("bookings").delete().eq("id", id);
+        if (error) throw error;
+        if (orderId) {
+          const { error: orderErr } = await core.from("orders").delete().eq("id", orderId);
+          if (orderErr) throw orderErr;
+        }
+      }
+    },
+    async updateBookingStatus(id, status) {
+      return this.updateBooking(id, { status });
+    },
+    async checkConflict(params) {
+      const { core } = getClients();
+      let q = core.from("bookings").select("id", { count: "exact", head: true }).eq("assignee_id", params.assigneeId).eq("kind", "appointment").not("status", "in", '("cancelled","no_show")').not("starts_at", "is", null).lt("starts_at", params.endsAt).gt("ends_at", params.startsAt);
+      if (params.excludeBookingId) {
+        q = q.neq("id", params.excludeBookingId);
+      }
+      const { count, error } = await q;
+      if (error) throw error;
+      return (count ?? 0) > 0;
+    },
+    async getAvailableSlots(params) {
+      const { pub } = getClients();
+      const { data, error } = await pub.rpc("get_available_slots", {
+        p_tenant_id: getTenantId(),
+        p_assignee_id: params.assigneeId,
+        p_date: params.date,
+        p_duration_minutes: params.durationMinutes,
+        p_slot_interval: params.slotInterval ?? 30
+      });
+      if (error) throw error;
+      return (data ?? []).map((row) => ({ start: row.slot_start, end: row.slot_end }));
+    },
+    async getSchedules(professionalId) {
+      const { core } = getClients();
+      let q = core.from("schedules").select("*").eq("kind", "working_hours");
+      if (professionalId) q = q.eq("assignee_id", professionalId);
+      q = q.order("day_of_week").order("starts_at");
+      const { data, error } = await q;
+      if (error) throw error;
+      return (data ?? []).map(mapSchedule);
+    },
+    async saveSchedule(input) {
+      const { core } = getClients();
+      const tenantId = getTenantId();
+      if (!tenantId) throw new Error("No active tenant");
+      const { data, error } = await core.from("schedules").insert({
+        tenant_id: tenantId,
+        kind: "working_hours",
+        assignee_id: input.assigneeId,
+        location_id: input.locationId ?? null,
+        day_of_week: input.dayOfWeek ?? null,
+        specific_date: input.specificDate ?? null,
+        starts_at: input.startsAt,
+        ends_at: input.endsAt,
+        is_active: input.isActive !== false,
+        metadata: input.metadata ?? {}
+      }).select("*").single();
+      if (error) throw error;
+      return mapSchedule(data);
+    },
+    async deleteSchedule(id) {
+      const { core } = getClients();
+      const { error } = await core.from("schedules").delete().eq("id", id);
+      if (error) throw error;
+    },
+    async getProfessionals() {
+      const { core } = getClients();
+      const { data, error } = await core.from("persons").select("id, name, avatar_url, is_active").eq("kind", "staff").eq("is_active", true).order("name");
+      if (error) throw error;
+      return (data ?? []).map((p) => ({
+        id: p.id,
+        name: p.name,
+        avatarUrl: p.avatar_url,
+        locationId: null,
+        locationName: null,
+        isActive: p.is_active
+      }));
+    },
+    async getLocations() {
+      const { core } = getClients();
+      const { data, error } = await core.from("locations").select("id, name").eq("is_active", true).order("name");
+      if (error) throw error;
+      return (data ?? []).map((l) => ({ id: l.id, name: l.name }));
+    },
+    async getConfirmationsPending(daysAhead = 2) {
+      const { pub } = getClients();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const cutoff = /* @__PURE__ */ new Date();
+      cutoff.setDate(cutoff.getDate() + daysAhead);
+      const { data, error } = await pub.from("v_bookings").select("*").eq("status", "scheduled").gte("starts_at", now).lte("starts_at", cutoff.toISOString()).order("starts_at");
+      if (error) throw error;
+      return (data ?? []).map(mapBooking);
+    },
+    async sendConfirmation(bookingId, channel) {
+      const { core } = getClients();
+      const { data: booking } = await core.from("bookings").select("metadata").eq("id", bookingId).single();
+      const metadata = booking?.metadata ?? {};
+      const confirmations = metadata.confirmations ?? [];
+      confirmations.push({ channel, sentAt: (/* @__PURE__ */ new Date()).toISOString(), status: "sent" });
+      await core.from("bookings").update({ metadata: { ...metadata, confirmations } }).eq("id", bookingId);
+    },
+    async completeBooking(bookingId) {
+      const { core } = getClients();
+      const { data: existing, error: existingErr } = await core.from("bookings").select("order_id").eq("id", bookingId).single();
+      if (existingErr) throw existingErr;
+      const { error } = await core.from("bookings").update({ status: "completed" }).eq("id", bookingId);
+      if (error) throw error;
+      const orderId = existing?.order_id;
+      const booking = await this.getBookingById(bookingId);
+      if (!booking) throw new Error("Booking not found");
+      return { booking, orderId: orderId ?? bookingId };
+    }
+  };
+}
 function getCurrentBookingQuery(state, dateRange = state.dateRange) {
   return {
     dateRange,
@@ -4221,6 +4663,287 @@ var agendaLocales = {
   en,
   "pt-BR": ptBR
 };
+
+// src/migrations/index.ts
+var MIGRATION_001_PUBLIC_BOOKING = `-- ============================================================================
+-- plugin-agenda 001: booking read model + public (anon) booking surface
+--
+-- Ships the objects the agenda providers reference but the spine (packages/db
+-- migrations 001\u2013008) does not define:
+--   \xA71  order_items columns the admin provider writes (duration/assignee)
+--   \xA72  public.v_bookings        \u2014 admin read model (authenticated, RLS applies)
+--   \xA73  public.v_public_services \u2014 anon-readable service catalog
+--   \xA74  public.get_available_slots      \u2014 anon RPC (mirrors the mock algorithm)
+--   \xA75  public.create_public_booking    \u2014 anon RPC (validated, race-safe write)
+--
+-- Anon-access design: public booking pages run with the publishable key and no
+-- session, so the canonical tenant RLS yields nothing. Anon access is granted
+-- ONLY via the column-whitelisted view (\xA73) and SECURITY DEFINER RPCs (\xA74, \xA75)
+-- with tight input validation and hardcoded statuses.
+-- ============================================================================
+
+-- \xA71 \u2014 columns the agenda provider writes but 004_archetypes lacks
+ALTER TABLE saas_core.order_items
+  ADD COLUMN IF NOT EXISTS duration_minutes integer,
+  ADD COLUMN IF NOT EXISTS assignee_id uuid REFERENCES saas_core.persons(id) ON DELETE SET NULL;
+
+-- Upsert key for public customers (per tenant, by normalized phone)
+CREATE UNIQUE INDEX IF NOT EXISTS persons_tenant_customer_phone
+  ON saas_core.persons(tenant_id, phone)
+  WHERE kind = 'customer' AND phone IS NOT NULL;
+
+-- Slot-conflict scan
+CREATE INDEX IF NOT EXISTS bookings_assignee_time
+  ON saas_core.bookings(assignee_id, starts_at, ends_at)
+  WHERE status NOT IN ('cancelled', 'no_show');
+
+-- \xA72 \u2014 admin read model (security_invoker \u2192 underlying RLS applies; anon sees 0 rows)
+CREATE OR REPLACE VIEW public.v_bookings
+WITH (security_invoker = true) AS
+SELECT
+  b.id, b.tenant_id, b.kind, b.starts_at, b.ends_at, b.status, b.notes,
+  b.order_id, b.location_id, b.metadata, b.created_at, b.updated_at,
+  b.party_id                              AS client_id,
+  COALESCE(pc.name, b.metadata->>'title') AS client_name,
+  pc.phone                                AS client_phone,
+  pc.email                                AS client_email,
+  pc.avatar_url                           AS client_avatar_url,
+  b.assignee_id                           AS professional_id,
+  ps.name                                 AS professional_name,
+  ps.avatar_url                           AS professional_avatar_url,
+  l.name                                  AS location_name,
+  o.total                                 AS order_total,
+  o.status                                AS order_status,
+  (EXTRACT(EPOCH FROM (COALESCE(b.ends_at, b.starts_at) - b.starts_at))::int / 60)
+                                          AS total_duration_minutes
+FROM saas_core.bookings b
+LEFT JOIN saas_core.persons   pc ON pc.id = b.party_id
+LEFT JOIN saas_core.persons   ps ON ps.id = b.assignee_id
+LEFT JOIN saas_core.locations l  ON l.id  = b.location_id
+LEFT JOIN saas_core.orders    o  ON o.id  = b.order_id;
+
+GRANT SELECT ON public.v_bookings TO authenticated, service_role;
+REVOKE SELECT ON public.v_bookings FROM anon;
+
+-- \xA73 \u2014 anon-readable public catalog (owner-rights view = deliberate, whitelisted)
+CREATE OR REPLACE VIEW public.v_public_services AS
+SELECT
+  s.id, s.tenant_id, s.name, s.description, s.price, s.currency,
+  COALESCE(s.duration_minutes, 30)                AS duration_minutes,
+  s.image_url,
+  COALESCE((s.metadata->>'sort_order')::int, 0)   AS sort_order
+FROM saas_core.services s
+WHERE s.is_active AND s.status = 'active';
+
+GRANT SELECT ON public.v_public_services TO anon, authenticated, service_role;
+
+-- \xA74 \u2014 availability RPC (mirrors plugin-agenda/src/data/mock.ts getAvailableSlots)
+CREATE OR REPLACE FUNCTION public.get_available_slots(
+  p_tenant_id uuid,
+  p_date date,
+  p_duration_minutes integer,
+  p_assignee_id uuid DEFAULT NULL,
+  p_slot_interval integer DEFAULT 30
+) RETURNS TABLE (slot_start timestamptz, slot_end timestamptz)
+LANGUAGE plpgsql STABLE SECURITY DEFINER
+SET search_path = saas_core, public
+AS $$
+DECLARE
+  v_tz text;
+BEGIN
+  -- tight validation: this function is anon-callable
+  IF p_duration_minutes IS NULL OR p_duration_minutes NOT BETWEEN 5 AND 480 THEN
+    RAISE EXCEPTION 'invalid duration';
+  END IF;
+  IF p_slot_interval IS NULL OR p_slot_interval NOT BETWEEN 5 AND 240 THEN
+    RAISE EXCEPTION 'invalid interval';
+  END IF;
+  IF p_date IS NULL OR p_date < current_date OR p_date > current_date + 90 THEN
+    RETURN;
+  END IF;
+
+  SELECT COALESCE(t.settings->>'timezone', 'America/Sao_Paulo') INTO v_tz
+  FROM tenants t WHERE t.id = p_tenant_id;
+  IF v_tz IS NULL THEN RETURN; END IF;  -- unknown tenant \u2192 empty, not an error
+
+  RETURN QUERY
+  WITH day_schedules AS (
+    SELECT sc.assignee_id, sc.starts_at AS win_start, sc.ends_at AS win_end
+    FROM schedules sc
+    WHERE sc.tenant_id = p_tenant_id
+      AND sc.kind = 'working_hours'
+      AND sc.is_active
+      AND (p_assignee_id IS NULL OR sc.assignee_id = p_assignee_id)
+      AND (
+        sc.specific_date = p_date
+        OR (sc.specific_date IS NULL AND sc.day_of_week = EXTRACT(dow FROM p_date)::smallint)
+      )
+  ),
+  candidate AS (
+    SELECT
+      ds.assignee_id,
+      gs                                              AS s_start,
+      gs + make_interval(mins => p_duration_minutes)  AS s_end
+    FROM day_schedules ds
+    CROSS JOIN LATERAL generate_series(
+      (p_date + ds.win_start) AT TIME ZONE v_tz,
+      ((p_date + ds.win_end) AT TIME ZONE v_tz) - make_interval(mins => p_duration_minutes),
+      make_interval(mins => p_slot_interval)
+    ) AS gs
+  )
+  SELECT DISTINCT c.s_start, c.s_end
+  FROM candidate c
+  WHERE NOT EXISTS (
+    SELECT 1 FROM bookings b
+    WHERE b.tenant_id = p_tenant_id
+      AND b.assignee_id = c.assignee_id
+      AND b.status NOT IN ('cancelled', 'no_show')
+      AND b.starts_at < c.s_end
+      AND COALESCE(b.ends_at, b.starts_at) > c.s_start
+  )
+  ORDER BY 1;
+END;
+$$;
+
+REVOKE ALL ON FUNCTION public.get_available_slots(uuid, date, integer, uuid, integer) FROM public;
+GRANT EXECUTE ON FUNCTION public.get_available_slots(uuid, date, integer, uuid, integer)
+  TO anon, authenticated, service_role;
+
+-- \xA75 \u2014 public booking write RPC (validated, race-safe, hardcoded statuses)
+CREATE OR REPLACE FUNCTION public.create_public_booking(
+  p_tenant_id uuid,
+  p_service_id uuid,
+  p_starts_at timestamptz,
+  p_name text,
+  p_phone text,
+  p_email text DEFAULT NULL,
+  p_notes text DEFAULT NULL
+) RETURNS TABLE (booking_id uuid, starts_at timestamptz, ends_at timestamptz)
+LANGUAGE plpgsql SECURITY DEFINER
+SET search_path = saas_core, public
+AS $$
+DECLARE
+  v_service record;
+  v_person_id uuid;
+  v_assignee uuid;
+  v_ends timestamptz;
+  v_order uuid;
+  v_booking uuid;
+  v_phone text;
+  v_tz text;
+  v_notes text;
+BEGIN
+  -- validation: anon-callable, everything tight
+  IF p_name IS NULL OR length(trim(p_name)) NOT BETWEEN 2 AND 120 THEN
+    RAISE EXCEPTION 'invalid name';
+  END IF;
+  v_phone := regexp_replace(COALESCE(p_phone, ''), '\\D', '', 'g');
+  IF length(v_phone) NOT BETWEEN 8 AND 15 THEN
+    RAISE EXCEPTION 'invalid phone';
+  END IF;
+  IF p_email IS NOT NULL AND (length(p_email) > 254 OR p_email !~ '^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$') THEN
+    RAISE EXCEPTION 'invalid email';
+  END IF;
+  v_notes := left(p_notes, 500);
+  IF p_starts_at IS NULL OR p_starts_at <= now() OR p_starts_at > now() + interval '90 days' THEN
+    RAISE EXCEPTION 'invalid start';
+  END IF;
+
+  SELECT s.id, s.name, s.price, COALESCE(s.duration_minutes, 30) AS duration_minutes
+    INTO v_service
+  FROM services s
+  WHERE s.id = p_service_id AND s.tenant_id = p_tenant_id
+    AND s.is_active AND s.status = 'active';
+  IF NOT FOUND THEN RAISE EXCEPTION 'unknown service'; END IF;
+
+  v_ends := p_starts_at + make_interval(mins => v_service.duration_minutes);
+  SELECT COALESCE(t.settings->>'timezone', 'America/Sao_Paulo') INTO v_tz
+  FROM tenants t WHERE t.id = p_tenant_id;
+  IF v_tz IS NULL THEN RAISE EXCEPTION 'unknown tenant'; END IF;
+
+  -- pick the assignee whose working hours cover the slot
+  SELECT sc.assignee_id INTO v_assignee
+  FROM schedules sc
+  WHERE sc.tenant_id = p_tenant_id
+    AND sc.kind = 'working_hours'
+    AND sc.is_active
+    AND (
+      sc.specific_date = (p_starts_at AT TIME ZONE v_tz)::date
+      OR (sc.specific_date IS NULL
+          AND sc.day_of_week = EXTRACT(dow FROM p_starts_at AT TIME ZONE v_tz)::smallint)
+    )
+    AND (p_starts_at AT TIME ZONE v_tz)::time >= sc.starts_at
+    AND (v_ends AT TIME ZONE v_tz)::time <= sc.ends_at
+  ORDER BY sc.assignee_id
+  LIMIT 1;
+  IF v_assignee IS NULL THEN RAISE EXCEPTION 'slot outside working hours'; END IF;
+
+  -- serialize per (tenant, assignee) to kill the double-book race
+  PERFORM pg_advisory_xact_lock(hashtextextended(p_tenant_id::text || v_assignee::text, 0));
+
+  IF EXISTS (
+    SELECT 1 FROM bookings b
+    WHERE b.tenant_id = p_tenant_id
+      AND b.assignee_id = v_assignee
+      AND b.status NOT IN ('cancelled', 'no_show')
+      AND b.starts_at < v_ends
+      AND COALESCE(b.ends_at, b.starts_at) > p_starts_at
+  ) THEN
+    RAISE EXCEPTION 'slot no longer available';
+  END IF;
+
+  -- anti-spam: cap open future public bookings per phone per tenant
+  IF (
+    SELECT count(*) FROM bookings b
+    JOIN persons p ON p.id = b.party_id
+    WHERE b.tenant_id = p_tenant_id
+      AND p.phone = v_phone
+      AND b.starts_at > now()
+      AND b.status = 'scheduled'
+  ) >= 3 THEN
+    RAISE EXCEPTION 'too many open bookings for this phone';
+  END IF;
+
+  -- upsert the customer by (tenant, phone) \u2014 matches persons_tenant_customer_phone
+  INSERT INTO persons (tenant_id, kind, name, phone, email, metadata)
+  VALUES (p_tenant_id, 'customer', trim(p_name), v_phone, p_email,
+          jsonb_build_object('source', 'public_booking'))
+  ON CONFLICT (tenant_id, phone) WHERE kind = 'customer' AND phone IS NOT NULL
+  DO UPDATE SET
+    name = EXCLUDED.name,
+    email = COALESCE(EXCLUDED.email, persons.email),
+    updated_at = now()
+  RETURNING id INTO v_person_id;
+
+  -- order + booking + order_item (statuses hardcoded \u2014 caller cannot set)
+  INSERT INTO orders (tenant_id, kind, status, party_id, assignee_id, subtotal, total, notes, metadata)
+  VALUES (p_tenant_id, 'appointment', 'scheduled', v_person_id, v_assignee,
+          v_service.price, v_service.price, v_notes,
+          jsonb_build_object('source', 'public_booking',
+                             'serviceNames', v_service.name,
+                             'contactName', trim(p_name)))
+  RETURNING id INTO v_order;
+
+  INSERT INTO bookings (tenant_id, kind, party_id, assignee_id, order_id,
+                        starts_at, ends_at, status, notes, metadata)
+  VALUES (p_tenant_id, 'appointment', v_person_id, v_assignee, v_order,
+          p_starts_at, v_ends, 'scheduled', v_notes,
+          jsonb_build_object('source', 'public_booking', 'serviceNames', v_service.name))
+  RETURNING id INTO v_booking;
+
+  INSERT INTO order_items (order_id, service_id, name, quantity, unit_price, total,
+                           sort_order, duration_minutes, assignee_id)
+  VALUES (v_order, v_service.id, v_service.name, 1, v_service.price, v_service.price,
+          0, v_service.duration_minutes, v_assignee);
+
+  RETURN QUERY SELECT v_booking, p_starts_at, v_ends;
+END;
+$$;
+
+REVOKE ALL ON FUNCTION public.create_public_booking(uuid, uuid, timestamptz, text, text, text, text) FROM public;
+GRANT EXECUTE ON FUNCTION public.create_public_booking(uuid, uuid, timestamptz, text, text, text, text)
+  TO anon, authenticated, service_role;
+`;
 function computeCommissionAmount(total, ratePercent) {
   const base = Number(total) || 0;
   const rate = Number(ratePercent) || 0;
@@ -4635,8 +5358,8 @@ function createAgendaPlugin(options) {
   const config = resolveConfig(options);
   core.registerTranslations(agendaLocales);
   const provider2 = options?.dataProvider ?? core.createSafeDataProvider(
-    () => chunkGAJVIEXM_cjs.createSupabaseAgendaProvider(),
-    () => chunkGAJVIEXM_cjs.createMockAgendaProvider()
+    () => createSupabaseAgendaProvider(),
+    () => chunkLFUELUIT_cjs.createMockAgendaProvider()
   );
   const store = createAgendaStore(provider2, options?.financialBridge);
   const registries = [...agendaRegistries, ...options?.settingsRegistries ?? []];
@@ -4780,13 +5503,21 @@ function createAgendaPlugin(options) {
         permission: { feature: "appointments", action: "read" }
       }
     ],
+    migrations: [
+      {
+        id: "agenda-001-public-booking",
+        version: "0.3.0",
+        sql: MIGRATION_001_PUBLIC_BOOKING,
+        description: "Booking read model (v_bookings) + anon public booking surface (v_public_services, get_available_slots, create_public_booking) + order_items duration/assignee columns"
+      }
+    ],
     locales: agendaLocales
   };
 }
 
 Object.defineProperty(exports, "createMockAgendaProvider", {
   enumerable: true,
-  get: function () { return chunkGAJVIEXM_cjs.createMockAgendaProvider; }
+  get: function () { return chunkLFUELUIT_cjs.createMockAgendaProvider; }
 });
 exports.bookingToEvent = bookingToEvent2;
 exports.computeCommissionAmount = computeCommissionAmount;