@kortix/ui 0.14.8 → 0.14.10

package/dist/internal/connector-logo/connector-logo.js

@@ -0,0 +1,56 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { EnvelopeSimpleIcon, MonitorIcon, PlugIcon } from '@phosphor-icons/react';
+import { useState } from 'react';
+import { MicrosoftTeams } from '../icons/microsoft-teams.js';
+import { Slack } from '../icons/slack.js';
+import { Telegram } from '../icons/telegram.js';
+import { cn } from '../lib/utils.js';
+import { resolveConnectorLogo, } from './connector-logo-source.js';
+const TILE = {
+    xs: 'size-5 rounded-sm',
+    sm: 'size-6 rounded-sm',
+    md: 'size-8 rounded-md',
+    lg: 'size-9 rounded-md',
+    xl: 'size-14 rounded-xl',
+};
+const MARK = { xs: 'size-3', sm: 'size-3.5', md: 'size-4', lg: 'size-5', xl: 'size-7' };
+/**
+ * The marks of the Kortix-built connectors, as their channel banners draw
+ * them; brand marks keep their colours. `apps/web/public/connector-icons/<app>.svg`
+ * is this mark rendered on its tile (`connector-mark-files.tsx`), so the URL
+ * the API catalogue sends and this component are one image.
+ */
+export const NATIVE_MARK = {
+    slack: { Mark: Slack, brand: true },
+    teams: { Mark: MicrosoftTeams, brand: true },
+    telegram: { Mark: Telegram, brand: true },
+    email: { Mark: EnvelopeSimpleIcon, brand: false },
+    computer: { Mark: MonitorIcon, brand: false },
+};
+/** The tile a mark sits on: the channel banner's (background, hairline border). */
+function MarkTile({ size, className, children, }) {
+    return (_jsx("span", { "aria-hidden": true, className: cn('bg-background flex shrink-0 items-center justify-center border', TILE[size], className), children: children }));
+}
+/**
+ * A connector's logo — the only one. Every connector, app and account surface
+ * renders this, so the same app shows the same mark everywhere
+ * (`connector-logo-source.ts` holds the rule).
+ *
+ * Kortix-built connectors and connectors with no logo draw a mark on the
+ * banner tile. A catalogue logo is the bare image: its own shape is the edge.
+ * A URL that fails to load latches per URL (a swapped URL gets a fresh try)
+ * and shows the neutral fallback, so "missing" and "broken" look identical.
+ */
+export function ConnectorLogo({ source, size = 'lg', className, }) {
+    const logo = resolveConnectorLogo(source);
+    const [failedUrl, setFailedUrl] = useState(null);
+    if (logo.kind === 'native') {
+        const { Mark, brand } = NATIVE_MARK[logo.app];
+        return (_jsx(MarkTile, { size: size, className: className, children: _jsx(Mark, { className: cn('shrink-0', MARK[size], !brand && 'text-muted-foreground') }) }));
+    }
+    if (logo.kind === 'none' || failedUrl === logo.src) {
+        return (_jsx(MarkTile, { size: size, className: className, children: _jsx(PlugIcon, { className: cn('text-muted-foreground shrink-0', MARK[size]) }) }));
+    }
+    return (_jsx("span", { "aria-hidden": true, className: cn('flex shrink-0 items-center justify-center overflow-hidden', TILE[size], className), children: _jsx("img", { src: logo.src, alt: "", loading: "lazy", decoding: "async", referrerPolicy: "no-referrer", draggable: false, className: cn('size-full object-contain select-none', TILE[size]), onError: () => setFailedUrl(logo.src) }) }));
+}

package/dist/internal/connector-logo/connector-mark-files.d.ts

@@ -0,0 +1,11 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+import type { NativeConnectorApp } from './connector-logo-source.js';
+/**
+ * The SVG file for a Kortix-built connector's logo
+ * (`apps/web/public/connector-icons/<app>.svg`): its `ConnectorLogo` mark on
+ * the tile, rendered from the same component. Written by
+ * `scripts/write-connector-marks.tsx`; `connector-mark-files.test.ts` fails
+ * when a committed file and this output differ.
+ */
+export declare function nativeMarkFileSvg(app: NativeConnectorApp): string;
+export declare const NATIVE_MARK_APPS: NativeConnectorApp[];

