@cosmoops/connect-sdk 0.36.0 → 0.38.0

package/dist/esm/client/components/workspace-switcher.js

@@ -1,8 +1,8 @@
 "use client";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useState } from "react";
-import { Button, Dropdown, ListBox } from "@heroui/react";
-import { ChevronsUpDown } from "lucide-react";
+import { Button, Dropdown, ListBox, Separator } from "@heroui/react";
+import { ChevronsUpDown, Plus } from "lucide-react";
 import { useConnect, useConnectUser, useConnectWorkspaces } from "../provider.js";
 import { m } from "./motion.js";
 import { SidebarLabel, sidebarRowClass, useConnectShell } from "./shell-context.js";
@@ -11,6 +11,9 @@ function workspaceInitials(name) {
     const parts = name.trim().split(/\s+/).filter(Boolean);
     return (parts.slice(0, 2).map((part) => part[0]).join("") || "?").toUpperCase();
 }
+function openExternal(url) {
+    window.open(url, "_blank", "noopener,noreferrer");
+}
 /**
  * Switches which workspace this application is looking at.
  *
@@ -19,11 +22,15 @@ function workspaceInitials(name) {
  * it reads as a heading for the nav rather than as one more destination.
  *
  * It decides for itself whether to appear: an account with one workspace is
- * shown nothing, because a switcher offering one option teaches the user
- * nothing and costs a row of chrome on every screen. That is the opposite of
- * Connect's own switcher, which always renders - Connect is where a workspace
- * is *created*, so hiding it at one workspace would guarantee nobody ever
- * reached two. A partner application creates nothing, so it has no such duty.
+ * shown nothing by default, because a switcher offering one option teaches
+ * the user nothing and costs a row of chrome on every screen. That is the
+ * opposite of Connect's own switcher, which always renders - Connect is where
+ * a workspace is *created*, so hiding it at one workspace would guarantee
+ * nobody ever reached two. `alwaysShow` is the escape hatch for a partner
+ * application that wants that same discoverability without becoming Connect:
+ * it keeps the dropdown open below two workspaces and adds a row that sends
+ * the member to Connect to actually create one, since there is nothing here
+ * that can.
  *
  * **Authorization is the data, not a prop.** The list comes from the caller's
  * own session (`GET /workspaces` takes no user id), so a workspace the user
@@ -42,19 +49,22 @@ function workspaceInitials(name) {
  * component - so the only thing to do afterwards is reload, which is what
  * `onSwitched` defaults to.
  */
