@cosmoops/connect-sdk 0.3.0 → 0.7.0

package/dist/types/client/components/logo.d.ts

@@ -1,12 +1,12 @@
 import type { ReactNode } from "react";
 export interface ConnectLogoProps {
     /**
-     * This service's name - rendered as the sub-brand beneath the `cosmo·ops`
+     * This application's name - rendered as the sub-brand beneath the `cosmo·ops`
      * wordmark, in the house `cosmo·ops VOICE` treatment.
      */
     name: string;
     /**
-     * This service's own glyph, drawn inside the accent badge. Any node - a
+     * This application's own glyph, drawn inside the accent badge. Any node - a
      * `lucide-react` icon, an `<img>`, an inline `<svg>`. Paint it with
      * `currentColor` and it inherits `--accent-foreground` from the badge, so it
      * stays legible when a host app changes the accent.
@@ -19,10 +19,10 @@ export interface ConnectLogoProps {
     className?: string;
 }
 /**
- * The shared platform lockup: a service's own glyph on the CosmoOps badge,
- * `cosmo·ops` beside it, and the service name underneath.
+ * The shared platform lockup: an application's own glyph on the CosmoOps badge,
+ * `cosmo·ops` beside it, and the application name underneath.
  *
- * This is what makes a family of service platforms look like one product. Each
+ * This is what makes a family of application platforms look like one product. Each
  * platform passes only what differs - its `name` and its `icon` - and inherits
  * the mark geometry, the wordmark treatment, the separator, and the accent from
  * one place. Change the lockup here and every platform follows.

package/dist/types/client/components/motion.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from "react";
+export { m, AnimatePresence } from "motion/react";
+/** HeroUI's --ease-out-quart, transcribed for motion transitions. */
+export declare const EASE_OUT_QUART: readonly [0.165, 0.84, 0.44, 1];
+export declare const ENTER: {
+    readonly duration: 0.3;
+    readonly ease: readonly [0.165, 0.84, 0.44, 1];
+};
+export declare const METER_SPRING: {
+    readonly type: "spring";
+    readonly stiffness: 170;
+    readonly damping: 26;
+};
+/**
+ * Per-component motion root. domAnimation keeps the feature bundle small,
+ * `strict` restricts rendering to `m.*` components, and reducedMotion="user"
+ * drops transform animation (keeping opacity) under prefers-reduced-motion -
+ * the same contract HeroUI's own `motion-reduce` styles follow.
+ */
+export declare function MotionProvider({ children }: Readonly<{
+    children: ReactNode;
+}>): import("react").JSX.Element;

package/dist/types/client/components/nav.d.ts

@@ -0,0 +1,110 @@
+import type { ReactNode } from "react";
+/**
+ * One destination in the shell's sidebar.
+ *
+ * `href` is a path in *your* app, not a Connect URL - the shell never
+ * routes anywhere itself, it hands `href` to `renderLink` and lets your
+ * router do the work.
+ */
+export interface ConnectNavItem {
+    label: string;
+    href: string;
+    /**
+     * A pre-rendered glyph, e.g. `<LayoutDashboard className="size-5" />`.
+     * Required in practice for anything in the primary rail: the collapsed rail
+     * is icon-only, and an item with no icon collapses to an empty box.
+     */
+    icon?: ReactNode;
+    /** Trailing content on the row - a count `<Chip>`, a status dot. Hidden while collapsed. */
+    badge?: ReactNode;
+    /**
+     * Match this route only when the path is exactly `href`, never as a prefix.
+     * `/` is always treated as exact regardless, since every path starts with it.
+     */
+    exact?: boolean;
+    /** Opens in a new tab, with a trailing arrow. For docs, status pages, anything outside the app. */
+    external?: boolean;
+    /** One level of children, revealed beneath the parent when the parent or a child is active. */
+    items?: ConnectNavItem[];
+    /**
+     * Leave this route *outside* `ConnectAccessGate` - see
+     * `ConnectAppShellProps.gate`. Declared here, next to the route it applies
+     * to, rather than as a second list somewhere else that has to be kept in
+     * step with this one.
+     */
+    gateExempt?: boolean;
+}
+/** A titled group of items. Untitled groups render as a plain divider-free block. */
+export interface ConnectNavSection {
+    title?: string;
+    items: ConnectNavItem[];
+}
+/**
+ * What `ConnectAppShell`/`ConnectSideNav` accept for `nav`: a flat list of
+ * items, a list of sections, or a mix. Consecutive bare items fold into one
+ * untitled section, so the common case is just an array of items.
+ */
+export type ConnectNav = ReadonlyArray<ConnectNavItem | ConnectNavSection>;
+/** Props the shell hands to `renderLink`. Spread them onto whatever your router's link component is. */
+export interface ConnectNavLinkProps {
+    href: string;
+    className: string;
+    children: ReactNode;
+    onClick?: () => void;
+    "aria-current"?: "page";
+    /**
+     * Always set, and the only name the link has while the rail is collapsed -
+     * spread it through rather than dropping it, or an icon-only rail reads as
+     * a column of unlabelled links.
+     */
+    "aria-label": string;
+    target?: string;
+    rel?: string;
+}
+/**
+ * How this app renders a link.
+ *
+ * The SDK ships into any React app and cannot import `next/link`,
+ * `react-router` or anything else framework-specific, so routing is a prop.
+ * The default is a plain `<a>`, which is correct but costs a full page load;
+ * an app with a client router should pass its own:
+ *
+ * ```tsx
+ * renderLink={(props) => <Link {...props} />}   // next/link
+ * ```
+ */
+export type ConnectLinkRenderer = (props: ConnectNavLinkProps) => ReactNode;
+/** Folds a mixed `ConnectNav` into sections, gathering consecutive bare items into one untitled group. */
+export declare function normalizeNav(nav: ConnectNav): ConnectNavSection[];
+/** Every item in the tree, parents and children alike, in render order. */
+export declare function flattenNav(nav: ConnectNav): ConnectNavItem[];
+/**
+ * `https://x.test/billing/?tab=1#top` -> `/billing`.
+ *
+ * Trailing slashes go too, so `/billing/` and `/billing` are the same route -
+ * they are, to every router, and treating them as different is how a nav item
+ * ends up unhighlighted on exactly one of the two URLs a user can arrive at.
+ */
+export declare function normalizePath(path: string): string;
+/**
+ * The href of the nav item the current path belongs to, or `null`.
+ *
+ * Longest prefix wins, so `/settings/billing` lights up Billing and not also
+ * its parent Settings - a plain `startsWith` over an unordered list lights up
+ * both, and the sidebar grows two highlights.
+ *
+ * External items never match: they leave the app, so no path inside it is
+ * ever "on" them.
+ */
+export declare function resolveActivePath(pathname: string, nav: ConnectNav): string | null;
+/**
+ * Whether `item` is the destination `resolveActivePath` picked.
+ *
+ * Not just `normalizePath(item.href) === activeHref`, which is the trap this
+ * exists to close: `normalizePath` strips the origin off an absolute URL, so
+ * an external item pointed at `https://docs.example.com` normalizes to `/` and
+ * lights up on every app's home route. External items are never active.
+ */
+export declare function isNavItemActive(item: ConnectNavItem, activeHref: string | null): boolean;
+/** Hrefs declared `gateExempt` - the routes `ConnectAppShell` renders outside its `ConnectAccessGate`. */
+export declare function gateExemptPaths(nav: ConnectNav): string[];

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

@@ -4,7 +4,7 @@
  * an upgrade while the card behind it said downgrade would be worse than
  * either label being wrong on its own.
  *
- * Mirrors `packages/data/src/services/catalog.ts` and
+ * Mirrors `packages/data/src/applications/catalog.ts` and
  * `packages/data/src/payments/plan-change.ts`, which are the copies Connect's
  * own UI uses and which decide which use-case actually runs. The duplication
  * is deliberate and load-bearing: this package carries no dependency on
@@ -81,7 +81,7 @@ export declare function groupPlansByTier(plans: readonly Plan[]): PlanTier[];
  */
 export declare function annualSaving(monthly: Plan | null | undefined, annual: Plan | null | undefined): number | null;
 /**
- * What moving to `plan` would be, given what the org is on today.
+ * What moving to `plan` would be, given what the workspace is on today.
  *
  * `switch-to-annual`/`switch-to-monthly` exist because a change of *cadence*
  * is neither an upgrade nor a downgrade, and calling it one is not a wording

package/dist/types/client/components/readiness.d.ts

@@ -6,7 +6,7 @@ export interface ConnectReadinessBannerProps {
     className?: string;
 }
 /**
- * Every gate between this workspace and your service, with the way out of each.
+ * Every gate between this workspace and your application, with the way out of each.
  *
  * This is the component that keeps a blocked customer from staring at a broken
  * app. `getReadiness` resolves subscription state, KYC/KYB, a chargeable
@@ -14,7 +14,7 @@ export interface ConnectReadinessBannerProps {
  * `resolveUrl` into the exact Connect screen that fixes it** - so being blocked
  * comes with somewhere to go rather than a refusal.
  *
- * Render it high on any page your service gates. It draws nothing at all when
+ * Render it high on any page your application gates. It draws nothing at all when
  * the workspace is ready, so it is safe to leave mounted permanently.
  *
  * Two deliberate refusals:

package/dist/types/client/components/side-nav.d.ts

@@ -0,0 +1,31 @@
+import { type ConnectLinkRenderer, type ConnectNav } from "./nav.js";
+/** A plain anchor - correct anywhere, and a full page load. See `ConnectLinkRenderer`. */
+export declare const defaultRenderLink: ConnectLinkRenderer;
+export interface ConnectSideNavProps {
+    /** Items, sections, or a mix - see `ConnectNav`. */
+    nav: ConnectNav;
+    /**
+     * The current path. Pass your router's own (`usePathname()` in Next) -
+     * without it the nav reads `window.location` and patches `history` to hear
+     * about client-side navigations, which works but is guesswork the router
+     * never has to do. See `useActivePath`.
+     */
+    activePath?: string;
+    /** See `ConnectLinkRenderer`. Defaults to a plain `<a>`. */
+    renderLink?: ConnectLinkRenderer;
+    /** Icon-only rail. Labels move into tooltips and children are hidden. */
+    collapsed?: boolean;
+    /** Called after any nav link is pressed - the mobile drawer closes itself with this. */
+    onNavigate?: () => void;
+    className?: string;
+}
+/**
+ * The sidebar's nav column on its own - sections, items, one level of
+ * children, and the active highlight.
+ *
+ * `ConnectAppShell` renders this inside its rail and its mobile drawer, and it
+ * is exported for a host that wants the shell's navigation without its
+ * chrome: the same items, the same active resolution, dropped into a layout
+ * you already have.
+ */
+export declare function ConnectSideNav({ nav, activePath, renderLink, collapsed, onNavigate, className, }: ConnectSideNavProps): import("react").JSX.Element;

package/dist/types/client/components/subscribe-dialog.d.ts

@@ -5,11 +5,11 @@ export interface ConnectSubscribeDialogProps {
     plan: Plan | null;
     /** Which of subscribe / upgrade / downgrade this is - decides the headline and what the notice says about money. */
     action: PlanAction;
-    /** The org's live subscription, for the "from" side of a plan change. */
+    /** The workspace's live subscription, for the "from" side of a plan change. */
     current: SubscriptionResponse | null;
     /** Coupon typed into the plan grid, echoed here so it is visible before the hand-off carries it. */
     coupon?: string;
-    /** Whether this org's `plan.trialDays` still applies is Connect's call, not this component's - see the notice below. */
+    /** Whether this workspace's `plan.trialDays` still applies is Connect's call, not this component's - see the notice below. */
     onClose(): void;
     onConfirm(): void;
 }
@@ -26,7 +26,7 @@ export interface ConnectSubscribeDialogProps {
  * The authoritative price is computed by Connect against the real cart:
  * proration is priced against the actual cycle, a coupon is validated
  * against the plan it is being applied to, trial eligibility depends on
- * whether this organization has ever subscribed to this service before, and
+ * whether this workspace has ever subscribed to this application before, and
  * an accumulated credit is deducted. None of that is knowable from the
  * partner's origin, so this component states the list price and says where
  * the final figure comes from rather than quietly guessing at one.

package/dist/types/client/components/surfaces.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The one elevation model every panel inside a Connect modal follows.
+ *
+ * This exists because "just use `bg-surface`" is wrong here, and wrong in a
+ * way that is invisible until you look at the tokens. `Modal.Dialog` paints
+ * itself `bg-overlay`, and in the shared theme (`theme.css`) `--overlay` and
+ * `--surface` sit at the *same lightness* in both schemes - 100% against 100%
+ * in light, 21% against 21% in dark. A `bg-surface` panel dropped on a modal
+ * therefore has no fill contrast at all; only its border separates it from
+ * the dialog behind it.
+ *
+ * That is how the account modal ended up looking half-finished: the identity
+ * card used `bg-surface-secondary` and read as a solid block, while the
+ * destination tiles and the session list used `bg-surface` and read as
+ * hairline outlines floating on nothing. Same nesting depth, two different
+ * physical materials, for no reason a user could infer.
+ *
+ * Three levels, and nesting one inside another always steps the fill:
+ *
+ * - **L0 - the dialog itself.** `bg-overlay`, owned by HeroUI. Not ours.
+ * - **L1 - a panel on the dialog.** `PANEL_FILL` + `border-border`. The
+ *   identity card, each destination tile, the session list.
+ * - **L2 - a medallion inside a panel.** `bg-surface`, which is L0's value
+ *   and therefore reads as *inset* against L1 rather than raised. Light:
+ *   white on grey. Dark: near-black on charcoal. Both directions legible.
+ *
+ * The inversion at L2 is deliberate and is why this is written down. Reaching
+ * for a "lighter" fill one step down works in light mode and quietly fails in
+ * dark; stepping *back to the dialog's own value* is the trick that reads in
+ * both, because the contrast comes from the gap between L1 and L0 rather than
+ * from a direction of travel.
+ */
+export declare const PANEL_FILL = "bg-surface-secondary";
+/**
+ * The icon well shared by destination tiles and session rows: a 40px box
+ * holding a 20px glyph.
+ *
+ * Half the well, which is the point. Both surfaces used to run a `size-4`
+ * (16px) icon inside a `size-9` (36px) well - a 44% fill that reads as an
+ * icon someone forgot to finish, and the specific thing that made the
+ * Profile/Billing/Connect tiles look under-drawn. They also disagreed on
+ * shape (a circle in the tiles, a rounded square in the session rows) for
+ * what is the same component role, so the two surfaces never looked related.
+ *
+ * Pair with `ICON` on the glyph inside. Session rows override the well to
+ * `size-9` for density but keep the same `ICON`, so glyph size stays constant
+ * across the whole modal even where the well does not.
+ */
+export declare const MEDALLION = "size-10";
+/** The glyph inside a `MEDALLION`. Constant across every well in the modal - see `MEDALLION`. */
+export declare const ICON = "size-5";

package/dist/types/client/components/usage-meter.d.ts

@@ -11,7 +11,7 @@ export interface ConnectUsageMeterProps {
  *
  * Reads the balance Connect actually debits, so the number here and the number
  * `consumeAddon` enforces cannot disagree. Before the `addons:read` endpoint
- * existed this component was impossible to write honestly: a service could
+ * existed this component was impossible to write honestly: an application could
  * spend an allowance down on every request and the only thing the API exposed
  * was the list of add-on *ids* on the subscription.
  *

package/dist/types/client/components/user-menu.d.ts

@@ -26,7 +26,7 @@ export interface ConnectUserMenuProps {
  * in place, which is why it sits alone in the footer rather than as a fourth
  * item in the same list as three navigations.
  *
- * The session list is account-wide, not scoped to this service - see
+ * The session list is account-wide, not scoped to this application - see
  * `ConnectUserSession`'s doc comment in `types.ts`. Appearance only renders
  * when both `theme` and `onThemeChange` are supplied.
  *
@@ -55,7 +55,7 @@ export declare function ConnectManageSubscriptionButton({ className }: Readonly<
  * Invoices and payment history, on Connect.
  *
  * A deep link rather than a component that lists them, and that is not a
- * placeholder: nothing in `/api/v1/service/*` exposes invoices, so an SDK-side
+ * placeholder: nothing in `/api/v1/application/*` exposes invoices, so an SDK-side
  * list would have nothing to read. It is also the right answer regardless -
  * a GST tax invoice is a legal document with a fixed format, downloadable and
  * emailed from one place, and a partner-rendered copy of one would be a second

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

@@ -7,10 +7,10 @@
  *
  * Styling is HeroUI v3 semantic tokens only (`accent`, `muted`, `surface`,
  * `separator`, ...), never a hardcoded colour - so these components inherit
- * whatever theme the host service platform already configured, and one theme
+ * whatever theme the host application platform already configured, and one theme
  * change lands identically in all of them.
  */
-export { ConnectProvider, useConnect, useConnectUser, useConnectEntitlements, useConnectPlans, useConnectApps, useConnectAddonUsage, useConnectSessions, useConnectResource, CONNECT_APP_URL, } from "./provider.js";
+export { ConnectProvider, useConnect, useConnectUser, useConnectEntitlements, useConnectPlans, useConnectApps, useConnectAddonUsage, useConnectSessions, useConnectIntegrations, useConnectResource, CONNECT_APP_URL, } from "./provider.js";
 export type { ConnectProviderProps, ConnectContextValue, ConnectSession } from "./provider.js";
 export { blockingBlockers, normalizePlanFeatures } from "../helpers.js";
 export type { WirePlanFeature } from "../helpers.js";
@@ -25,8 +25,17 @@ export { ConnectUserMenu, ConnectManageSubscriptionButton, ConnectInvoicesButton
 export { ConnectAccountSessions } from "./components/account-sessions.js";
 export type { ConnectAccountSessionsProps } from "./components/account-sessions.js";
 export type { ConnectUserMenuProps } from "./components/user-menu.js";
+export { ConnectAppShell } from "./components/app-shell.js";
+export type { ConnectAppShellProps } from "./components/app-shell.js";
+export { ConnectSideNav } from "./components/side-nav.js";
+export type { ConnectSideNavProps } from "./components/side-nav.js";
+export { useActivePath } from "./use-active-path.js";
+export { normalizeNav, flattenNav, normalizePath, resolveActivePath, isNavItemActive, gateExemptPaths, } from "./components/nav.js";
+export type { ConnectNav, ConnectNavItem, ConnectNavSection, ConnectNavLinkProps, ConnectLinkRenderer, } from "./components/nav.js";
 export { ConnectAppsGrid } from "./components/apps-grid.js";
 export type { ConnectAppsGridProps } from "./components/apps-grid.js";
+export { ConnectIntegrationsModal } from "./components/integrations-modal.js";
+export type { ConnectIntegrationsModalProps } from "./components/integrations-modal.js";
 export { ConnectPlans } from "./components/plans.js";
 export type { ConnectPlansProps } from "./components/plans.js";
 export { ConnectSubscribeDialog } from "./components/subscribe-dialog.js";
@@ -35,6 +44,8 @@ export { ConnectSubscriptionGate, ConnectNoSubscriptionCard, ConnectSubscription
 export type { ConnectSubscriptionGateProps, ConnectNoSubscriptionCardProps, ConnectSubscriptionCardProps, ConnectTrialBannerProps, ConnectSubscriptionState, } from "./components/subscription.js";
 export { ConnectReadinessBanner, ConnectReadinessGate } from "./components/readiness.js";
 export type { ConnectReadinessBannerProps, ConnectReadinessGateProps } from "./components/readiness.js";
+export { ConnectAccessGate, useConnectAccessGate } from "./components/access-gate.js";
+export type { ConnectAccessGateProps, ConnectAccessGateState, ConnectAccessGateResult, } from "./components/access-gate.js";
 export { ConnectFeatureGate, useConnectFeature } from "./components/feature-gate.js";
 export type { ConnectFeatureGateProps } from "./components/feature-gate.js";
 export { ConnectUsageMeter } from "./components/usage-meter.js";

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

@@ -2,7 +2,7 @@
  * The Connect mark - concentric rings on a solid accent badge.
  *
  * Painted from `--accent` / `--accent-foreground`, the same HeroUI tokens the
- * host app themes, so the badge tracks whatever palette a service platform has
+ * host app themes, so the badge tracks whatever palette an application platform has
  * configured rather than carrying a hardcoded CosmoOps green into someone
  * else's brand.
  */

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

@@ -1,10 +1,10 @@
 import type { ReactNode } from "react";
-import type { AddonUsageResponse, ConnectUser, OrganizationApp, PlansResponse, ReadinessResponse, ServiceRole, SessionsListResponse, SessionSubscription, SubscriptionResponse } from "../types.js";
+import type { AddonUsageResponse, ConnectUser, IntegrationsListResponse, WorkspaceApp, PlansResponse, ReadinessResponse, ApplicationRole, SessionsListResponse, SessionSubscription, SubscriptionResponse } from "../types.js";
 export declare const CONNECT_APP_URL = "https://connect.cosmoops.com";
 export interface ConnectSession {
     user: ConnectUser | null;
     subscription: SessionSubscription | null;
-    serviceRole: ServiceRole | null;
+    applicationRole: ApplicationRole | null;
 }
 export interface ConnectContextValue {
     /**
@@ -61,7 +61,7 @@ export interface ConnectContextValue {
 }
 export interface ConnectProviderProps {
     /**
-     * This service's public `client_id`, from its Setup tab in Connect.
+     * This application's public `client_id`, from its Integration tab in Connect.
      *
      * Not needed for the default sign-in flow: `signIn()` with no `redirectUri`
      * bounces the browser to your own `/signin` route, which already knows
@@ -87,6 +87,27 @@ export interface ConnectProviderProps {
      * child effects.
      */
     fetch?: (input: string, init?: RequestInit) => Promise<Response>;
+    /**
+     * Sign in a returning visitor automatically, with no click.
+     *
+     * When the first `/session` read comes back signed out, the browser is sent
+     * on one round trip to Connect with OIDC `prompt=none`. If they still have
+     * a Connect session and have authorised this app before, they come straight
+     * back signed in and never see a screen. If not, they come straight back
+     * signed out, with no error and nothing rendered differently - your normal
+     * signed-out UI just appears a beat later.
+     *
+     * **Off by default, and it is a real trade, not just caution.** It costs a
+     * full-page redirect on the first load of every signed-out visit - a brief
+     * flash on a marketing page, invisible on an app shell - so it belongs on
+     * apps whose visitors are overwhelmingly already Connect users. It is
+     * attempted at most once per tab (a `sessionStorage` marker), so a visitor
+     * who genuinely has no session does not bounce on every navigation.
+     *
+     * Requires `createConnectHandler` mounted at `basePath`; the redirect goes
+     * to your own `/signin`, which mints the `state` server-side.
+     */
+    silentSignIn?: boolean;
     children: ReactNode;
 }
 /**
@@ -103,7 +124,7 @@ export interface ConnectProviderProps {
  * </ConnectProvider>
  * ```
  */
-export declare function ConnectProvider({ clientId, basePath, redirectUri, appUrl, fetch: fetchImpl, children, }: ConnectProviderProps): import("react").JSX.Element;
+export declare function ConnectProvider({ clientId, basePath, redirectUri, appUrl, fetch: fetchImpl, silentSignIn, children, }: ConnectProviderProps): import("react").JSX.Element;
 export declare function useConnect(): ConnectContextValue;
 /** The signed-in user, or `null`. Sugar over `useConnect().session`. */
 export declare function useConnectUser(): ConnectUser | null;
@@ -127,7 +148,7 @@ export declare function useConnectEntitlements(): {
 /**
  * What is left of every consumable add-on on this workspace's subscription.
  *
- * The read half of `client.billing.consumeAddon` - a service that meters its
+ * The read half of `client.billing.consumeAddon` - an application that meters its
  * own end users had no way to show them what remained until this existed.
  * Empty `addons` means there is nothing to meter, which is not an error.
  */
@@ -144,7 +165,7 @@ export declare function useConnectAddonUsage(): {
      */
     refetch(): void;
 };
-/** This service's plan catalog. */
+/** This application's plan catalog. */
 export declare function useConnectPlans(): {
     data: PlansResponse | null;
     isLoading: boolean;
@@ -158,10 +179,10 @@ export declare function useConnectPlans(): {
      */
     refetch(): void;
 };
-/** The apps this organization can open. */
+/** The apps this workspace can open. */
 export declare function useConnectApps(): {
     data: {
-        apps: OrganizationApp[];
+        apps: WorkspaceApp[];
     } | null;
     isLoading: boolean;
     error: string | null;
@@ -174,9 +195,23 @@ export declare function useConnectApps(): {
      */
     refetch(): void;
 };
+/** Enabled Composio-hosted toolkits and this workspace's connection status for each. */
+export declare function useConnectIntegrations(): {
+    data: IntegrationsListResponse | null;
+    isLoading: boolean;
+    error: string | null;
+    /**
+     * Forces a fresh read - the provider's cache clears the mutated path's
+     * entry on a successful `mutateResource` call, but nothing re-triggers
+     * this hook's own effect on its own (none of its dependencies change from
+     * a cache write nobody here observes). Call this right after a
+     * `mutateResource` you made against the same `path` completes.
+     */
+    refetch(): void;
+};
 /**
  * This Connect account's own login sessions - account-wide, not scoped to
- * this service, see `SessionsListResponse`'s doc comment. The component
+ * this application, see `SessionsListResponse`'s doc comment. The component
  * that calls this is also the one that must own any revoke actions and call
  * the returned `refetch()` afterward - see `mutateResource`'s doc comment
  * for why nothing does that automatically.

package/dist/types/client/use-active-path.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The current path, from `activePath` when given and from the browser
+ * otherwise.
+ *
+ * Exported because a host building its own shell out of `ConnectSideNav`
+ * needs the same fallback the shell uses.
+ */
+export declare function useActivePath(activePath?: string): string;

package/dist/types/client/use-checkout.d.ts

@@ -57,7 +57,7 @@ export declare function useConnectCheckout(): ConnectCheckoutState & {
 export interface CheckoutUrlOptions {
     /** Connect's origin, from `useConnect().appUrl`. */
     appUrl: string;
-    serviceId: string;
+    applicationId: string;
     planId: string;
     /**
      * The live subscription's id, when there is one. Present means "change the
@@ -85,9 +85,9 @@ export declare function buildCancelUrl({ appUrl, subscriptionId }: {
  * The Connect URL that completes a subscribe or a plan change.
  *
  * Both land on a modal Connect renders over the relevant page (an intercepted
- * parallel route - `app/@modal/(.)services/...` and
+ * parallel route - `app/@modal/(.)applications/...` and
  * `app/@modal/(.)billing/...`), so the customer arrives already looking at the
  * confirmation for the plan they picked here, not at a catalogue they have to
  * find it in again.
  */
-export declare function buildCheckoutUrl({ appUrl, serviceId, planId, subscriptionId, coupon, }: CheckoutUrlOptions): string;
+export declare function buildCheckoutUrl({ appUrl, applicationId, planId, subscriptionId, coupon, }: CheckoutUrlOptions): string;

package/dist/types/errors.d.ts

@@ -1,8 +1,8 @@
 /**
- * Every failure the Connect service API can report, as one class.
+ * Every failure the Connect application API can report, as one class.
  *
  * The API speaks two error dialects and this collapses them: the
- * `/api/v1/service/*` endpoints use `{ error: { code, message } }`, while the
+ * `/api/v1/application/*` endpoints use `{ error: { code, message } }`, while the
  * three `/sso/*` ones use OAuth2's `{ error, error_description }` (RFC 6749
  * §5.2). Both land here with `code` populated, so integrating code branches on
  * one field either way.
@@ -40,7 +40,7 @@ export declare class ConnectError extends Error {
      * Whether the user's Connect sign-in is over and they need to go back
      * through `identity.authorizeUrl()`. Collapses every session-side failure,
      * matching how the API reports them - unknown, expired, revoked, or issued
-     * to a different service all arrive as one `invalid_token`.
+     * to a different application all arrive as one `invalid_token`.
      */
     get isSessionExpired(): boolean;
     /**
@@ -52,7 +52,7 @@ export declare class ConnectError extends Error {
      * guessing keys. These two are the exception: reaching them required
      * presenting a key whose hash matched, so you already hold it, and what you
      * need to know is that no retry and no scope change will fix this - the key
-     * has to be reissued from the service's Setup tab.
+     * has to be reissued from the application's Integration tab.
      *
      * Worth alerting on. It is the one failure that will not resolve itself and
      * takes down every call your integration makes.

package/dist/types/helpers.d.ts

@@ -21,7 +21,7 @@ export type WirePlanFeature = string | PlanFeature;
  * Coerces either wire shape into `PlanFeature[]`.
  *
  * A bare key becomes `{ key, name: key, description: "" }` - the same
- * fallback the server applies for a plan older than its service's feature
+ * fallback the server applies for a plan older than its application's feature
  * catalog, so an un-upgraded Connect renders exactly what it always did
  * rather than a column of blanks.
  *

package/dist/types/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * `@cosmoops/connect-sdk` - the official client for the CosmoOps Connect
- * **service-partner API** (`/api/v1/service/*`).
+ * **application-partner API** (`/api/v1/application/*`).
  *
  * This root entry is the isomorphic surface: wire types, the error class, and
  * pure helpers. It pulls in neither Node-only code nor React, so it is safe to

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

@@ -81,6 +81,9 @@ export { handle as GET, handle as POST };
  * if (!session) redirect("/api/connect/signin?next=/dashboard");
  * ```
  *
+ * `requireConnectSession()` below is that exact check in one call, for the
+ * common case of "redirect if signed out."
+ *
  * Pass a `Request` to use it somewhere `next/headers` does not exist - a
  * framework-agnostic handler, a test, a custom server. Both forms take the
  * same path afterwards; the argument is only how the cookie is found.
@@ -92,11 +95,48 @@ export { handle as GET, handle as POST };
  *
  * Returns `null` for every failure - an expired session and a missing one both
  * mean "not signed in", and a page guard should not need a try/catch.
+ *
+ * **Memoized per request for the plain, zero-argument call** - the shape
+ * every page, layout and Server Action actually uses - via React's `cache()`.
+ * Passing an explicit `request`, `client` or `session` bypasses the cache
+ * and always makes a live call: those are for tests and non-ambient
+ * callers, where a fresh read every time is the point, not an oversight.
  */
 export declare function getConnectSession(request?: Request, options?: {
     client?: ConnectClient;
     session?: ConnectSessionStore;
 }): Promise<UserResponse | null>;
+/**
+ * `getConnectSession()`, minus the boilerplate of checking it and redirecting
+ * yourself:
+ *
+ * ```tsx
+ * // app/dashboard/page.tsx
+ * const session = await requireConnectSession();
+ * ```
+ *
+ * Redirects to `/signin` under the same `basePath` as `getConnectSession`'s
+ * default (`/api/connect`) when signed out - pass `signInPath` if you mounted
+ * the bridge somewhere else, and `next` to send the visitor back to where
+ * they were once they're signed in. Only sensible in a Server Component,
+ * Route Handler or Server Action, the same three places `redirect()` from
+ * `next/navigation` itself works.
+ *
+ * A thin wrapper, not a framework of its own - reach for `getConnectSession`
+ * plus your own check when "not signed in" isn't "redirect to sign-in"
+ * (an API route returning 401, say). Role and entitlement checks stay
+ * outside this function on purpose: `session.applicationRole.granted` and
+ * `connect.entitlements.*` are one line each on top of the session this
+ * already gives you, and where that line redirects (a plans page, a
+ * "forbidden" screen) is a decision only your app can make - see
+ * "Authentication & authorization" for the pattern.
+ */
+export declare function requireConnectSession(request?: Request, options?: {
+    client?: ConnectClient;
+    session?: ConnectSessionStore;
+    signInPath?: string;
+    next?: string;
+}): Promise<UserResponse>;
 export { createConnectHandler } from "../server/handler.js";
 export type { ConnectSessionStore } from "../server/handler.js";
 export { ConnectClient } from "../server/client.js";