package/dist/internal/connector-logo/connector-mark-files.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { renderToStaticMarkup } from 'react-dom/server';
+import { NATIVE_MARK } from './connector-logo.js';
+/** `MarkTile`'s look, as a file: white ground, hairline border, rounded corners. */
+const TILE_FILL = '#FFFFFF';
+const TILE_BORDER = '#E4E4E7';
+/** `text-muted-foreground` on the light ground, for the glyph marks. */
+const GLYPH_COLOR = '#71717A';
+const LABEL = {
+    slack: 'Slack',
+    teams: 'Microsoft Teams',
+    telegram: 'Telegram',
+    email: 'Email',
+    computer: 'Computer',
+};
+/**
+ * The SVG file for a Kortix-built connector's logo
+ * (`apps/web/public/connector-icons/<app>.svg`): its `ConnectorLogo` mark on
+ * the tile, rendered from the same component. Written by
+ * `scripts/write-connector-marks.tsx`; `connector-mark-files.test.ts` fails
+ * when a committed file and this output differ.
+ */
+export function nativeMarkFileSvg(app) {
+    const { Mark, brand } = NATIVE_MARK[app];
+    const markup = renderToStaticMarkup(_jsx(Mark, {}));
+    const open = markup.slice(0, markup.indexOf('>'));
+    // The mark's own size and class give way to its place on the tile.
+    const placed = open.replace(/ (?:class|width|height)="[^"]*"/g, '').replace(/^<svg/, '<svg x="8" y="8" width="20" height="20"');
+    const mark = (placed + markup.slice(open.length))
+        .replaceAll('currentColor', brand ? 'currentColor' : GLYPH_COLOR);
+    return (`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 36 36" role="img" aria-label="${LABEL[app]}">` +
+        `<rect x="0.5" y="0.5" width="35" height="35" rx="7.5" fill="${TILE_FILL}" stroke="${TILE_BORDER}"/>` +
+        `${mark}</svg>\n`);
+}
+export const NATIVE_MARK_APPS = Object.keys(LABEL);

package/dist/internal/files/file-read-retry.d.ts

@@ -25,4 +25,17 @@ export declare const SANDBOX_PARKED_REFETCH_INTERVAL_MS = 30000;
  * the file appears on its own in seconds. A parked box takes the slow lane.
  */
 export declare function sandboxWakingRefetchInterval(error: unknown, parked: boolean): number | false;
+/** The image wait's polls (R38): 1, 2, 4, 8 s, then every 10 s, about 2 min in all. */
+export declare const IMAGE_WAKING_ATTEMPTS = 15;
+/**
+ * The poll interval of an image read while the session runtime is still
+ * starting (`isRuntimeStartingError`), after its `failures`-th failed read:
+ * 1 s doubling to a 10 s cap; `false` (stop) after `IMAGE_WAKING_ATTEMPTS`,
+ * when the tile says the image is unavailable and offers Try again; `false`
+ * for any other error. A file viewer keeps `sandboxWakingRefetchInterval`
+ * (a parked box can take longer than an image tile should wait).
+ */
+export declare function imageWakingRefetchInterval(error: unknown, failures: number): number | false;
+/** True once an image read gave up waiting for the runtime (`imageWakingRefetchInterval`). */
+export declare function imageWaitedOut(error: unknown, failures: number): boolean;
 export declare function shouldRetryFileRead(filePath: string | null | undefined, failureCount: number, error: unknown): boolean;

package/dist/internal/files/file-read-retry.js

@@ -1,4 +1,4 @@
-import { isSandboxNotReadyError } from '@kortix/sdk';
+import { isRuntimeStartingError } from '@kortix/sdk';
 export const UPLOADED_FILE_READ_RETRY_DELAY_MS = 2_000;
 export const UPLOADED_FILE_READ_RETRY_WINDOW_MS = 60_000;
 export const UPLOADED_FILE_READ_MAX_RETRIES = Math.ceil(UPLOADED_FILE_READ_RETRY_WINDOW_MS / UPLOADED_FILE_READ_RETRY_DELAY_MS);
@@ -87,16 +87,36 @@ export const SANDBOX_PARKED_REFETCH_INTERVAL_MS = 30_000;
  * the file appears on its own in seconds. A parked box takes the slow lane.
  */
 export function sandboxWakingRefetchInterval(error, parked) {
-    if (!isSandboxNotReadyError(error))
+    // Also the runtime URL not pinned yet ("Server URL not ready"): it clears on its own too.
+    if (!isRuntimeStartingError(error))
         return false;
     return parked ? SANDBOX_PARKED_REFETCH_INTERVAL_MS : SANDBOX_WAKING_REFETCH_INTERVAL_MS;
 }