-export function ConnectWorkspaceSwitcher({ onSwitched, row = true, className, }) {
-    const { mutateResource } = useConnect();
+export function ConnectWorkspaceSwitcher({ onSwitched, row = true, className, alwaysShow = false, }) {
+    const { mutateResource, appUrl } = useConnect();
     const { collapsed } = useConnectShell();
     const user = useConnectUser();
     const { data, isLoading } = useConnectWorkspaces();
     const [switching, setSwitching] = useState(null);
     const [error, setError] = useState(null);
     const workspaces = data?.workspaces ?? [];
-    // Nothing to switch between, or nothing loaded yet. Deliberately renders
-    // `null` rather than a skeleton: this sits in persistent chrome, and a
-    // placeholder that resolves to nothing for most accounts is worse than
-    // appearing a moment late for the few who have two.
-    if (isLoading || workspaces.length < 2)
+    // Nothing loaded yet. Deliberately renders `null` rather than a skeleton:
+    // this sits in persistent chrome, and a placeholder that resolves to
+    // nothing for most accounts is worse than appearing a moment late.
+    //
+    // Below one workspace, `alwaysShow` is the only thing that keeps this
+    // rendering - the default stays "nothing to switch between" for every
+    // host that hasn't opted in.
+    if (isLoading || (!alwaysShow && workspaces.length < 2))
         return null;
     const active = workspaces.find((workspace) => workspace.isActive);
     const label = active?.name ?? user?.workspaceName ?? "Workspace";
@@ -84,7 +94,7 @@ export function ConnectWorkspaceSwitcher({ onSwitched, row = true, className, })
                     // A 32px tile rather than a 20px glyph, so the initials land on the
                     // same optical centre the avatar below them uses - see
                     // `SIDEBAR_ROW_TILE`. Collapsed, this tile *is* the switcher.
-                    _jsxs(Button, { variant: "tertiary", "aria-label": `Workspace: ${label}. Switch workspace`, className: sidebarRowClass({ tile: true, className }), children: [_jsx("span", { className: "flex size-8 shrink-0 items-center justify-center rounded-lg bg-accent-soft text-xs font-semibold text-accent", children: workspaceInitials(label) }), _jsx(SidebarLabel, { className: "text-sm font-medium text-foreground", children: label }), _jsx(m.span, { className: "shrink-0 text-muted", animate: { opacity: collapsed ? 0 : 1 }, transition: collapsed ? { duration: 0.1 } : { duration: 0.18, delay: 0.1 }, "aria-hidden": true, children: _jsx(ChevronsUpDown, { className: "size-4" }) })] })) : (_jsxs(Button, { variant: "secondary", size: "sm", className: "w-full justify-between", children: [_jsx("span", { className: "truncate", children: label }), _jsx(ChevronsUpDown, { className: "size-4 shrink-0 text-muted", "aria-hidden": "true" })] })), _jsx(Dropdown.Popover, { children: _jsx(ListBox, { children: workspaces.map((workspace) => (_jsxs(ListBox.Item, { id: workspace.workspaceId, textValue: workspace.name, isDisabled: !selectable(workspace) || switching !== null, onAction: () => void handleSwitch(workspace), children: [_jsxs("div", { className: "min-w-0", children: [_jsx("p", { className: "truncate text-sm", children: workspace.name }), selectable(workspace) ? null : (_jsx("p", { className: "truncate text-xs text-muted", children: reasonUnavailable(workspace) }))] }), _jsx(ListBox.ItemIndicator, {})] }, workspace.workspaceId))) }) })] }), error && !collapsed ? _jsx("p", { className: "mt-1 px-2 text-xs text-danger", children: error }) : null] }));
+                    _jsxs(Button, { variant: "tertiary", "aria-label": `Workspace: ${label}. Switch workspace`, className: sidebarRowClass({ tile: true, className }), children: [_jsx("span", { className: "flex size-8 shrink-0 items-center justify-center rounded-lg bg-accent-soft text-xs font-semibold text-accent", children: workspaceInitials(label) }), _jsx(SidebarLabel, { className: "text-sm font-medium text-foreground", children: label }), _jsx(m.span, { className: "shrink-0 text-muted", animate: { opacity: collapsed ? 0 : 1 }, transition: collapsed ? { duration: 0.1 } : { duration: 0.18, delay: 0.1 }, "aria-hidden": true, children: _jsx(ChevronsUpDown, { className: "size-4" }) })] })) : (_jsxs(Button, { variant: "secondary", size: "sm", className: "w-full justify-between", children: [_jsx("span", { className: "truncate", children: label }), _jsx(ChevronsUpDown, { className: "size-4 shrink-0 text-muted", "aria-hidden": "true" })] })), _jsx(Dropdown.Popover, { children: _jsxs(ListBox, { children: [workspaces.map((workspace) => (_jsxs(ListBox.Item, { id: workspace.workspaceId, textValue: workspace.name, isDisabled: !selectable(workspace) || switching !== null, onAction: () => void handleSwitch(workspace), children: [_jsxs("div", { className: "min-w-0", children: [_jsx("p", { className: "truncate text-sm", children: workspace.name }), selectable(workspace) ? null : (_jsx("p", { className: "truncate text-xs text-muted", children: reasonUnavailable(workspace) }))] }), _jsx(ListBox.ItemIndicator, {})] }, workspace.workspaceId))), alwaysShow ? (_jsxs(_Fragment, { children: [workspaces.length > 0 && _jsx(Separator, {}), _jsxs(ListBox.Item, { id: "__create_workspace", textValue: "Create workspace", onAction: () => openExternal(appUrl), children: [_jsx(Plus, { className: "size-4 shrink-0 text-muted", "aria-hidden": true }), _jsx("p", { className: "truncate text-sm", children: "Create workspace" })] })] })) : null] }) })] }), error && !collapsed ? _jsx("p", { className: "mt-1 px-2 text-xs text-danger", children: error }) : null] }));
 }
 /** Belongs to the user, and usable here. The same two facts `switch` enforces. */
 function selectable(workspace) {

package/dist/esm/client/index.js

@@ -31,6 +31,11 @@ ConnectUserMenu, ConnectManageSubscriptionButton, ConnectInvoicesButton, Connect
 // Built, compiled into `dist/`, and reachable from no entry point until now -
 // `ConnectUserMenu` was the only thing that could render it.
 export { ConnectAccountSessions } from "./components/account-sessions.js";
+// A link to *any* Connect portal page that offers a "Back to <your app>" way
+// home - what `ConnectProfileButton` builds for `/profile` internally, made
+// reusable for a host linking out to a different Connect page (e.g.
+// `/calendar/settings`) on its own.
+export { connectPortalUrl, useConnectPortalUrl } from "./portal-links.js";
 // The frame the rest of these components live inside. Exported next to the
 // pieces it composes rather than in a section of its own - an integration
 // reaching for a sidebar wants to find the launcher and the account menu in
@@ -144,5 +149,11 @@ export { ConnectWorkspaceSwitcher } from "./components/workspace-switcher.js";
 export { useConnectWorkspaces, useConnectWorkspaceMembers } from "./provider.js";
 export { ConnectBookingCalendar } from "./components/booking-calendar.js";
 export { ConnectBookingDialog, ConnectBookingDetail } from "./components/booking-dialogs.js";
-export { useBookableEventTypes, useAvailableSlots, useBookings, useBookingActions, } from "./use-scheduling.js";
+// The write half of scheduling - a workspace's own first-time setup, not a
+// partner integration's booking flow. `ConnectAvailabilityFormModal` and
+// `ConnectEventTypeFormModal` give a host application a real inline setup
+// step instead of a link-out to Connect's own Calendar settings.
+export { ConnectAvailabilityFormModal } from "./components/availability-form.js";
+export { ConnectEventTypeFormModal } from "./components/event-type-form.js";
+export { useBookableEventTypes, useAvailabilitySchedules, useCreateAvailabilitySchedule, useCreateEventType, useAvailableSlots, useBookings, useBookingActions, } from "./use-scheduling.js";
 export { layoutBookings, dayColumns, zonedInstant, } from "./components/booking-grid.js";

package/dist/esm/client/portal-links.js

@@ -0,0 +1,34 @@
+"use client";
+import { useConnect } from "./provider.js";
+/**
+ * Any Connect portal page, with the context it needs to offer a way back
+ * here - `connectPortalUrl(appUrl, clientId, "/profile")`,
+ * `connectPortalUrl(appUrl, clientId, "/calendar/settings")`, and so on.
+ *
+ * Connect answers any of these paths for a signed-in user on the bare URL -
+ * these two params only add the "Back to <your app>" banner
+ * (`ApplicationReturnBar` on Connect's side). It validates `return_to`
+ * against this `client_id`'s registered redirect origins and silently drops
+ * the banner if they don't match, so a wrong or stale `appUrl`/`clientId`
+ * pairing degrades to what linking there did before rather than erroring.
+ *
+ * `window.location.href` rather than a configured home URL: the point is to
+ * come back to the page they left, and only the browser knows which one that
+ * is.
+ */
+export function connectPortalUrl(appUrl, clientId, path) {
+    const url = new URL(path, appUrl);
+    url.searchParams.set("client_id", clientId);
+    if (typeof window !== "undefined") {
+        url.searchParams.set("return_to", window.location.href);
+    }
+    return url.toString();
+}
+/**
+ * `connectPortalUrl`, with `appUrl`/`clientId` read from the provider instead
+ * of threaded through by every caller.
+ */
+export function useConnectPortalUrl(path) {
+    const { appUrl, clientId } = useConnect();
+    return connectPortalUrl(appUrl, clientId, path);
+}

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

@@ -15,6 +15,48 @@ export function useBookableEventTypes() {
     const { data, isLoading, error } = useConnectResource("/scheduling/event-types");
     return { eventTypes: data?.eventTypes ?? [], isLoading, error };
 }
+/**
+ * The working-hours templates an appointment type can point at.
+ *
+ * Read this before offering a "set up availability" step - a workspace that
+ * already has one does not need a second "Working hours" from your UI.
+ */
+export function useAvailabilitySchedules() {
+    const { data, isLoading, error } = useConnectResource("/scheduling/schedules");
+    return { schedules: data?.schedules ?? [], isLoading, error };
+}
+/**
+ * Gives a workspace its first working hours.
+ *
+ * **Not optimistic** - same posture as `useBookingActions`: this is one of
+ * the two writes a host's first-run setup makes, and a modal that closes on
+ * a failed create is worse than one that stays open with the reason shown.
+ */
+export function useCreateAvailabilitySchedule() {
+    const { run, isPending, error, clearError } = useResourceAction();
+    return {
+        isPending,
+        error,
+        clearError,
+        createSchedule: (input) => run("/scheduling/schedules", input),
+    };
+}
+/**
+ * Creates the first thing a workspace can be booked for.
+ *
+ * Host is a specific member, never a team - there is no groups read in this
+ * bridge, so a round-robin team host stays a Console-only capability
+ * reachable by following "Manage in Connect".
+ */
+export function useCreateEventType() {
+    const { run, isPending, error, clearError } = useResourceAction();
+    return {
+        isPending,
+        error,
+        clearError,
+        createEventType: (input) => run("/scheduling/event-types", input),
+    };
+}
 /**
  * Free times for one appointment type.
  *
@@ -68,15 +110,16 @@ export function useBookings(query) {
     };
 }
 /**
- * Book, move and cancel.
+ * The isPending/error bookkeeping every write in this file shares, factored
+ * out once `useCreateAvailabilitySchedule` and `useCreateEventType` needed
+ * the identical shape `useBookingActions` already had.
  *
- * **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.
+ * **Never optimistic**, and that is not an oversight for any caller of this:
+ * whether a slot is free, or a schedule name collides, is a question only the
+ * server can answer. Painting the result before it comes back is exactly the
+ * lie a two-phase hold (or a modal that closes early) would tell.
  */
-export function useBookingActions() {
+function useResourceAction() {
     const { mutateResource } = useConnect();
     const [isPending, setPending] = useState(false);
     const [error, setError] = useState(null);
@@ -96,10 +139,23 @@ export function useBookingActions() {
             setPending(false);
         }
     }, [mutateResource]);
+    return { isPending, error, clearError: () => setError(null), run };
+}
+/**
+ * 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.
+ */
+export function useBookingActions() {
+    const { run, isPending, error, clearError } = useResourceAction();
     return {
         isPending,
         error,
-        clearError: () => setError(null),
+        clearError,
         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/esm/server/client.js

@@ -175,4 +175,4 @@ export class ConnectClient {
     }
 }
 /** Kept in step with `package.json` by `sdk.test.ts`. */
-export const SDK_VERSION = "0.36.0";
+export const SDK_VERSION = "0.38.0";

package/dist/esm/server/handler.js

@@ -850,6 +850,84 @@ export function createConnectHandler(options) {
             const asUser = await requireToken(request);
             return json({ eventTypes: await client.scheduling.listEventTypes(workspaceId, { asUser }) });
         },
+        /*
+         * Creates the first thing a workspace can be booked for - a browser-side
+         * counterpart to `POST /scheduling/event-types` above, for a host's own
+         * inline setup UI (`ConnectEventTypeFormModal`). Host is a specific
+         * member, never a team - there is no groups read in this bridge, so a
+         * round-robin team host stays a Console-only capability.
+         */
+        "POST /scheduling/event-types": async (request) => {
+            const { workspaceId } = await requireWorkspace(request);
+            const asUser = await requireToken(request);
+            const body = (await request.json().catch(() => null));
+            if (typeof body?.name !== "string" ||
+                typeof body.durationMinutes !== "number" ||
+                typeof body.hostMemberId !== "string" ||
+                typeof body.scheduleId !== "string" ||
+                typeof body.location?.kind !== "string") {
+                throw new ConnectError({
+                    status: 400,
+                    code: "validation_error",
+                    message: "name, durationMinutes, hostMemberId, scheduleId and location are required",
+                    endpoint: "/scheduling/event-types",
+                });
+            }
+            return json(await client.scheduling.createEventType({
+                workspaceId,
+                name: body.name,
+                description: typeof body.description === "string" ? body.description : null,
+                durationMinutes: body.durationMinutes,
+                bufferBeforeMinutes: typeof body.bufferBeforeMinutes === "number" ? body.bufferBeforeMinutes : undefined,
+                bufferAfterMinutes: typeof body.bufferAfterMinutes === "number" ? body.bufferAfterMinutes : undefined,
+                hostMemberId: body.hostMemberId,
+                scheduleId: body.scheduleId,
+                location: {
+                    kind: body.location.kind,
+                    value: typeof body.location.value === "string" ? body.location.value : null,
+                },
+                publicBookingEnabled: typeof body.publicBookingEnabled === "boolean" ? body.publicBookingEnabled : undefined,
+                asUser,
+            }), 201);
+        },
+        /*
+         * The working-hours templates an appointment type can point at - read
+         * before a setup UI offers to create one, so it can tell "none yet" from
+         * "already set up".
+         */
+        "GET /scheduling/schedules": async (request) => {
+            const { workspaceId } = await requireWorkspace(request);
+            const asUser = await requireToken(request);
+            return json({ schedules: await client.scheduling.listSchedules(workspaceId, { asUser }) });
+        },
+        /**
+         * Gives a workspace its first working hours - the browser-side
+         * counterpart to `POST /scheduling/schedules` above, for
+         * `ConnectAvailabilityFormModal`.
+         */
+        "POST /scheduling/schedules": async (request) => {
+            const { workspaceId } = await requireWorkspace(request);
+            const asUser = await requireToken(request);
+            const body = (await request.json().catch(() => null));
+            if (typeof body?.name !== "string" ||
+                typeof body.timezone !== "string" ||
+                typeof body.weeklyHours !== "object" ||
+                body.weeklyHours === null) {
+                throw new ConnectError({
+                    status: 400,
+                    code: "validation_error",
+                    message: "name, timezone and weeklyHours are required",
+                    endpoint: "/scheduling/schedules",
+                });
+            }
+            return json(await client.scheduling.createSchedule({
+                workspaceId,
+                name: body.name,
+                timezone: body.timezone,
+                weeklyHours: body.weeklyHours,
+                asUser,
+            }), 201);
+        },
         "GET /scheduling/slots": async (request) => {
             const { workspaceId } = await requireWorkspace(request);
             const asUser = await requireToken(request);

package/dist/esm/server/http.js

@@ -1,4 +1,15 @@
 import { ConnectError } from "../errors.js";
+/**
+ * How long a *generating* endpoint may take to send its headers.
+ *
+ * One number, named once, and it is not a guess: it is what
+ * `POST /visitor/chat` and `POST /ai/chat` declare as their `maxDuration` on
+ * the far side. A client bound shorter than the route's own ceiling cannot be
+ * right - it can only abort work Connect is still allowed to be doing - and
+ * the two numbers drifting apart is exactly how a 20s client came to be
+ * fronting a 60s route.
+ */
+export const GENERATION_TIMEOUT_MS = 60_000;
 const RETRYABLE_STATUS = new Set([408, 429, 500, 502, 503, 504]);
 /**
  * One id, safe to interpolate into a request path.
@@ -145,7 +156,7 @@ export async function request(options, spec) {
         // that has actually started to run as long as it needs. A caller that
         // wants to bound the stream itself passes `spec.signal`.
         const timeoutController = new AbortController();
-        const timer = setTimeout(() => timeoutController.abort(), options.timeoutMs);
+        const timer = setTimeout(() => timeoutController.abort(), spec.timeoutMs ?? options.timeoutMs);
         const signal = spec.signal
             ? AbortSignal.any([spec.signal, timeoutController.signal])
             : timeoutController.signal;

package/dist/esm/server/resources/ai.js

@@ -1,5 +1,5 @@
 import { actingAs } from "./acting-as.js";
-import { request } from "../http.js";
+import { GENERATION_TIMEOUT_MS, request } from "../http.js";
 /**
  * RAG chat and structured extraction against a workspace's data.
  *
@@ -40,6 +40,12 @@ export class AiResource {
                 ...(input.screenContext ? { screenContext: input.screenContext } : {}),
             },
             headers: actingAs(input.asUser),
+            /*
+             * Matches the route's own `maxDuration`. This endpoint does not send
+             * headers until the model's first token, so the default 20s bound was
+             * aborting any turn that opened with a tool call - see `RequestSpec.timeoutMs`.
+             */
+            timeoutMs: GENERATION_TIMEOUT_MS,
             raw: true,
             signal: options.signal,
         });

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

