@cosmoops/connect-sdk 0.17.0 → 0.19.0

package/dist/cjs/client/components/booking-grid.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zonedInstant = zonedInstant;
+exports.dayColumns = dayColumns;
+exports.dayStartInstant = dayStartInstant;
+exports.layoutBookings = layoutBookings;
+exports.hourMarks = hourMarks;
+/**
+ * An instant, as the local day and minute it lands on in `timeZone`.
+ *
+ * Built from `formatToParts` rather than by adding a fixed offset. An offset
+ * is only correct until a DST boundary, and "add 5.5 hours" is wrong the
+ * moment the same code is pointed at a zone that observes one - which is
+ * exactly the kind of bug that appears twice a year and never in a test.
+ */
+function zonedInstant(instant, timeZone) {
+    const parts = partsFormatter(timeZone).formatToParts(instant);
+    const read = (type) => parts.find((part) => part.type === type)?.value ?? "00";
+    // `hourCycle: "h23"` so midnight is 00 rather than 24 - `hour12: false`
+    // alone still yields 24 in some engines, and a 24 would push midnight onto
+    // the wrong day.
+    return {
+        dateKey: `${read("year")}-${read("month")}-${read("day")}`,
+        minutes: Number(read("hour")) * 60 + Number(read("minute")),
+    };
+}
+const formatterCache = new Map();
+function partsFormatter(timeZone) {
+    let formatter = formatterCache.get(timeZone);
+    if (!formatter) {
+        // Cached because a grid calls this once per booking per render, and
+        // constructing an `Intl.DateTimeFormat` is the expensive part by a wide
+        // margin.
+        formatter = new Intl.DateTimeFormat("en-CA", {
+            timeZone,
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            hourCycle: "h23",
+        });
+        formatterCache.set(timeZone, formatter);
+    }
+    return formatter;
+}
+/**
+ * `count` consecutive days starting at the local day `anchor` falls on.
+ *
+ * Days are stepped by adding 24 hours and re-reading the zone rather than by
+ * incrementing a date field, so a day that is 23 or 25 hours long still
+ * produces the right sequence of `dateKey`s - the midday anchor is what keeps
+ * a DST shift from landing the step on the previous or next day.
+ */
+function dayColumns(anchor, timeZone, count, now) {
+    const todayKey = zonedInstant(now, timeZone).dateKey;
+    const columns = [];
+    for (let index = 0; index < count; index += 1) {
+        const probe = new Date(anchor.getTime() + index * 24 * 60 * 60_000);
+        const { dateKey } = zonedInstant(probe, timeZone);
+        const startsAt = dayStartInstant(dateKey, timeZone);
+        columns.push({
+            dateKey,
+            label: new Intl.DateTimeFormat("en-IN", {
+                timeZone,
+                weekday: "short",
+                day: "numeric",
+            }).format(startsAt),
+            monthLabel: new Intl.DateTimeFormat("en-IN", { timeZone, month: "short" }).format(startsAt),
+            startsAt,
+            isToday: dateKey === todayKey,
+        });
+    }
+    return columns;
+}
+/**
+ * Local midnight of `dateKey` in `timeZone`, as an instant.
+ *
+ * Solved by probing rather than by arithmetic: guess UTC midnight, read what
+ * local time that actually is, and subtract the difference. One correction is
+ * always enough because a zone's offset cannot change within the few hours the
+ * correction spans - and unlike a fixed-offset formula it is right across DST
+ * and for the half-hour zones (`Asia/Kolkata`, `Australia/Adelaide`) that a
+ * naive implementation quietly breaks on.
+ */
+function dayStartInstant(dateKey, timeZone) {
+    const utcGuess = new Date(`${dateKey}T00:00:00.000Z`);
+    const { dateKey: landedOn, minutes } = zonedInstant(utcGuess, timeZone);
+    // Whether the guess landed on the day before, the day itself, or the day
+    // after decides which way to correct.
+    const dayDelta = compareDateKeys(landedOn, dateKey);
+    return new Date(utcGuess.getTime() - (minutes + dayDelta * 1440) * 60_000);
+}
+function compareDateKeys(a, b) {
+    if (a === b)
+        return 0;
+    return a < b ? -1 : 1;
+}
+/**
+ * A fifteen-minute appointment on a twelve-hour grid is two percent tall -
+ * unreadable and unclickable. Short appointments are drawn at a floor and
+ * allowed to overhang, which is what every calendar does and what makes a
+ * back-to-back pair still look like two things.
+ */
+const MIN_VISIBLE_FRACTION = 0.02;
+/**
+ * Places bookings on the grid, side by side where they collide.
+ *
+ * Overlap handling is the part worth stating. Two appointments at the same
+ * time are not an error - a workspace with two hosts has them constantly - and
+ * stacking them would hide one entirely. So overlapping bookings are grouped
+ * into *clusters* and each cluster is split into equal columns. The cluster is
+ * built transitively: A overlapping B and B overlapping C puts all three in one
+ * cluster even when A and C do not touch, because anything else lets two of
+ * them land on the same column.
+ */
+function layoutBookings(bookings, timeZone, window) {
+    const span = window.endMinute - window.startMinute;
+    if (span <= 0)
+        return [];
+    const byDay = new Map();
+    for (const booking of bookings) {
+        const start = zonedInstant(new Date(booking.startAt), timeZone);
+        const end = zonedInstant(new Date(booking.endAt), timeZone);
+        // An appointment that crosses local midnight is clamped to the end of the
+        // day it started on. Splitting it across two columns would be more correct
+        // and is not worth the complexity for a booking grid, where the longest
+        // event type is capped at eight hours server-side.
+        const endMinutes = end.dateKey === start.dateKey ? end.minutes : 1440;
+        const entries = byDay.get(start.dateKey) ?? [];
+        entries.push({ booking, start: start.minutes, end: Math.max(endMinutes, start.minutes + 1) });
+        byDay.set(start.dateKey, entries);
+    }
+    const positioned = [];
+    for (const [dateKey, entries] of byDay) {
+        entries.sort((a, b) => a.start - b.start || a.end - b.end);
+        for (const cluster of clusterOverlapping(entries)) {
+            cluster.forEach((entry, column) => {
+                const clampedStart = Math.max(entry.start, window.startMinute);
+                const clampedEnd = Math.min(entry.end, window.endMinute);
+                positioned.push({
+                    booking: entry.booking,
+                    dateKey,
+                    top: (clampedStart - window.startMinute) / span,
+                    height: Math.max((clampedEnd - clampedStart) / span, MIN_VISIBLE_FRACTION),
+                    column,
+                    columns: cluster.length,
+                    clipped: entry.start < window.startMinute || entry.end > window.endMinute,
+                });
+            });
+        }
+    }
+    return positioned;
+}
+/**
+ * Transitive overlap grouping - see `layoutBookings`.
+ *
+ * Entries arrive sorted by start. A cluster stays open while the next entry
+ * begins before the *furthest* end seen so far, not before the previous
+ * entry's end: a long appointment that swallows several short ones has to keep
+ * the whole run together.
+ */
+function clusterOverlapping(entries) {
+    const clusters = [];
+    let current = [];
+    let clusterEnd = -Infinity;
+    for (const entry of entries) {
+        if (current.length > 0 && entry.start >= clusterEnd) {
+            clusters.push(current);
+            current = [];
+            clusterEnd = -Infinity;
+        }
+        current.push(entry);
+        clusterEnd = Math.max(clusterEnd, entry.end);
+    }
+    if (current.length > 0)
+        clusters.push(current);
+    return clusters;
+}
+/**
+ * The hour labels down the left edge, inclusive of both ends.
+ *
+ * Takes no timezone, deliberately: these label *wall-clock hours on the grid*,
+ * not instants. The grid is already drawn in the business's zone, so "10 am"
+ * means the business's ten - running the label through a zone conversion would
+ * shift it away from the row it sits on.
+ */
+function hourMarks(window) {
+    const marks = [];
+    const formatter = new Intl.DateTimeFormat("en-IN", {
+        timeZone: "UTC",
+        hour: "numeric",
+        hour12: true,
+    });
+    const firstHour = Math.ceil(window.startMinute / 60);
+    const lastHour = Math.floor(window.endMinute / 60);
+    for (let hour = firstHour; hour <= lastHour; hour += 1) {
+        marks.push({
+            minute: hour * 60,
+            // A synthetic UTC instant formatted in UTC - the round trip exists only
+            // to borrow `Intl`'s "10 am" / "12 pm" spelling, not to convert anything.
+            label: formatter.format(new Date(Date.UTC(2000, 0, 1, hour % 24))),
+        });
+    }
+    return marks;
+}