+/** The image wait's polls (R38): 1, 2, 4, 8 s, then every 10 s, about 2 min in all. */
+export const IMAGE_WAKING_ATTEMPTS = 15;
+/**
+ * The poll interval of an image read while the session runtime is still
+ * starting (`isRuntimeStartingError`), after its `failures`-th failed read:
+ * 1 s doubling to a 10 s cap; `false` (stop) after `IMAGE_WAKING_ATTEMPTS`,
+ * when the tile says the image is unavailable and offers Try again; `false`
+ * for any other error. A file viewer keeps `sandboxWakingRefetchInterval`
+ * (a parked box can take longer than an image tile should wait).
+ */
+export function imageWakingRefetchInterval(error, failures) {
+    if (!isRuntimeStartingError(error) || failures > IMAGE_WAKING_ATTEMPTS)
+        return false;
+    return Math.min(1000 * 2 ** Math.max(0, failures - 1), 10_000);
+}
+/** True once an image read gave up waiting for the runtime (`imageWakingRefetchInterval`). */
+export function imageWaitedOut(error, failures) {
+    return isRuntimeStartingError(error) && failures > IMAGE_WAKING_ATTEMPTS;
+}
 export function shouldRetryFileRead(filePath, failureCount, error) {
     // A parked/booting sandbox is not a failed read. Fail fast out of the inline
     // retry loop so the viewer can render its "waking up" state immediately; the
     // query-level poll (SANDBOX_WAKING_REFETCH_INTERVAL_MS) re-reads until the
     // sandbox is back.
-    if (isSandboxNotReadyError(error))
+    if (isRuntimeStartingError(error))
         return false;
     if (isUploadedWorkspacePath(filePath)) {
         if (isPermanentFileReadFailure(error) && !isMissingFileReadFailure(error))

package/dist/internal/files/session-drive-files.d.ts

@@ -37,7 +37,11 @@ interface DriveFilesScope {
     sessionId: string;
     queryClient: QueryClient;
 }
-/** Make `next` the session drive paths resolve against; returns its undo. */
+/**
+ * Make `next` the session drive paths resolve against; returns its undo. The
+ * undo restores the scope it replaced: a review item's files open over a
+ * session page, and closing them must not drop that page's scope.
+ */
 export declare function setSessionDriveFilesScope(next: DriveFilesScope): () => void;
 /** Make the open session's mounts the ones drive paths resolve against. */
 export declare function useSessionDriveFilesScope(projectId: string, sessionId: string): void;

package/dist/internal/files/session-drive-files.js

@@ -38,12 +38,17 @@ export function resolveSessionDriveFile(filePath, mounts) {
     return { driveId: best.driveId, path: `${stripTrailingSlashes(best.subdir)}${rest}` || '/' };
 }
 let scope = null;
-/** Make `next` the session drive paths resolve against; returns its undo. */
+/**
+ * Make `next` the session drive paths resolve against; returns its undo. The
+ * undo restores the scope it replaced: a review item's files open over a
+ * session page, and closing them must not drop that page's scope.
+ */
 export function setSessionDriveFilesScope(next) {
+    const previous = scope;
     scope = next;
     return () => {
         if (scope === next)
-            scope = null;
+            scope = previous;
     };
 }
 /** Make the open session's mounts the ones drive paths resolve against. */

package/dist/internal/hooks/channels/use-channels-installations.d.ts

@@ -1,6 +1,6 @@
 /** @internal Kortix apps only. No semver: it may change in any release. */
-import { type EmailInstallation, type EmailMode, type EmailSenderPolicy, type SlackInstallation, type SlackMode, type ConnectTelegramInput, type TelegramInstallation } from '@kortix/sdk';
-export type { EmailInstallation, EmailMode, EmailSenderPolicy, SlackInstallation, SlackMode, TelegramInstallation };
+import { type EmailDomain, type EmailDomainList, type EmailDomainResult, type EmailInstallation, type EmailMode, type EmailSenderPolicy, type SlackInstallation, type SlackMode, type ConnectTelegramInput, type TelegramInstallation, type ChannelAccessList, type ChannelAccessPlatform, type ChannelUser } from '@kortix/sdk';
+export type { EmailDomain, EmailDomainList, EmailDomainResult, EmailInstallation, EmailMode, EmailSenderPolicy, SlackInstallation, SlackMode, TelegramInstallation, ChannelAccessPlatform, ChannelUser, };
 export declare function useSlackInstall(projectId: string | null): import("@tanstack/react-query").UseQueryResult<SlackInstallation | null, Error>;
 interface ConnectInput {
     projectId: string;
@@ -25,6 +25,21 @@ interface ConnectEmailInput {
     sender_policy?: EmailSenderPolicy;
 }
 export declare function useConnectEmail(): import("@tanstack/react-query").UseMutationResult<EmailInstallation, Error, ConnectEmailInput, unknown>;
+/** The domains an own Resend API key can create inboxes on. A mutation: it runs when the user enters a key. */
+export declare function useListEmailDomains(): import("@tanstack/react-query").UseMutationResult<EmailDomainList, Error, {
+    projectId: string;
+    apiKey: string;
+}, unknown>;
+export declare function useAddEmailDomain(): import("@tanstack/react-query").UseMutationResult<EmailDomainResult, Error, {
+    projectId: string;
+    apiKey: string;
+    domain: string;
+}, unknown>;
+export declare function useVerifyEmailDomain(): import("@tanstack/react-query").UseMutationResult<EmailDomainResult, Error, {
+    projectId: string;
+    apiKey: string;
+    domainId: string;
+}, unknown>;
 export declare function useDisconnectEmail(): import("@tanstack/react-query").UseMutationResult<{
     projectId: string;
     connectorSlug: string | null | undefined;
@@ -37,13 +52,25 @@ export declare function useUpdateEmailPolicy(): import("@tanstack/react-query").
     connectorSlug?: string | null;
     sender_policy: EmailSenderPolicy;
 }, unknown>;
-/** The project's Telegram bot (connectors_v2). Pass null to keep the query off. */
+/** The project's Telegram bot. Pass null to keep the query off. */
 export declare function useTelegramInstall(projectId: string | null): import("@tanstack/react-query").UseQueryResult<TelegramInstallation | null, Error>;
 export declare function useConnectTelegram(): import("@tanstack/react-query").UseMutationResult<TelegramInstallation, Error, {
     projectId: string;
 } & ConnectTelegramInput, unknown>;
-export declare function useSetTelegramAllowedUsers(): import("@tanstack/react-query").UseMutationResult<TelegramInstallation, Error, {
+/** Allowed users and access requests, with their names on the platform. Each fetch can call the platform, so enable it only on demand. */
+export declare function useChannelUsers(projectId: string, platform: ChannelAccessPlatform, enabled: boolean): import("@tanstack/react-query").UseQueryResult<import("@kortix/sdk").ChannelUsers, Error>;
+/** One user's profile photo. Off without a `version`: that user has no photo. */
+export declare function useChannelUserPhoto(projectId: string, platform: ChannelAccessPlatform, userId: string, version: string | null, enabled: boolean): import("@tanstack/react-query").UseQueryResult<Blob | null, Error>;
+export declare const useAllowChannelUser: (platform: ChannelAccessPlatform) => import("@tanstack/react-query").UseMutationResult<ChannelAccessList, Error, {
+    projectId: string;
+    userId: string;
+}, unknown>;
+export declare const useRemoveChannelUser: (platform: ChannelAccessPlatform) => import("@tanstack/react-query").UseMutationResult<ChannelAccessList, Error, {
+    projectId: string;
+    userId: string;
+}, unknown>;
+export declare const useDismissChannelAccessRequest: (platform: ChannelAccessPlatform) => import("@tanstack/react-query").UseMutationResult<ChannelAccessList, Error, {
     projectId: string;
-    userIds: string[];
+    userId: string;
 }, unknown>;
 export declare function useDisconnectTelegram(): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;

package/dist/internal/hooks/channels/use-channels-installations.js

@@ -1,5 +1,5 @@
 'use client';
-import { connectEmail, connectSlack, connectTelegram, disconnectEmail, disconnectSlack, disconnectTelegram, getEmailInstallation, getEmailMode, getSlackInstallation, getSlackManifest, getSlackMode, getTelegramInstallation, setTelegramAllowedUsers, updateEmailPolicy, } from '@kortix/sdk';
+import { addEmailDomain, connectEmail, listEmailDomains, verifyEmailDomain, connectSlack, connectTelegram, disconnectEmail, disconnectSlack, disconnectTelegram, getEmailInstallation, getEmailMode, getSlackInstallation, getSlackManifest, getSlackMode, getTelegramInstallation, getChannelUserPhoto, listChannelUsers, allowChannelUser, removeChannelUser, dismissChannelAccessRequest, updateEmailPolicy, } from '@kortix/sdk';
 import { qk } from '@kortix/sdk/react';
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 const key = (projectId) => ['channels', 'slack-install', projectId ?? 'none'];
@@ -73,7 +73,7 @@ export function useEmailMode(projectId) {
         staleTime: 60_000,
         queryFn: () => projectId
             ? getEmailMode(projectId)
-            : { provider: 'agentmail', managed_available: false },
+            : { provider: 'resend', managed_available: false },
     });
 }
 export function useConnectEmail() {
@@ -87,6 +87,22 @@ export function useConnectEmail() {
         },
     });
 }