@@ -31,6 +31,68 @@ export class SchedulingResource {
         // `undefined` past every status check in between.
         return result.eventTypes ?? [];
     }
+    /**
+     * The working-hours templates an appointment type can point at.
+     *
+     * Read this before offering to create one - a workspace that already has
+     * hours set does not need a second "Working hours" from your integration.
+     */
+    async listSchedules(workspaceId, options = {}) {
+        const result = await request(this.transport, {
+            method: "GET",
+            path: "/scheduling/schedules",
+            query: { workspaceId },
+            headers: actingAs(options.asUser),
+        });
+        return result.schedules ?? [];
+    }
+    /**
+     * Gives a workspace its first working hours.
+     *
+     * Narrower than what the workspace's own Calendar settings can do - no date
+     * overrides, and never owned by one person (`ownerMemberId` stays `null`
+     * server-side). Anything beyond that is a Console edit, not a second write
+     * path for your integration to maintain.
+     */
+    createSchedule(input) {
+        return request(this.transport, {
+            method: "POST",
+            path: "/scheduling/schedules",
+            json: {
+                workspaceId: input.workspaceId,
+                name: input.name,
+                timezone: input.timezone,
+                weeklyHours: input.weeklyHours,
+            },
+            headers: actingAs(input.asUser),
+        });
+    }
+    /**
+     * The first thing a workspace can be booked for.
+     *
+     * Needs a schedule - create or pick one with `listSchedules`/`createSchedule`
+     * first. The slug for a future public booking link is derived from `name`
+     * server-side; you cannot choose one.
+     */
+    createEventType(input) {
+        return request(this.transport, {
+            method: "POST",
+            path: "/scheduling/event-types",
+            json: {
+                workspaceId: input.workspaceId,
+                name: input.name,
+                description: input.description ?? null,
+                durationMinutes: input.durationMinutes,
+                bufferBeforeMinutes: input.bufferBeforeMinutes,
+                bufferAfterMinutes: input.bufferAfterMinutes,
+                hostMemberId: input.hostMemberId,
+                scheduleId: input.scheduleId,
+                location: input.location,
+                publicBookingEnabled: input.publicBookingEnabled ?? false,
+            },
+            headers: actingAs(input.asUser),
+        });
+    }
     /**
      * Free times for one appointment type over one window.
      *

package/dist/esm/server/resources/visitor.js

@@ -1,4 +1,4 @@
-import { request } from "../http.js";
+import { GENERATION_TIMEOUT_MS, request } from "../http.js";
 /**
  * The header a bridge forwards the visitor's own address on.
  *
@@ -97,6 +97,12 @@ export class VisitorResource {
             path: "/visitor/chat",
             json: input,
             headers: visitorHeaders(options),
+            /*
+             * Matches the route's own `maxDuration`. This endpoint does not send
+             * headers until the model's first token, so the default 20s bound was
+             * aborting any turn that opened with a tool call - see `RequestSpec.timeoutMs`.
+             */
+            timeoutMs: GENERATION_TIMEOUT_MS,
             raw: true,
             signal: options.signal,
         });

