@tightknitai/block-kitchen 0.9.9 → 0.9.10

package/README.md

@@ -105,9 +105,12 @@ export function MyBuilderPage() {
 | `workspaceName` | `string` | no | Shown in the preview chrome to mimic a real Slack message header. |
 | `initialBlocks` | `SupportedBlock[]` | no | Starting draft. If omitted, the builder starts empty. |
 | `onChange` | `(blocks: SupportedBlock[]) => void` | no | Fires on every state change. Use this to persist the draft (URL, localStorage, etc). |
-| `loadChannels` | `() => Promise<{ id: string; name: string }[]>` | yes | Returns channels available to send to. The package never makes Slack API calls itself. |
-| `loadSendAsUserStatus` | `() => Promise<{ canSendAsUser: boolean; oauthUrl?: string }>` | yes | Whether the current user has a Slack user-token and can post as themselves. If `canSendAsUser` is false, `oauthUrl` is shown as a "Sign in with Slack" link. |
-| `onSend` | `(payload) => Promise<{ ok: boolean; error?: string }>` | yes | Called when the user submits the send dialog. Payload is `{ channelId, blocks, sendAsUser }`. |
+| `onValidationChange` | `(summary: ValidationSummary) => void` | no | Fires when the draft's validation verdict changes (debounced alongside the builder's own validation pass — not on every keystroke). `summary` is `{ valid, errorCount, errors }`: the exact verdict the issues chip/sheet shows, always scoped to the `message` surface. Lets a host-owned CTA gate on validity in [compose-only mode](#compose-only-mode-bring-your-own-send-flow) without re-running the validator. |
+| `loadChannels` | `() => Promise<{ id: string; name: string }[]>` | grouped\* | Returns channels available to send to. The package never makes Slack API calls itself. |
+| `loadSendAsUserStatus` | `() => Promise<{ canSendAsUser: boolean; oauthUrl?: string }>` | grouped\* | Whether the current user has a Slack user-token and can post as themselves. If `canSendAsUser` is false, `oauthUrl` is shown as a "Sign in with Slack" link. |
+| `onSend` | `(payload) => Promise<{ ok: boolean; error?: string }>` | grouped\* | Called when the user submits the send dialog. Payload is `{ channelId, blocks, sendAsUser, extras? }` (`extras` only when `renderSendExtras` is wired). |
+| `renderSendExtras` | `(ctx: SendExtrasContext) => ReactNode` | no | Renders host-defined fields inside the built-in send dialog, below the channel and identity pickers. Collect values with `ctx.setExtras(patch)`; they arrive on `onSend` as `payload.extras`. Requires the send trio. See [Extending the send dialog](#extending-the-send-dialog-custom-fields). |
+| `primaryAction` | `{ label, onClick, disableWhenInvalid? }` | no | Compose-only mode only: a host-owned button in the toolbar slot where "Review & send" normally sits. `onClick` receives `{ blocks, validation }` — the current draft plus the same verdict `onValidationChange` reports. See [Keeping the CTA in the toolbar](#keeping-the-cta-in-the-toolbar-primaryaction). |
 | `editing` | `{ onLoadMessage, onUpdate, loadRecentMessages? }` | no | Opt-in edit mode. When present, the toolbar exposes "Edit message": the user pastes a Slack message link, `onLoadMessage({ link })` returns a host-computed [editability verdict](#editing-an-existing-message-opt-in), and a successful load flips the primary action to "Update message" wired to `onUpdate`. Pass `loadRecentMessages` to add a "recent messages from this app" picker beside the paste input; the user picks a channel first (reusing `loadChannels`) and the lookup is scoped to it. Omit `editing` to keep send-only behavior. |
 | `loadButtonLabel` | `string` | no | Label + accessible name for the toolbar button that opens the load-message dialog (the edit-mode entry point). Defaults to `'Load message'`. Only shown when `editing` is set and no message is loaded. |
 | `updateButtonLabel` | `string` | no | Label for the toolbar's primary button while a message is loaded for editing. It's a split button: clicking it updates the message in place; the menu beside it also offers "Send as a new message" (post the current blocks as new). Defaults to `'Review & update'`. |
@@ -127,6 +130,163 @@ export function MyBuilderPage() {
 | `confirmSendLabel` | `string` | no | Label for the send dialog's final confirm button. Defaults to `'Send'` (shows `'Sending…'` while in flight). |
 | `theme` | `BrandTheme \| BrandPreset` | no | Branding tokens applied to the builder chrome (toolbar, palette, popovers, dialogs). Accepts a `Partial<BrandTokens>` map and optional `light`/`dark` overrides. See [Styling](#styling) below. |
 
+\* The send trio — `loadChannels`, `loadSendAsUserStatus`, `onSend` — is
+all-or-nothing: provide all three for the built-in send flow, or omit all
+three for [compose-only mode](#compose-only-mode-bring-your-own-send-flow)
+(no send button; your app owns the send flow). Wiring only some of the three
+is a type error. `editing` and `renderSendExtras` require the trio;
+`primaryAction` requires its absence (the built-in Send/Update flow owns the
+toolbar's primary slot otherwise).
+
+## Compose-only mode (bring your own send flow)
+
+Omit the send trio entirely and the builder renders no send button — it
+becomes a pure Block Kit editor. This is the right shape when composing is
+one step in a flow your app owns (a wizard, an audience picker, a scheduler):
+the package owns *composition* (authoring, preview, validation UX) and your
+app owns *distribution* (audiences, identity, scheduling, delivery). The
+only thing that crosses the boundary is the blocks array.
+
+Mirror the draft with `onChange`, gate your own CTA with
+`onValidationChange`, and hand `toSlackBlocks(draft)` to whatever comes next:
+
+```tsx
+import { useState } from "react";
+import {
+  BlockKitchen,
+  toSlackBlocks,
+  type SupportedBlock,
+  type ValidationSummary,
+} from "@tightknitai/block-kitchen";
+
+function ComposeStep({ onNext }: { onNext: (blocks: SupportedBlock[]) => void }) {
+  const [draft, setDraft] = useState<SupportedBlock[]>([]);
+  const [validation, setValidation] = useState<ValidationSummary | null>(null);
+
+  return (
+    <>
+      <BlockKitchen onChange={setDraft} onValidationChange={setValidation} />
+      {/* Your CTA, your copy, your placement — gated on the builder's own verdict. */}
+      <button
+        disabled={draft.length === 0 || validation?.valid === false}
+        onClick={() => onNext(toSlackBlocks(draft))}
+      >
+        Next: choose audience
+      </button>
+    </>
+  );
+}
+```
+
+Notes:
+
+- The rest of the toolbar (Clear, View JSON, the issues chip, theme/surface
+  controls) is unchanged — users can still inspect problems in the issues
+  sheet; only the moment of commitment moves into your app.
+- `onValidationChange` reports the same verdict the issues sheet displays
+  (validated against the `message` surface, like Send), so your CTA and the
+  in-builder issue count can never disagree.
+- `editing` is unavailable in compose-only mode: updating an existing message
+  is inherently bound to its channel + timestamp, so the update flow only
+  exists alongside the send integration.
+
+### Keeping the CTA in the toolbar (`primaryAction`)
+
+The example above renders its CTA outside the builder. If you want the button
+to sit where "Review & send" normally sits — say a message drafter whose
+primary action is "Save template" — pass `primaryAction`:
+
+```tsx
+<BlockKitchen
+  primaryAction={{
+    label: "Save template",
+    onClick: ({ blocks, validation }) => openSaveModal(blocks, validation),
+    // Send-style gating is opt-in. Default is enabled-while-invalid: a
+    // drafter usually allows committing a work-in-progress draft and
+    // surfaces the verdict in its own flow instead.
+    disableWhenInvalid: false,
+  }}
+/>
+```
+
+`onClick` receives the current draft in the builder's native format (the same
+shape `onChange` reports — persist that to re-open the draft later; run it
+through `toSlackBlocks` for the Slack-ready payload) plus the validation
+verdict `onValidationChange` would report. The button is never disabled for
+an empty draft; gate on `blocks.length` in `onClick` if you need that.
+
+### Building a bespoke send flow from the exported primitives
+
+If your custom flow ends in something send-shaped, you don't have to rebuild
+the built-in dialog's machinery — the send-flow primitives are exported:
+
+- `SendDialog` — the built-in dialog as a standalone component
+  (`SendDialogProps`): channel loading/error states, bot-vs-user identity
+  picker, OAuth hand-off, in-flight and failure states. Mount it against your
+  own trigger.
+- `useSlackSignIn(loadStatus, { open, enabled })` — the OAuth sign-in state
+  machine behind the identity picker: fetches user-token status on open,
+  refreshes on window focus, and background-polls after the OAuth tab opens
+  until the token appears.
+- `SlackSignInButton` — the "Sign in with Slack" button with its polling
+  spinner, for wiring `useSlackSignIn` into your own dialog.
+
+## Extending the send dialog (custom fields)
+
+When the built-in send flow is *almost* right — you want the channel picker,
+identity picker, and sending states, plus a few controls of your own (a
+cross-post toggle, a custom sender name) — pass `renderSendExtras` instead of
+rebuilding the dialog. It renders below the built-in fields, and whatever you
+collect via `setExtras` arrives on `onSend` as `payload.extras`:
+
+```tsx
+<BlockKitchen
+  loadChannels={loadChannels}
+  loadSendAsUserStatus={loadSendAsUserStatus}
+  renderSendExtras={({ extras, setExtras }) => (
+    <>
+      <label>
+        <input
+          type="checkbox"
+          checked={Boolean(extras.alsoPostToIntranet)}
+          onChange={(e) => setExtras({ alsoPostToIntranet: e.target.checked })}
+        />
+        Also publish to the intranet
+      </label>
+      <label>
+        Custom sender name
+        <input
+          type="text"
+          value={String(extras.senderName ?? "")}
+          onChange={(e) => setExtras({ senderName: e.target.value })}
+        />
+      </label>
+    </>
+  )}
+  onSend={async ({ channelId, blocks, sendAsUser, extras }) => {
+    await api.send({ channelId, blocks, sendAsUser, ...extras }); // your code
+    return { ok: true };
+  }}
+/>
+```
+
+Notes:
+
+- The `extras` object is owned by the dialog: it resets every time the dialog
+  opens (alongside the channel and identity pickers), and `setExtras(patch)`
+  shallow-merges. Render controlled inputs from `extras`.
+- The context also carries the currently selected `channelId` (`null` until
+  channels load) and `sendAsUser`, so extras can react to them — e.g. only
+  offer cross-posting for certain channels.
+- `payload.extras` is present iff `renderSendExtras` is wired, so existing
+  `onSend` handlers never see a new key.
+- The dialog renders in a portal attached to `document.body`, so CSS that
+  relies on ancestor selectors from your app's DOM won't reach slot content —
+  style it directly (inline, CSS modules, utility classes).
+- For customizations that generalize something the dialog already models
+  (identities, channels), prefer proposing a first-class prop over routing
+  them through extras; the slot is for genuinely host-specific concerns.
+
 ## Editing an existing message (opt-in)
 
 By default the builder is send-only. Pass `editing` to let users load an
@@ -225,9 +385,9 @@ Variant `id`s must be unique across the array — the drag-drop lookup keys by i
 
 ## Boundary
 
-The package is deliberately decoupled from any Slack SDK or backend. It does not import HTTP clients, OAuth libraries, or workspace-state systems. Everything I/O-shaped is brokered through props.
+The package is deliberately decoupled from any Slack SDK or backend. It does not import HTTP clients, OAuth libraries, or workspace-state systems. Everything I/O-shaped is brokered through props — and the send flow itself is optional: see [compose-only mode](#compose-only-mode-bring-your-own-send-flow) when your app owns the moment of commitment.
 
-Helpers also exported:
+Helpers and send-flow primitives also exported:
 
 ```ts
 import {
@@ -235,18 +395,29 @@ import {
   encodeBlocksToString,    // base64url-encode a blocks array (for URL state)
   decodeBlocksFromString,
   defaultPalette,          // the built-in palette — spread to customize
+  SendDialog,              // the built-in send dialog, standalone (bespoke send flows)
+  useSlackSignIn,          // the OAuth sign-in state machine behind the identity picker
+  SlackSignInButton,       // the "Sign in with Slack" button + polling spinner
 } from "@tightknitai/block-kitchen";
 
 import type {
   SupportedBlock,
   SupportedBlockType,
   BlockKitchenProps,
+  BlockKitchenBaseProps,        // shared props
+  BlockKitchenSendProps,        // the send trio + `editing` + `renderSendExtras`
+  BlockKitchenComposeOnlyProps, // the trio explicitly absent + `primaryAction`
   PaletteSection,
   PaletteVariant,
   SendPayload,
   SendResult,
+  SendDialogProps,
+  SendExtrasContext,
+  PrimaryActionConfig,
+  PrimaryActionContext,
   ChannelOption,
   SendAsUserStatus,
+  ValidationSummary,
   PreviewHooks,
 } from "@tightknitai/block-kitchen";
 ```

package/dist/helpers.d.cts

@@ -1,5 +1,5 @@
-import { T as SupportedBlock } from './palette-CKP8CK5Z.cjs';
-export { U as SupportedBlockType } from './palette-CKP8CK5Z.cjs';
+import { Z as SupportedBlock } from './palette-Duj901T6.cjs';
+export { _ as SupportedBlockType } from './palette-Duj901T6.cjs';
 import 'react';
 import 'slack-web-api-client';
 

package/dist/helpers.d.ts

@@ -1,5 +1,5 @@
-import { T as SupportedBlock } from './palette-CKP8CK5Z.js';
-export { U as SupportedBlockType } from './palette-CKP8CK5Z.js';
+import { Z as SupportedBlock } from './palette-Duj901T6.js';
+export { _ as SupportedBlockType } from './palette-Duj901T6.js';
 import 'react';
 import 'slack-web-api-client';
 

package/dist/index.cjs

@@ -2045,6 +2045,7 @@ function computeValidation(blocks, surface) {
   const grouped = groupValidatorErrors(result.errors, blocks);
   return {
     valid: result.valid,
+    errors: result.errors,
     byBlockId: grouped.byBlockId,
     general: grouped.general,
     total: grouped.total
@@ -3562,6 +3563,7 @@ function SendDialog({
   loadChannels,
   loadSendAsUserStatus,
   onSend,
+  renderSendExtras,
   confirmSendLabel = "Send",
   errorCount,
   onShowIssues
@@ -3571,6 +3573,10 @@ function SendDialog({
   const [channelId, setChannelId] = React.useState("");
   const [sendAs, setSendAs] = React.useState("bot");
   const [status, setStatus] = React.useState({ kind: "idle" });
+  const [extras, setExtrasState] = React.useState({});
+  const setExtras = React.useCallback((patch) => {
+    setExtrasState((prev) => ({ ...prev, ...patch }));
+  }, []);
   const { userStatus, polling, startSignIn } = useSlackSignIn(loadSendAsUserStatus, { open, enabled: true });
   const loadChannelsRef = React.useRef(loadChannels);
   React.useEffect(() => {
@@ -3585,6 +3591,7 @@ function SendDialog({
     setChannelsError(null);
     setChannelId("");
     setSendAs("bot");
+    setExtrasState({});
     let cancelled = false;
     loadChannelsRef.current().then((list) => {
       if (cancelled) {
@@ -3612,7 +3619,10 @@ function SendDialog({
       const result = await onSend({
         channelId,
         blocks: toSlackBlocks(blocks),
-        sendAsUser: sendAs === "user"
+        sendAsUser: sendAs === "user",
+        // Only introduce the key when the extras slot is wired, so existing
+        // consumers never see a new payload field.
+        ...renderSendExtras ? { extras } : {}
       });
       if (result.ok) {
         setStatus({ kind: "idle" });
@@ -3679,6 +3689,12 @@ function SendDialog({
           }
         )
       ] }),
+      renderSendExtras ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-col gap-1.5", children: renderSendExtras({
+        channelId: channelId || null,
+        sendAsUser: sendAs === "user",
+        extras,
+        setExtras
+      }) }) : null,
       errorCount > 0 ? /* @__PURE__ */ jsxRuntime.jsxs(
         "button",
         {
@@ -9425,6 +9441,8 @@ function Toolbar2({
   showThemeControl = true,
   docsLink,
   errorCount,
+  showSend = true,
+  primaryAction,
   sendButtonLabel = "Review & send",
   editingEnabled = false,
   editBadge,
@@ -9559,7 +9577,24 @@ function Toolbar2({
           /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Code2, { className: "h-3.5 w-3.5" }),
           /* @__PURE__ */ jsxRuntime.jsx("span", { className: "hidden md:inline", children: "View JSON" })
         ] }),
-        editBadge ? (
+        !showSend ? primaryAction ? (
+          // Compose-only mode with a host-owned primary action: same
+          // placement and styling as the built-in send button. No icon —
+          // the action's meaning is the host's, so the label always shows
+          // (the send button can collapse to its icon on small screens;
+          // an icon-less button can't).
+          /* @__PURE__ */ jsxRuntime.jsx(
+            Button,
+            {
+              type: "button",
+              size: "sm",
+              onClick: primaryAction.onClick,
+              disabled: primaryAction.disabled,
+              "aria-label": primaryAction.label,
+              children: /* @__PURE__ */ jsxRuntime.jsx("span", { children: primaryAction.label })
+            }
+          )
+        ) : null : editBadge ? (
           // A message is loaded: split button. Main action updates it in
           // place; the menu also offers posting the blocks as a new message.
           /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-stretch", children: [
@@ -9802,12 +9837,15 @@ function BlockKitchen(props) {
     workspaceName,
     initialBlocks,
     onChange,
+    onValidationChange,
     previewHooks,
     customEmojis,
     loadChannels,
     loadSendAsUserStatus,
     onSend,
+    renderSendExtras,
     editing,
+    primaryAction,
     loadButtonLabel,
     updateButtonLabel,
     confirmUpdateLabel,
@@ -9824,6 +9862,13 @@ function BlockKitchen(props) {
     sendButtonLabel,
     confirmSendLabel,
     theme
+    // Widen the all-or-nothing union so the branch-specific props
+    // destructure as independent optionals: untyped JS consumers can still
+    // pass partial wiring (handled by the runtime guards below), and the
+    // correlated-union narrowing would otherwise flag those guards as
+    // "always true". `primaryAction` is pulled from the compose-only branch
+    // (where it carries a real type) rather than the send branch's
+    // `undefined` pin, which would collapse the intersection to `undefined`.
   } = props;
   const paletteSections = React.useMemo(() => {
     const sections = palette ?? defaultPalette;
@@ -9842,13 +9887,36 @@ function BlockKitchen(props) {
   }, [palette, disabledBlockTypes]);
   const variantById = React.useMemo(() => buildVariantById(paletteSections), [paletteSections]);
   const allowedSurfaces = allowedSurfacesProp && allowedSurfacesProp.length > 0 ? allowedSurfacesProp : ["message"];
-  const seededBlocks = editing?.initialTarget?.blocks ?? initialBlocks;
+  const sendEnabled = Boolean(loadChannels && loadSendAsUserStatus && onSend);
+  const editingConfig = sendEnabled ? editing : void 0;
+  const seededBlocks = editingConfig?.initialTarget?.blocks ?? initialBlocks;
   React.useEffect(() => {
-    if (editing?.initialTarget && initialBlocks) {
+    if (editingConfig?.initialTarget && initialBlocks) {
       console.warn(
         "[BlockKitchen] Both `initialBlocks` and `editing.initialTarget` were provided; using the target\u2019s blocks and ignoring `initialBlocks`."
       );
     }
+    const sendPropsProvided = [loadChannels, loadSendAsUserStatus, onSend].filter(Boolean).length;
+    if (sendPropsProvided > 0 && sendPropsProvided < 3) {
+      console.warn(
+        "[BlockKitchen] Partial send wiring: `loadChannels`, `loadSendAsUserStatus`, and `onSend` are all-or-nothing. The send button is hidden until all three are provided."
+      );
+    }
+    if (editing && !sendEnabled) {
+      console.warn(
+        "[BlockKitchen] `editing` requires the send integration (`loadChannels`, `loadSendAsUserStatus`, `onSend`); ignoring `editing`."
+      );
+    }
+    if (renderSendExtras && !sendEnabled) {
+      console.warn(
+        "[BlockKitchen] `renderSendExtras` extends the built-in send dialog, which requires the send integration (`loadChannels`, `loadSendAsUserStatus`, `onSend`); ignoring `renderSendExtras`."
+      );
+    }
+    if (primaryAction && sendEnabled) {
+      console.warn(
+        "[BlockKitchen] `primaryAction` is only available in compose-only mode \u2014 with the send integration wired, the built-in Send/Update flow owns the toolbar\u2019s primary action; ignoring `primaryAction`."
+      );
+    }
   }, []);
   const { blocks, addBlock, addChild, updateBlock, removeBlock, duplicateBlock, reorderBlock, moveBlock, replaceAll } = useBlockKitchenState({ initialBlocks: seededBlocks, onChange });
   const childParentById = React.useMemo(() => {
@@ -9866,8 +9934,8 @@ function BlockKitchen(props) {
   const [sendOpen, setSendOpen] = React.useState(false);
   const [updateOpen, setUpdateOpen] = React.useState(false);
   const [loadOpen, setLoadOpen] = React.useState(false);
-  const [editTarget, setEditTarget] = React.useState(() => editing?.initialTarget ?? null);
-  const activeEditTarget = editing ? editTarget : null;
+  const [editTarget, setEditTarget] = React.useState(() => editingConfig?.initialTarget ?? null);
+  const activeEditTarget = editingConfig ? editTarget : null;
   const [issuesOpen, setIssuesOpen] = React.useState(false);
   const [paletteOpen, setPaletteOpen] = React.useState(false);
   const [openBlockId, setOpenBlockId] = React.useState(null);
@@ -9885,6 +9953,22 @@ function BlockKitchen(props) {
     return { emoji: makeEmojiHook(byName), ...previewHooks };
   }, [customEmojis, previewHooks]);
   const validation = useBlockKitValidation(blocks, "message");
+  const validationSummary = React.useMemo(
+    () => ({ valid: validation.valid, errorCount: validation.total, errors: validation.errors }),
+    [validation]
+  );
+  const lastNotifiedValidationRef = React.useRef(null);
+  React.useEffect(() => {
+    if (!onValidationChange) {
+      return;
+    }
+    const key = JSON.stringify([validationSummary.valid, validationSummary.errorCount, ...validationSummary.errors]);
+    if (lastNotifiedValidationRef.current === key) {
+      return;
+    }
+    lastNotifiedValidationRef.current = key;
+    onValidationChange(validationSummary);
+  }, [validationSummary, onValidationChange]);
   const sensors = core.useSensors(
     core.useSensor(core.PointerSensor, { activationConstraint: { distance: 4 } }),
     core.useSensor(core.TouchSensor, { activationConstraint: { delay: 150, tolerance: 8 } }),
@@ -9988,8 +10072,14 @@ function BlockKitchen(props) {
               allowedSurfaces,
               showThemeControl: isPreviewThemeControlled ? false : showThemeControl,
               docsLink,
+              showSend: sendEnabled,
+              primaryAction: !sendEnabled && primaryAction ? {
+                label: primaryAction.label,
+                onClick: () => primaryAction.onClick({ blocks: blockPayloads, validation: validationSummary }),
+                disabled: primaryAction.disableWhenInvalid ? !validationSummary.valid : false
+              } : null,
               sendButtonLabel,
-              editingEnabled: !!editing,
+              editingEnabled: !!editingConfig,
               editBadge: activeEditTarget ? {
                 channelLabel: activeEditTarget.channelName ? `#${activeEditTarget.channelName}` : activeEditTarget.channelId,
                 ts: activeEditTarget.ts
@@ -10071,7 +10161,7 @@ function BlockKitchen(props) {
           }
         ) }),
         /* @__PURE__ */ jsxRuntime.jsx(JsonDrawer, { open: jsonOpen, onOpenChange: setJsonOpen, blocks: blockPayloads, onApply: replaceAll }),
-        /* @__PURE__ */ jsxRuntime.jsx(
+        loadChannels && loadSendAsUserStatus && onSend ? /* @__PURE__ */ jsxRuntime.jsx(
           SendDialog,
           {
             open: sendOpen,
@@ -10080,6 +10170,7 @@ function BlockKitchen(props) {
             loadChannels,
             loadSendAsUserStatus,
             onSend,
+            renderSendExtras,
             confirmSendLabel,
             errorCount: validation.total,
             onShowIssues: () => {
@@ -10087,8 +10178,8 @@ function BlockKitchen(props) {
               setIssuesOpen(true);
             }
           }
-        ),
-        activeEditTarget && editing ? /* @__PURE__ */ jsxRuntime.jsx(
+        ) : null,
+        activeEditTarget && editingConfig && loadSendAsUserStatus ? /* @__PURE__ */ jsxRuntime.jsx(
           UpdateDialog,
           {
             open: updateOpen,
@@ -10096,7 +10187,7 @@ function BlockKitchen(props) {
             target: activeEditTarget,
             blocks: blockPayloads,
             loadSendAsUserStatus,
-            onUpdate: editing.onUpdate,
+            onUpdate: editingConfig.onUpdate,
             confirmUpdateLabel,
             errorCount: validation.total,
             onShowIssues: () => {
@@ -10105,13 +10196,13 @@ function BlockKitchen(props) {
             }
           }
         ) : null,
-        editing ? /* @__PURE__ */ jsxRuntime.jsx(
+        editingConfig && loadChannels ? /* @__PURE__ */ jsxRuntime.jsx(
           LoadMessageDialog,
           {
             open: loadOpen,
             onOpenChange: setLoadOpen,
-            onLoadMessage: editing.onLoadMessage,
-            loadRecentMessages: editing.loadRecentMessages,
+            onLoadMessage: editingConfig.onLoadMessage,
+            loadRecentMessages: editingConfig.loadRecentMessages,
             loadChannels,
             onLoaded: (result) => {
               replaceAll(result.blocks);
@@ -10306,6 +10397,8 @@ function fromBase64Url(b64url) {
 }
 
 exports.BlockKitchen = BlockKitchen;
+exports.SendDialog = SendDialog;
+exports.SlackSignInButton = SlackSignInButton;
 exports.TemplatePicker = TemplatePicker;
 exports.decodeBlocksFromString = decodeBlocksFromString;
 exports.defaultPalette = defaultPalette;
@@ -10313,5 +10406,6 @@ exports.encodeBlocksToString = encodeBlocksToString;
 exports.extraAlertVariant = extraAlertVariant;
 exports.legacyInputVariants = legacyInputVariants;
 exports.toSlackBlocks = toSlackBlocks;
+exports.useSlackSignIn = useSlackSignIn;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map