package/dist/cjs/client/index.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizePath = exports.flattenNav = exports.normalizeNav = exports.useActivePath = exports.ConnectSideNav = exports.ConnectSidebarNav = exports.RAIL_EXPANDED = exports.RAIL_COLLAPSED = exports.sidebarRowClass = exports.useConnectShell = exports.ConnectShellProvider = exports.ConnectSidebarRow = exports.ConnectSidebarFooter = exports.ConnectSidebarBody = exports.ConnectSidebarHeader = exports.ConnectSidebar = exports.AppShell = exports.ConnectAccountSessions = exports.ConnectSignOutButton = exports.ConnectHomeButton = exports.ConnectProfileButton = exports.ConnectInvoicesButton = exports.ConnectManageSubscriptionButton = exports.ConnectUserMenu = exports.ConnectProfileModal = exports.ConnectUserButton = exports.ConnectRegisterButton = exports.ConnectLoginButton = exports.ConnectLogo = exports.ConnectMark = exports.ConnectGrievanceNotice = exports.isConnectError = exports.ConnectError = exports.normalizePlanFeatures = exports.blockingBlockers = exports.CONNECT_APP_URL = exports.useConnectResource = exports.useConnectIntegrations = exports.useConnectSessions = exports.useConnectAddonUsage = exports.useConnectCompanyProfile = exports.useConnectApps = exports.useConnectPlans = exports.useConnectEntitlements = exports.useConnectPlatformAccess = exports.useConnectAudience = exports.useConnectWorkspaceType = exports.useConnectUser = exports.useConnect = exports.ConnectProvider = void 0;
 exports.annualSaving = exports.resolveAction = exports.monthlyOf = exports.formatPrice = exports.buildCheckoutUrl = exports.useConnectCheckout = exports.ConnectFilterTabs = exports.ConnectCursorPagination = exports.ConnectConfirmDialog = exports.ConnectLinkButton = exports.ConnectPlansPage = exports.ConnectUsageMeter = exports.ConnectPlatformGate = exports.ConnectWorkspaceTypeGate = exports.useConnectFeature = exports.ConnectFeatureGate = exports.useConnectAccessGate = exports.ConnectAccessGate = exports.ConnectReadinessGate = exports.ConnectReadinessBanner = exports.resolveSubscriptionState = exports.ConnectSeatUsage = exports.ConnectTrialBanner = exports.ConnectSubscriptionCard = exports.ConnectNoSubscriptionCard = exports.ConnectSubscriptionGate = exports.ConnectSubscribeDialog = exports.ConnectPlans = exports.ConnectIntegrationsModal = exports.AI_TONE_DOT = exports.AI_TONE_CHIP = exports.AI_EMPTY_VALUE = exports.aiStatusTone = exports.isNumericAiFormat = exports.formatAiValue = exports.AiSources = exports.AiSteps = exports.AiDetails = exports.AiTimeline = exports.AiMetrics = exports.AiChart = exports.AiTable = exports.ConnectAskAi = exports.ConnectAppsGrid = exports.isLinkableConnectScreen = exports.matchConnectScreen = exports.filterNavForAudience = exports.gateExemptPaths = exports.isNavItemActive = exports.resolveActivePath = void 0;