package/dist/types/client/components/app-shell.d.ts

@@ -36,8 +36,14 @@ export interface AppShellProps {
      * for an account with only one workspace - so the reason to pass `false` is
      * not "most users have one" (already handled) but "this application renders
      * its own".
+     *
+     * Pass `{ alwaysShow: true }` instead of `true` to keep it mounted below
+     * two workspaces too - see `ConnectWorkspaceSwitcherProps.alwaysShow` for
+     * what that changes about the dropdown.
      */
-    workspaceSwitcher?: false;
+    workspaceSwitcher?: false | {
+        alwaysShow?: boolean;
+    };
     /** Rendered below `children`, inside the scrolling content pane. */
     footer?: ReactNode;
     /**

package/dist/types/client/components/availability-form.d.ts

@@ -0,0 +1,22 @@
+import type { AvailabilitySchedule } from "../../types.js";
+export interface ConnectAvailabilityFormModalProps {
+    isOpen: boolean;
+    onOpenChange: (isOpen: boolean) => void;
+    /** Called once the schedule is created, before the modal closes. */
+    onCreated?: (schedule: AvailabilitySchedule) => void;
+}
+/**
+ * Gives a workspace its first working hours, from inside a host application
+ * rather than a link-out to Connect.
+ *
+ * Deliberately narrower than Connect's own Calendar settings form: one
+ * interval per day (no split shifts), no date overrides, and the timezone
+ * defaults to the browser's own rather than asking. This is a first-run
+ * setup step, not a second copy of the Console editor - "Manage in Connect"
+ * is still where the rest of what a schedule can do lives.
+ *
+ * **Not optimistic.** `useCreateAvailabilitySchedule` settles the write
+ * against the server before this closes, the same posture every write in
+ * this package takes - see `ConnectBookingDialog`.
+ */
+export declare function ConnectAvailabilityFormModal({ isOpen, onOpenChange, onCreated, }: Readonly<ConnectAvailabilityFormModalProps>): import("react").JSX.Element;