+/** The domains an own Resend API key can create inboxes on. A mutation: it runs when the user enters a key. */
+export function useListEmailDomains() {
+    return useMutation({
+        mutationFn: ({ projectId, apiKey }) => listEmailDomains(projectId, { apiKey }),
+    });
+}
+export function useAddEmailDomain() {
+    return useMutation({
+        mutationFn: ({ projectId, apiKey, domain }) => addEmailDomain(projectId, { apiKey, domain }),
+    });
+}
+export function useVerifyEmailDomain() {
+    return useMutation({
+        mutationFn: ({ projectId, apiKey, domainId }) => verifyEmailDomain(projectId, { apiKey, domainId }),
+    });
+}
 export function useDisconnectEmail() {
     const qc = useQueryClient();
     return useMutation({
@@ -112,8 +128,11 @@ export function useUpdateEmailPolicy() {
         },
     });
 }
-const telegramKey = (projectId) => ['channels', 'telegram-install', projectId ?? 'none'];
-/** The project's Telegram bot (connectors_v2). Pass null to keep the query off. */
+const installKey = (platform, projectId) => ['channels', `${platform}-install`, projectId ?? 'none'];
+const usersKey = (platform, projectId) => ['channels', `${platform}-users`, projectId];
+const telegramKey = (projectId) => installKey('telegram', projectId);
+const telegramUsersKey = (projectId) => usersKey('telegram', projectId);
+/** The project's Telegram bot. Pass null to keep the query off. */
 export function useTelegramInstall(projectId) {
     return useQuery({
         queryKey: telegramKey(projectId),
@@ -128,23 +147,52 @@ export function useConnectTelegram() {
         mutationFn: ({ projectId, ...body }) => connectTelegram(projectId, body),
         onSuccess: (_data, { projectId }) => {
             qc.invalidateQueries({ queryKey: telegramKey(projectId) });
+            // Another bot sees other users: never show the old bot's list.
+            qc.removeQueries({ queryKey: telegramUsersKey(projectId) });
             qc.invalidateQueries({ queryKey: qk.project.connectors(projectId) });
         },
     });
 }
-export function useSetTelegramAllowedUsers() {
+/** Allowed users and access requests, with their names on the platform. Each fetch can call the platform, so enable it only on demand. */
+export function useChannelUsers(projectId, platform, enabled) {
+    return useQuery({
+        queryKey: usersKey(platform, projectId),
+        enabled,
+        queryFn: () => listChannelUsers(projectId, platform),
+    });
+}
+/** One user's profile photo. Off without a `version`: that user has no photo. */
+export function useChannelUserPhoto(projectId, platform, userId, version, enabled) {
+    return useQuery({
+        queryKey: ['channels', `${platform}-photo`, projectId, userId, version],
+        enabled: enabled && !!version,
+        // The version is in the key: a new photo is a new key.
+        staleTime: Infinity,
+        retry: false,
+        queryFn: ({ signal }) => getChannelUserPhoto(projectId, platform, userId, version, signal),
+    });
+}
+function useChannelUserMutation(platform, action) {
     const qc = useQueryClient();
     return useMutation({
-        mutationFn: ({ projectId, userIds }) => setTelegramAllowedUsers(projectId, userIds),
-        onSuccess: (_data, { projectId }) => qc.invalidateQueries({ queryKey: telegramKey(projectId) }),
+        mutationFn: ({ projectId, userId }) => action(projectId, platform, userId),
+        // Returned so the mutation stays pending until the list shows the change.
+        onSuccess: (_data, { projectId }) => Promise.all([
+            qc.invalidateQueries({ queryKey: installKey(platform, projectId) }),
+            qc.invalidateQueries({ queryKey: usersKey(platform, projectId) }),
+        ]),
     });
 }
+export const useAllowChannelUser = (platform) => useChannelUserMutation(platform, allowChannelUser);
+export const useRemoveChannelUser = (platform) => useChannelUserMutation(platform, removeChannelUser);
+export const useDismissChannelAccessRequest = (platform) => useChannelUserMutation(platform, dismissChannelAccessRequest);
 export function useDisconnectTelegram() {
     const qc = useQueryClient();
     return useMutation({
         mutationFn: (projectId) => disconnectTelegram(projectId),
         onSuccess: (_data, projectId) => {
             qc.invalidateQueries({ queryKey: telegramKey(projectId) });
+            qc.removeQueries({ queryKey: telegramUsersKey(projectId) });
             qc.invalidateQueries({ queryKey: qk.project.connectors(projectId) });
         },
     });

package/dist/internal/hooks/channels/use-email-inboxes.d.ts

@@ -0,0 +1,19 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+import { type AddEmailInboxInput, type EmailInbox, type EmailSenderPolicy } from '@kortix/sdk';
+export type { AddEmailInboxInput, EmailInbox };
+/** The inboxes the viewer can use. Pass null to keep the query off (flag off). */
+export declare function useEmailInboxes(projectId: string | null): import("@tanstack/react-query").UseQueryResult<EmailInbox[], Error>;
+export declare function useAddEmailInbox(): import("@tanstack/react-query").UseMutationResult<EmailInbox, Error, AddEmailInboxInput & {
+    projectId: string;
+}, unknown>;
+export declare function useUpdateEmailInbox(): import("@tanstack/react-query").UseMutationResult<EmailInbox, Error, {
+    projectId: string;
+    connectionId: string;
+    sender_policy?: EmailSenderPolicy;
+    display_name?: string;
+    label?: string;
+}, unknown>;
+export declare function useRemoveEmailInbox(): import("@tanstack/react-query").UseMutationResult<import("@kortix/sdk").RemoveEmailInboxResult, Error, {
+    projectId: string;
+    connectionId: string;
+}, unknown>;

package/dist/internal/hooks/channels/use-email-inboxes.js

@@ -0,0 +1,48 @@
+'use client';
+import { addEmailInbox, listEmailInboxes, removeEmailInbox, updateEmailInbox, } from '@kortix/sdk';
+import { qk } from '@kortix/sdk/react';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+/**
+ * The project's email inboxes. Each inbox is one ACCOUNT on the `kortix_email`
+ * connector profile, so the standard account surfaces (default, who can use
+ * it) apply to it; these hooks add what only email has: the Resend inbox
+ * behind the account, its address and who may email it.
+ */
+const inboxesKey = (projectId) => ['channels', 'email-inboxes', projectId ?? 'none'];
+/** Everything that shows an inbox: the inbox list, the account list, the connector page. */
+function refreshInboxViews(qc, projectId) {
+    void qc.invalidateQueries({ queryKey: inboxesKey(projectId) });
+    void qc.invalidateQueries({ queryKey: ['connections', projectId] });
+    void qc.invalidateQueries({ queryKey: qk.project.connectors(projectId) });
+    void qc.invalidateQueries({ queryKey: ['channels', 'email-install'] });
+}
+/** The inboxes the viewer can use. Pass null to keep the query off (flag off). */
+export function useEmailInboxes(projectId) {
+    return useQuery({
+        queryKey: inboxesKey(projectId),
+        enabled: !!projectId,
+        staleTime: 30_000,
+        queryFn: async () => (projectId ? listEmailInboxes(projectId) : []),
+    });
+}
+export function useAddEmailInbox() {
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: ({ projectId, ...input }) => addEmailInbox(projectId, input),
+        onSuccess: (_inbox, { projectId }) => refreshInboxViews(qc, projectId),
+    });
+}
+export function useUpdateEmailInbox() {
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: ({ projectId, connectionId, ...patch }) => updateEmailInbox(projectId, connectionId, patch),
+        onSuccess: (_inbox, { projectId }) => refreshInboxViews(qc, projectId),
+    });
+}
+export function useRemoveEmailInbox() {
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: ({ projectId, connectionId }) => removeEmailInbox(projectId, connectionId),
+        onSuccess: (_result, { projectId }) => refreshInboxViews(qc, projectId),
+    });
+}