-exports.useConnectWorkspaceMembers = exports.useConnectWorkspaces = exports.ConnectWorkspaceSwitcher = exports.resolvePlanGroup = exports.groupPlansByTier = exports.ACTION_LABEL = exports.discountLabel = void 0;
+exports.zonedInstant = exports.dayColumns = exports.layoutBookings = exports.useBookingActions = exports.useBookings = exports.useAvailableSlots = exports.useBookableEventTypes = exports.ConnectBookingDetail = exports.ConnectBookingDialog = exports.ConnectBookingCalendar = exports.useConnectWorkspaceMembers = exports.useConnectWorkspaces = exports.ConnectWorkspaceSwitcher = exports.resolvePlanGroup = exports.groupPlansByTier = exports.ACTION_LABEL = exports.discountLabel = void 0;
 /**
  * Browser half of `@cosmoops/connect-sdk` - React components and hooks.
  *
@@ -223,3 +223,17 @@ Object.defineProperty(exports, "ConnectWorkspaceSwitcher", { enumerable: true, g
 var provider_js_2 = require("./provider.js");
 Object.defineProperty(exports, "useConnectWorkspaces", { enumerable: true, get: function () { return provider_js_2.useConnectWorkspaces; } });
 Object.defineProperty(exports, "useConnectWorkspaceMembers", { enumerable: true, get: function () { return provider_js_2.useConnectWorkspaceMembers; } });
+var booking_calendar_js_1 = require("./components/booking-calendar.js");
+Object.defineProperty(exports, "ConnectBookingCalendar", { enumerable: true, get: function () { return booking_calendar_js_1.ConnectBookingCalendar; } });
+var booking_dialogs_js_1 = require("./components/booking-dialogs.js");
+Object.defineProperty(exports, "ConnectBookingDialog", { enumerable: true, get: function () { return booking_dialogs_js_1.ConnectBookingDialog; } });
+Object.defineProperty(exports, "ConnectBookingDetail", { enumerable: true, get: function () { return booking_dialogs_js_1.ConnectBookingDetail; } });
+var use_scheduling_js_1 = require("./use-scheduling.js");
+Object.defineProperty(exports, "useBookableEventTypes", { enumerable: true, get: function () { return use_scheduling_js_1.useBookableEventTypes; } });
+Object.defineProperty(exports, "useAvailableSlots", { enumerable: true, get: function () { return use_scheduling_js_1.useAvailableSlots; } });
+Object.defineProperty(exports, "useBookings", { enumerable: true, get: function () { return use_scheduling_js_1.useBookings; } });
+Object.defineProperty(exports, "useBookingActions", { enumerable: true, get: function () { return use_scheduling_js_1.useBookingActions; } });
+var booking_grid_js_1 = require("./components/booking-grid.js");
+Object.defineProperty(exports, "layoutBookings", { enumerable: true, get: function () { return booking_grid_js_1.layoutBookings; } });
+Object.defineProperty(exports, "dayColumns", { enumerable: true, get: function () { return booking_grid_js_1.dayColumns; } });
+Object.defineProperty(exports, "zonedInstant", { enumerable: true, get: function () { return booking_grid_js_1.zonedInstant; } });

package/dist/cjs/client/use-scheduling.js

@@ -0,0 +1,113 @@
+"use client";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useBookableEventTypes = useBookableEventTypes;
+exports.useAvailableSlots = useAvailableSlots;
+exports.useBookings = useBookings;
+exports.useBookingActions = useBookingActions;
+const react_1 = require("react");
+const provider_js_1 = require("./provider.js");
+/**
+ * The bridge's scheduling surface, as hooks.
+ *
+ * Every path here is one of the six the bridge exposes, and every one of them
+ * is resolved *for the signed-in member* - Connect takes the workspace from
+ * their session and checks their own `calendar:read` / `calendar:manage`.
+ * Nothing in this file names a workspace, and nothing should: a browser that
+ * can name a tenant is a browser that can read someone else's diary.
+ */
+/** What this workspace offers as bookable. Active types only. */
+function useBookableEventTypes() {
+    const { data, isLoading, error } = (0, provider_js_1.useConnectResource)("/scheduling/event-types");
+    return { eventTypes: data?.eventTypes ?? [], isLoading, error };
+}
+/**
+ * Free times for one appointment type.
+ *
+ * **Deliberately re-read rather than cached across a session.** A slot list is
+ * a snapshot of contention: anyone else on that calendar - a colleague, a
+ * voice agent mid-call, someone on the public booking link - can take one
+ * between the read and the click. Showing a stale one is how two people are
+ * offered the same minute. The booking call re-checks inside a transaction
+ * anyway, so a stale list costs a refusal rather than a double booking; this
+ * just means the refusal is rare.
+ */
+function useAvailableSlots(query) {
+    const path = query
+        ? `/scheduling/slots?${new URLSearchParams({
+            eventTypeId: query.eventTypeId,
+            from: query.from.toISOString(),
+            to: query.to.toISOString(),
+            ...(query.excludeBookingId ? { excludeBookingId: query.excludeBookingId } : {}),
+        }).toString()}`
+        : null;
+    // `useConnectResource` needs a path; an empty one never resolves, so the
+    // hook is called unconditionally (rules of hooks) and simply idles.
+    const { data, isLoading, error, refetch } = (0, provider_js_1.useConnectResource)(path ?? "");
+    return {
+        slots: path ? (data?.slots ?? []) : [],
+        timezone: data?.timezone ?? null,
+        durationMinutes: data?.durationMinutes ?? null,
+        isLoading: path ? isLoading : false,
+        error: path ? error : null,
+        refetch,
+    };
+}
+/** One page of the diary, ascending - a forward view, not a history. */
+function useBookings(query) {
+    const path = (0, react_1.useMemo)(() => `/scheduling/bookings?${new URLSearchParams({
+        from: query.from.toISOString(),
+        to: query.to.toISOString(),
+        order: "asc",
+        status: "confirmed",
+        limit: String(query.limit ?? 100),
+        ...(query.hostMemberId ? { hostMemberId: query.hostMemberId } : {}),
+    }).toString()}`, [query.from, query.to, query.hostMemberId, query.limit]);
+    const { data, isLoading, error, refetch } = (0, provider_js_1.useConnectResource)(path);
+    return {
+        bookings: data?.bookings ?? [],
+        hasMore: data?.hasMore ?? false,
+        isLoading,
+        error,
+        path,
+        refetch,
+    };
+}
+/**
+ * Book, move and cancel.
+ *
+ * **None of these is optimistic**, and that is not an oversight. Whether a
+ * slot is still free is a question only the server can answer, inside the
+ * transaction that decides it - two people can be holding the same minute
+ * right now. Painting a booking as made and withdrawing it is exactly the lie
+ * the two-phase hold exists to prevent.
+ */
+function useBookingActions() {
+    const { mutateResource } = (0, provider_js_1.useConnect)();
+    const [isPending, setPending] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const run = (0, react_1.useCallback)(async (path, body) => {
+        setPending(true);
+        setError(null);
+        try {
+            return await mutateResource(path, body);
+        }
+        catch (cause) {
+            // The server writes these as sentences - "that time was just taken" -
+            // precisely so they can be shown rather than mapped to a code.
+            setError(cause instanceof Error ? cause.message : "Something went wrong.");
+            return null;
+        }
+        finally {
+            setPending(false);
+        }
+    }, [mutateResource]);
+    return {
+        isPending,
+        error,
+        clearError: () => setError(null),
+        createBooking: (input) => run("/scheduling/bookings", input),
+        rescheduleBooking: (input) => run("/scheduling/bookings/reschedule", input).then((result) => result?.booking ?? null),
+        cancelBooking: (input) => run("/scheduling/bookings/cancel", input),
+    };
+}