package/dist/types/client/components/event-type-form.d.ts

@@ -0,0 +1,22 @@
+import type { BookableEventType } from "../../types.js";
+export interface ConnectEventTypeFormModalProps {
+    isOpen: boolean;
+    onOpenChange: (isOpen: boolean) => void;
+    /** Called once the appointment type is created, before the modal closes. */
+    onCreated?: (eventType: BookableEventType) => void;
+}
+/**
+ * Creates the first thing a workspace can be booked for, from inside a host
+ * application rather than a link-out to Connect.
+ *
+ * **Needs a schedule to exist first** - the picker reads `useAvailabilitySchedules`
+ * and renders "Set up availability first" with nothing to submit if none
+ * exists yet. Pair this with `ConnectAvailabilityFormModal` in a setup flow
+ * rather than assuming one.
+ *
+ * **Host is a specific member, never a team.** There is no groups read in
+ * this bridge, so a round-robin team host stays a Console-only capability -
+ * defaults to whoever is signed in, with an optional picker from the
+ * workspace's own roster.
+ */
+export declare function ConnectEventTypeFormModal({ isOpen, onOpenChange, onCreated, }: Readonly<ConnectEventTypeFormModalProps>): import("react").JSX.Element;

package/dist/types/client/components/plan-pricing.d.ts