package/dist/internal/hooks/connectors/use-add-account.js

@@ -33,7 +33,7 @@ export function useAddAccount({ projectId, connector, displayName, onAdded, onCr
         queryFn: () => listConnections(projectId),
         staleTime: 30_000,
         // A channel connector has no accounts: same guard as `useConnectorDetail`.
-        enabled: connector.provider !== 'channel',
+        enabled: connector.provider !== 'channel' || connector.platform === 'email',
     });
     const addManaged = useAddManagedAccount(projectId, connector.slug, accountId, onAdded);
     // Direct providers: create the account, narrow it before it holds a

package/dist/internal/hooks/index.d.ts

@@ -2,6 +2,6 @@
 /**
  * Utility Hooks
  */
-export { useMediaQuery } from './use-media-query.js';
+export { useMediaQuery } from '../../hooks/use-media-query.js';
 export { useIsMobile } from '../../hooks/use-mobile.js';
 export { useSlashFocus } from './use-slash-focus.js';

package/dist/internal/hooks/index.js

@@ -1,6 +1,6 @@
 /**
  * Utility Hooks
  */
-export { useMediaQuery } from './use-media-query.js';
+export { useMediaQuery } from '../../hooks/use-media-query.js';
 export { useIsMobile } from '../../hooks/use-mobile.js';
 export { useSlashFocus } from './use-slash-focus.js';