package/dist/cjs/server/client.js

@@ -7,6 +7,7 @@ const ai_js_1 = require("./resources/ai.js");
 const data_js_1 = require("./resources/data.js");
 const workspaces_js_1 = require("./resources/workspaces.js");
 const scheduling_js_1 = require("./resources/scheduling.js");
+const contacts_js_1 = require("./resources/contacts.js");
 const kv_js_1 = require("./resources/kv.js");
 const billing_js_1 = require("./resources/billing.js");
 const drive_js_1 = require("./resources/drive.js");
@@ -82,6 +83,8 @@ class ConnectClient {
     drive;
     /** A subscribing workspace's own calendar - what is bookable, free, and booked. */
     scheduling;
+    /** Who a workspace already knows how to reach, by phone or by id. */
+    contacts;
     /** RAG chat and structured extraction. */
     ai;
     /** Your application's own document store - see `DataResource`. */
@@ -131,6 +134,7 @@ class ConnectClient {
         this.billing = new billing_js_1.BillingResource(transport);
         this.drive = new drive_js_1.DriveResource(transport);
         this.scheduling = new scheduling_js_1.SchedulingResource(transport);
+        this.contacts = new contacts_js_1.ContactsResource(transport);
         this.ai = new ai_js_1.AiResource(transport);
         this.data = new data_js_1.DataResource(transport);
         this.kv = new kv_js_1.KvResource(transport);
@@ -146,4 +150,4 @@ class ConnectClient {
 }
 exports.ConnectClient = ConnectClient;
 /** Kept in step with `package.json` by `sdk.test.ts`. */
-exports.SDK_VERSION = "0.17.0";
+exports.SDK_VERSION = "0.19.0";

package/dist/cjs/server/handler.js

@@ -415,6 +415,142 @@ function createConnectHandler(options) {
             await session.write?.(request, response, result.sessionToken);
             return response;
         },
+        /*
+         * Scheduling - the workspace's own calendar, in a browser.
+         *
+         * Every one of these forwards the caller's session token, which is what
+         * makes them safe to expose: Connect derives the workspace from that token
+         * and checks the member's own `calendar:read` / `calendar:manage`. The
+         * browser names no tenant and the partner's key does not, by itself,
+         * authorize a write - without that second half, shipping a booking
+         * component would let every end user of every partner app take slots on a
+         * real business calendar.
+         *
+         * `workspaceId` is still passed because the resource requires it, and is
+         * still ignored by Connect whenever a token is present. `requireWorkspace`
+         * supplies the session's own, so the two can never disagree.
+         */
+        "GET /scheduling/event-types": async (request) => {
+            const { workspaceId } = await requireWorkspace(request);
+            const asUser = await requireToken(request);
+            return json({ eventTypes: await client.scheduling.listEventTypes(workspaceId, { asUser }) });
+        },
+        "GET /scheduling/slots": async (request) => {
+            const { workspaceId } = await requireWorkspace(request);
+            const asUser = await requireToken(request);
+            const url = new URL(request.url);
+            const eventTypeId = url.searchParams.get("eventTypeId");
+            const from = url.searchParams.get("from");
+            const to = url.searchParams.get("to");
+            if (!eventTypeId || !from || !to) {
+                throw new errors_js_1.ConnectError({
+                    status: 400,
+                    code: "validation_error",
+                    message: "eventTypeId, from and to are required",
+                    endpoint: "/scheduling/slots",
+                });
+            }
+            return json(await client.scheduling.findSlots({
+                workspaceId,
+                eventTypeId,
+                from,
+                to,
+                // Set when offering times to move an existing appointment to, or the
+                // booking blocks its own replacement and the list comes back empty.
+                excludeBookingId: url.searchParams.get("excludeBookingId") ?? undefined,
+                asUser,
+            }));
+        },
+        "GET /scheduling/bookings": async (request) => {
+            const { workspaceId } = await requireWorkspace(request);
+            const asUser = await requireToken(request);
+            const url = new URL(request.url);
+            const limit = Number(url.searchParams.get("limit") ?? 25);
+            return json(await client.scheduling.listBookings({
+                workspaceId,
+                status: url.searchParams.get("status") ?? undefined,
+                hostMemberId: url.searchParams.get("hostMemberId") ?? undefined,
+                from: url.searchParams.get("from") ?? undefined,
+                to: url.searchParams.get("to") ?? undefined,
+                order: url.searchParams.get("order") === "asc" ? "asc" : "desc",
+                cursor: url.searchParams.get("cursor") ?? undefined,
+                limit: Number.isInteger(limit) && limit >= 1 && limit <= 100 ? limit : 25,
+                asUser,
+            }));
+        },
+        "POST /scheduling/bookings": async (request) => {
+            const { workspaceId } = await requireWorkspace(request);
+            const asUser = await requireToken(request);
+            const body = (await request.json().catch(() => null));
+            if (typeof body?.eventTypeId !== "string" ||
+                typeof body.startAt !== "string" ||
+                typeof body.attendee?.name !== "string" ||
+                typeof body.attendee?.phone !== "string") {
+                throw new errors_js_1.ConnectError({
+                    status: 400,
+                    code: "validation_error",
+                    message: "eventTypeId, startAt and an attendee name and phone are required",
+                    endpoint: "/scheduling/bookings",
+                });
+            }
+            return json(await client.scheduling.createBooking({
+                workspaceId,
+                eventTypeId: body.eventTypeId,
+                startAt: body.startAt,
+                attendee: {
+                    name: body.attendee.name,
+                    phone: body.attendee.phone,
+                    email: typeof body.attendee.email === "string" ? body.attendee.email : null,
+                },
+                notes: typeof body.notes === "string" ? body.notes : null,
+                asUser,
+            }));
+        },
+        /*
+         * Reschedule and cancel take the booking id in the body rather than the
+         * path, matching `POST /sessions/revoke`. The bridge's route table is
+         * exact-match on `METHOD /path`, so a path parameter would mean a second
+         * matching strategy for two routes.
+         */
+        "POST /scheduling/bookings/reschedule": async (request) => {
+            const { workspaceId } = await requireWorkspace(request);
+            const asUser = await requireToken(request);
+            const body = (await request.json().catch(() => null));
+            if (typeof body?.bookingId !== "string" || typeof body.startAt !== "string") {
+                throw new errors_js_1.ConnectError({
+                    status: 400,
+                    code: "validation_error",
+                    message: "bookingId and startAt are required",
+                    endpoint: "/scheduling/bookings/reschedule",
+                });
+            }
+            return json(await client.scheduling.rescheduleBooking({
+                workspaceId,
+                bookingId: body.bookingId,
+                startAt: body.startAt,
+                notes: typeof body.notes === "string" ? body.notes : undefined,
+                asUser,
+            }));
+        },
+        "POST /scheduling/bookings/cancel": async (request) => {
+            const { workspaceId } = await requireWorkspace(request);
+            const asUser = await requireToken(request);
+            const body = (await request.json().catch(() => null));
+            if (typeof body?.bookingId !== "string") {
+                throw new errors_js_1.ConnectError({
+                    status: 400,
+                    code: "validation_error",
+                    message: "bookingId is required",
+                    endpoint: "/scheduling/bookings/cancel",
+                });
+            }
+            return json(await client.scheduling.cancelBooking({
+                workspaceId,
+                bookingId: body.bookingId,
+                reason: typeof body.reason === "string" ? body.reason : null,
+                asUser,
+            }));
+        },
         "GET /integrations": async (request) => {
             const { workspaceId } = await requireWorkspace(request);
             return json({ toolkits: await client.integrations.list(workspaceId) });

package/dist/cjs/server/resources/contacts.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContactsResource = void 0;
+const http_js_1 = require("../http.js");
+const acting_as_js_1 = require("./acting-as.js");
+/**
+ * Who a workspace already knows how to reach.
+ *
+ * **This is the telephony identity, not a CRM record.** A contact is keyed by
+ * `primaryPhone` - the one fact every inbound call carries - and it is written
+ * automatically: a voice agent creates one on the first call from a new number
+ * and fills fields in as it learns them. `source` says which kind you are
+ * holding, and it is worth rendering: `call` means an agent guessed and nobody
+ * has confirmed, `manual` means a person typed it.
+ *
+ * **Reference it, do not copy it.** If your application keeps its own customer
+ * records, store this contact's `id` on yours rather than duplicating the
+ * fields. Two writable copies of a person's name with no single owner drift,
+ * and Connect's is the one an agent keeps updating from calls. The id is also
+ * an exact join to anything else keyed by it - `Booking.contactId`, most
+ * usefully - so "which of my records is this appointment for" becomes a lookup
+ * instead of a phone match.
+ *
+ * Read-only for now. Writing into a store with a per-field provenance chain
+ * means declaring where your facts came from and how they merge with a
+ * human's, and nothing needs that yet.
+ */
+class ContactsResource {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /**
+     * "Do we already know this number?" - one point read, cheap enough for a
+     * screen pop on every inbound call.
+     *
+     * Resolves to `null` for a number nobody has called from before. That is the
+     * ordinary case for a first-time caller, not an error, which is why it is a
+     * null rather than a thrown `ConnectError`.
+     */
+    async lookupByPhone(input) {
+        const result = await (0, http_js_1.request)(this.transport, {
+            method: "GET",
+            path: "/contacts",
+            query: { workspaceId: input.workspaceId, phone: input.phone },
+            headers: (0, acting_as_js_1.actingAs)(input.asUser),
+        });
+        return result.contact ?? null;
+    }
+    /**
+     * The record behind an id you already hold.
+     *
+     * Throws `ConnectError` with `code: "not_found"` for an id that does not
+     * exist *or* belongs to another workspace - deliberately the same answer,
+     * since telling those apart would confirm a contact exists somewhere else.
+     */
+    get(contactId, options) {
+        return (0, http_js_1.request)(this.transport, {
+            method: "GET",
+            path: `/contacts/${encodeURIComponent(contactId)}`,
+            query: { workspaceId: options.workspaceId },
+            headers: (0, acting_as_js_1.actingAs)(options.asUser),
+        });
+    }
+}
+exports.ContactsResource = ContactsResource;

package/dist/cjs/server/resources/scheduling.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchedulingResource = void 0;
 const http_js_1 = require("../http.js");
+const acting_as_js_1 = require("./acting-as.js");
 /**
  * A subscribing workspace's own calendar.
  *
@@ -21,11 +22,12 @@ class SchedulingResource {
         this.transport = transport;
     }
     /** What this workspace offers as bookable. Active appointment types only. */
-    async listEventTypes(workspaceId) {
+    async listEventTypes(workspaceId, options = {}) {
         const result = await (0, http_js_1.request)(this.transport, {
             method: "GET",
             path: "/scheduling/event-types",
             query: { workspaceId },
+            headers: (0, acting_as_js_1.actingAs)(options.asUser),
         });
         // `?? []` for the same reason `apps.list` has it - a collection every
         // caller immediately maps, and a body without the key would hand them
@@ -54,7 +56,9 @@ class SchedulingResource {
                 eventTypeId: input.eventTypeId,
                 from: toInstant(input.from),
                 to: toInstant(input.to),
+                excludeBookingId: input.excludeBookingId,
             },
+            headers: (0, acting_as_js_1.actingAs)(input.asUser),
         });
     }
     /** One page of the workspace's diary. */
@@ -72,6 +76,7 @@ class SchedulingResource {
                 cursor: input.cursor,
                 limit: input.limit === undefined ? undefined : String(input.limit),
             },
+            headers: (0, acting_as_js_1.actingAs)(input.asUser),
         });
     }
     /**
@@ -93,6 +98,31 @@ class SchedulingResource {
                 attendee: input.attendee,
                 notes: input.notes ?? null,
             },
+            headers: (0, acting_as_js_1.actingAs)(input.asUser),
+        });
+    }
+    /**
+     * Moves an appointment to a different time.
+     *
+     * **The original is retired, not edited.** It stays on the diary as
+     * `rescheduled` with `rescheduledToId` pointing at the replacement, and both
+     * come back here - so a booking id you cached still resolves, and still says
+     * where the appointment went.
+     *
+     * A refused move changes nothing: the new slot is claimed before the old one
+     * is released, so a `conflict` leaves the customer with the appointment they
+     * already had. Re-read the slots (with `excludeBookingId`) and offer another.
+     */
+    rescheduleBooking(input) {
+        return (0, http_js_1.request)(this.transport, {
+            method: "POST",
+            path: `/scheduling/bookings/${encodeURIComponent(input.bookingId)}/reschedule`,
+            json: {
+                workspaceId: input.workspaceId,
+                startAt: toInstant(input.startAt),
+                notes: input.notes ?? null,
+            },
+            headers: (0, acting_as_js_1.actingAs)(input.asUser),
         });
     }
     /**
@@ -107,6 +137,7 @@ class SchedulingResource {
             method: "POST",
             path: `/scheduling/bookings/${encodeURIComponent(input.bookingId)}/cancel`,
             json: { workspaceId: input.workspaceId, reason: input.reason ?? null },
+            headers: (0, acting_as_js_1.actingAs)(input.asUser),
         });
     }
 }