@@ -74,6 +74,16 @@ export interface PlanTier {
     description: string;
     monthly: Plan | null;
     annual: Plan | null;
+    /**
+     * A plan paid once, never on a cadence - its own slot rather than falling
+     * into `annual`. A one-time plan has no renewal to discount against, so
+     * filing it as "annual" used to let a tier mixing a recurring plan with a
+     * one-time one compute a `annualSavingPercent` between a monthly charge and
+     * a lump sum, and offered the one-time purchase under the annual toggle as
+     * though it renewed. `pickTierPlan` in `plans.tsx` is the only reader that
+     * needs to know this slot exists.
+     */
+    oneTime: Plan | null;
     /** Whole-percent saving from paying annually, or `null` when this tier has no pair to compare. */
     annualSavingPercent: number | null;
 }

package/dist/types/client/components/workspace-switcher.d.ts

@@ -14,6 +14,21 @@ export interface ConnectWorkspaceSwitcherProps {
      */
     row?: boolean;
     className?: string;
+    /**
+     * Render even when the signed-in account has fewer than two workspaces.
+     *
+     * Off by default, which keeps this component's documented posture for
+     * every other host: an account with one workspace sees nothing, because a
+     * switcher offering one option teaches it nothing. Pass `true` on an
+     * application that wants a single-workspace account to be able to
+     * discover - and start - creating a second one without leaving its own
+     * chrome. There is deliberately no `workspaces.create()` on the SDK:
+     * creating a workspace is Connect's job, tied to KYC/KYB and a billing
+     * profile, not something an API key should be able to trigger - so turning
+     * this on also adds a "Create workspace" row that opens Connect, rather
+     * than pretending the switcher can do it itself.
+     */
+    alwaysShow?: boolean;
 }
 /**
  * Switches which workspace this application is looking at.
@@ -23,11 +38,15 @@ export interface ConnectWorkspaceSwitcherProps {
  * it reads as a heading for the nav rather than as one more destination.
  *
  * It decides for itself whether to appear: an account with one workspace is
- * shown nothing, because a switcher offering one option teaches the user
- * nothing and costs a row of chrome on every screen. That is the opposite of
- * Connect's own switcher, which always renders - Connect is where a workspace
- * is *created*, so hiding it at one workspace would guarantee nobody ever
- * reached two. A partner application creates nothing, so it has no such duty.
+ * shown nothing by default, because a switcher offering one option teaches
+ * the user nothing and costs a row of chrome on every screen. That is the
+ * opposite of Connect's own switcher, which always renders - Connect is where
+ * a workspace is *created*, so hiding it at one workspace would guarantee
+ * nobody ever reached two. `alwaysShow` is the escape hatch for a partner
+ * application that wants that same discoverability without becoming Connect:
+ * it keeps the dropdown open below two workspaces and adds a row that sends
+ * the member to Connect to actually create one, since there is nothing here
+ * that can.
  *
  * **Authorization is the data, not a prop.** The list comes from the caller's
  * own session (`GET /workspaces` takes no user id), so a workspace the user
@@ -46,4 +65,4 @@ export interface ConnectWorkspaceSwitcherProps {
  * component - so the only thing to do afterwards is reload, which is what
  * `onSwitched` defaults to.
  */