package/dist/internal/hooks/projects/use-new-project-session.d.ts

@@ -40,6 +40,9 @@ import { type PendingSessionPrompt, type SessionConnectorBindingsInput } from '@
  */
 /**
  * Options for a new-session start.
+ * `create.space_id` files the session in a channel or DM (`project_channels`).
+ * It never claims a warm session, shows no toast, and does not navigate: the
+ * space view stays and `onNavigate(sessionId)` opens the thread beside it.
  * `agent_name` chooses the session's boot agent. Later prompts can name another
  * agent; the API re-scopes its grants before forwarding the prompt.
  * `connector_bindings` binds specific connections; `inherit_unbound`
@@ -52,11 +55,17 @@ import { type PendingSessionPrompt, type SessionConnectorBindingsInput } from '@
  */
 export type NewProjectSessionOpts = {
     onNavigate?: (sessionId: string) => void;
+    /**
+     * Runs with the client-minted id right before the create POST (never on the
+     * warm path). A space draws its optimistic thread row here; `onError` takes it back.
+     */
+    onCreating?: (sessionId: string) => void;
     onError?: () => void;
     scope?: SessionScopeCommit;
     create?: {
         sandbox_slug?: string;
         agent_name?: string;
+        space_id?: string;
         pending_prompt?: PendingSessionPrompt;
         connector_bindings?: SessionConnectorBindingsInput;
         inherit_unbound?: boolean;

package/dist/internal/hooks/projects/use-new-project-session.js

@@ -25,11 +25,14 @@ function makeTakeOrCreateSession(projectId, opts, router, queryClient, onAdopt)
     // null whenever there is nothing suitable, so the create path below stays
     // the authority on billing and connector requirements.
     async function takeOrCreateSession() {
-        const warm = takeWarmSessionEntry(projectId, {
-            create: opts?.create,
-            // Replenish after /start, not beside the claim and /start requests.
-            replenish: false,
-        });
+        // A space thread always creates: a warm session belongs to no space.
+        const warm = opts.create?.space_id
+            ? null
+            : takeWarmSessionEntry(projectId, {
+                create: opts?.create,
+                // Replenish after /start, not beside the claim and /start requests.
+                replenish: false,
+            });
         if (warm) {
             // The first prompt is a DURABLE inbox row, never a client-side
             // replay (the start stash carries picks only — see the producers).
@@ -61,7 +64,9 @@ function makeTakeOrCreateSession(projectId, opts, router, queryClient, onAdopt)
         }
         const sessionId = randomUUID();
         markSessionFresh(sessionId);
-        router.prefetch(uiRoutes().session(projectId, sessionId));
+        opts.onCreating?.(sessionId);
+        if (!opts.create?.space_id)
+            router.prefetch(uiRoutes().session(projectId, sessionId));
         let created;
         try {
             created = await createProjectSession(projectId, {
@@ -92,6 +97,7 @@ function makeTakeOrCreateSession(projectId, opts, router, queryClient, onAdopt)
 }
 export function useNewProjectSession(projectId) {
     const t = useTranslations('threads');
+    const tSpaces = useTranslations('spaces.view');
     const router = useUiRouter();
     const pathname = useUiPathname();
     const queryClient = useQueryClient();
@@ -186,7 +192,8 @@ export function useNewProjectSession(projectId) {
         const takeOrCreateSession = makeTakeOrCreateSession(projectId, opts, router, queryClient, (session) => {
             adoptedWarmSession = session;
         });
-        const createSession = () => 
+        // A space thread shows up in the timeline at once, so it gets no toast.
+        const inSpace = Boolean(opts.create?.space_id);
         // `threads.*`, not `hardcodedUi.i18nComplete.*`. The two
         // i18nComplete slots these used to read hold the literal strings
         // "startingSession" and "sessionStarted" in en, fr, de, pt, sr and
@@ -194,9 +201,11 @@ export function useNewProjectSession(projectId) {
         // rendered its own key name. `threads.startingSession` /
         // `threads.sessionStarted` are the canonical entries and are
         // correctly translated in all nine catalogs.
-        loadingToast(t('startingSession'), takeOrCreateSession(), {
-            success: t('sessionStarted'),
-        });
+        const createSession = () => inSpace
+            ? takeOrCreateSession()
+            : loadingToast(t('startingSession'), takeOrCreateSession(), {
+                success: t('sessionStarted'),
+            });
         createScopedSession({
             create: createSession,
             draft: opts?.scope?.draft,
@@ -243,6 +252,11 @@ export function useNewProjectSession(projectId) {
                     invalidate: () => queryClient.invalidateQueries({ queryKey: qk.project.sessionsScope(projectId) }),
                 });
                 opts?.onNavigate?.(sessionId);
+                // The space view stays on screen, so no navigation lands to release the claim.
+                if (inSpace) {
+                    release();
+                    return;
+                }
                 // nav-contract: prefetch-only — the session id is minted or returned
                 // by the create POST, so no anchor can name it. `takeOrCreateSession`
                 // prefetches the route the moment the id exists.
@@ -251,6 +265,7 @@ export function useNewProjectSession(projectId) {
         }).catch((err) => {
             const code = err?.code;
             const action = resolveCreateFailure(code, err instanceof ApiError);
+            const failed = inSpace ? tSpaces('sendFailed') : t('failedToStartSession');
             if (action === 'upgrade') {
                 openUpgradeDialog({ reason: 'subscription_required', accountId });
             }
@@ -264,11 +279,11 @@ export function useNewProjectSession(projectId) {
                     });
                 }
                 else {
-                    errorToast(err instanceof Error ? err.message : t('failedToStartSession'));
+                    errorToast(err instanceof Error ? err.message : failed);
                 }
             }
             else if (action === 'toast') {
-                errorToast(err instanceof Error ? err.message : t('failedToStartSession'));
+                errorToast(err instanceof Error ? err.message : failed);
             }
             // No navigation happened, so release the claim now — the user stays
             // where they are and must be able to try again immediately.
@@ -286,6 +301,7 @@ export function useNewProjectSession(projectId) {
         openUpgradeDialog,
         accountId,
         t,
+        tSpaces,
         queryClient,
         openConnectorGate,
     ]);

package/dist/internal/hooks/use-auto-scroll.d.ts

@@ -6,6 +6,13 @@ interface UseAutoScrollOptions {
      *  until then (the area is conditionally rendered), so the observers and
      *  listeners attach on this edge. */
     hasContent?: boolean;
+    /**
+     * FACT 1's room under the newest turn. False keeps only the bottom gap: the
+     * end is the end of the content, as in a chat thread (a channel's thread
+     * panel). A transcript shorter than the viewport then rests at the top,
+     * never below an empty screen. Default true.
+     */
+    room?: boolean;
 }
 interface UseAutoScrollReturn {
     scrollRef: React.RefObject<HTMLDivElement | null>;
@@ -27,4 +34,4 @@ interface UseAutoScrollReturn {
      *  turns follow off until the reader comes to the end themselves. */
     startAtTop: () => void;
 }
-export declare function useAutoScroll({ hasContent, }?: UseAutoScrollOptions): UseAutoScrollReturn;
+export declare function useAutoScroll({ hasContent, room, }?: UseAutoScrollOptions): UseAutoScrollReturn;