-export declare function ConnectWorkspaceSwitcher({ onSwitched, row, className, }: Readonly<ConnectWorkspaceSwitcherProps>): import("react").JSX.Element | null;
+export declare function ConnectWorkspaceSwitcher({ onSwitched, row, className, alwaysShow, }: Readonly<ConnectWorkspaceSwitcherProps>): import("react").JSX.Element | null;

package/dist/types/client/index.d.ts

@@ -32,6 +32,7 @@ export type { ConnectUserButtonProps, ConnectProfileModalProps } from "./compone
 export { ConnectAccountSessions } from "./components/account-sessions.js";
 export type { ConnectAccountSessionsProps } from "./components/account-sessions.js";
 export type { ConnectUserMenuProps } from "./components/user-menu.js";
+export { connectPortalUrl, useConnectPortalUrl } from "./portal-links.js";
 export { AppShell } from "./components/app-shell.js";
 export type { AppShellProps } from "./components/app-shell.js";
 export { ConnectSidebar, ConnectSidebarHeader, ConnectSidebarBody, ConnectSidebarFooter, ConnectSidebarRow, } from "./components/sidebar.js";
@@ -104,5 +105,9 @@ export { useConnectWorkspaces, useConnectWorkspaceMembers } from "./provider.js"
 export { ConnectBookingCalendar } from "./components/booking-calendar.js";
 export type { ConnectBookingCalendarProps } from "./components/booking-calendar.js";
 export { ConnectBookingDialog, ConnectBookingDetail } from "./components/booking-dialogs.js";
-export { useBookableEventTypes, useAvailableSlots, useBookings, useBookingActions, type SlotQuery, type BookingsQuery, } from "./use-scheduling.js";
+export { ConnectAvailabilityFormModal } from "./components/availability-form.js";
+export type { ConnectAvailabilityFormModalProps } from "./components/availability-form.js";
+export { ConnectEventTypeFormModal } from "./components/event-type-form.js";
+export type { ConnectEventTypeFormModalProps } from "./components/event-type-form.js";
+export { useBookableEventTypes, useAvailabilitySchedules, useCreateAvailabilitySchedule, useCreateEventType, useAvailableSlots, useBookings, useBookingActions, type SlotQuery, type BookingsQuery, } from "./use-scheduling.js";
 export { layoutBookings, dayColumns, zonedInstant, type GridWindow, type PositionedBooking, } from "./components/booking-grid.js";