inline-chat-kit 0.58.0 → 0.59.0

package/CHANGELOG.md

@@ -8,6 +8,44 @@ The versions before 1.0 follow the pre-release convention: **a breaking change
 or new public API bumps the minor**, and the patch is for fixes. Anything that would break an
 existing install is called out under **Breaking**, with what to do about it.
 
+## 0.59.0 — 2026-09-24
+
+From integrating 0.58 into a host app. Nothing changes for a host that passes
+none of the new props, with one visible difference, below.
+
+### Added
+
+- **`fill="window" | "container"` on `ChatExperience`.** `"container"` makes
+  the chat as tall as its parent instead of the window — both the workspace and
+  the page. Embedded in a card inset 12px top and bottom, the window's height
+  overran the card by 24px and a docked composer lost half of itself to the
+  card's clip. `"window"` is the default and is what the kit did before.
+- **Parts sit in the prose where they arrived.** A part carries `at`, how much
+  prose had arrived when it did, stamped by `useChatTurns` on its first
+  appearance, and the row draws the answer in that order. "I suggest this
+  change:" is drawn before the change it introduces rather than under it. The
+  prose is still one string — Copy, the screen reader and versions read `ai` as
+  before; only the drawing is cut. Hosts can set `at` themselves; a part without
+  one sits before the prose, as every part did.
+
+### Changed
+
+- **Prose sent after a part is now drawn after it.** This is the point of the
+  above, and it is the one thing an existing host will see: a stream that sent
+  text, then a card, then more text used to draw the card on top and all the
+  text under it. Streams that send their parts before their prose — the usual
+  shape, and every stream in the demo — draw exactly as before. The one story
+  that changes is `Localized`, whose sentence now stands above its cards.
+- **The row of actions follows the whole answer.** It lived inside the prose
+  block, so an answer made only of parts had no regenerate and no thumbs.
+  Copy is offered only when there is prose to copy.
+
+### Fixed
+
+- **`highlights={false}` still cut the prose into a span per word.** The spans
+  exist for marking — hit-testing, the keyboard cursor, the dimming — and with
+  marking off they were 82 elements for four sentences. The answer is text now.
+
 ## 0.58.0 — 2026-09-23
 
 The composer at the bottom, as an alternative to the inline one — roadmap I2.

package/README.md

@@ -480,6 +480,31 @@ component that owns it.
 steps that follow from one another. Sending both for one stretch of thinking
 says it twice.
 
+#### Where a part sits in the prose
+
+The answer is drawn in the order the stream sent it. A part remembers how much
+prose had arrived when it did — `at`, in characters of `ai` — and is drawn at
+that point, so a sentence that introduces a card comes before the card:
+
+```tsx
+yield "I suggest this change:";                                   // prose
+yield { kind: "custom", id: "change", type: "plan-diff", data };  // at: 22
+yield " Tell me if it looks right.";                              // prose, after the card
+```
+
+`useChatTurns` stamps `at` on a part's **first** appearance and nothing moves it
+afterwards: an update to a part is not a new part, and a card a host adds with
+`updatePart` after the answer lands at the end. Give `at` yourself to place a
+part — `at: 0` puts it before all the prose. A part with no `at` sits before the
+prose, which is where every part sat before this existed, so turns built by
+hand look as they always have.
+
+The prose is still one string: `ai` is what Copy copies, what a screen reader
+hears and what a version keeps. Only the drawing is cut, at the points the
+parts arrived — each run is its own block of markdown, and a highlight cannot
+cross a card. The row of actions goes after whatever the answer ends with, so an
+answer made only of parts has one too, without a Copy of nothing.
+
 #### Your own cards: `custom`
 
 Every other kind is a component in this package. `custom` is the host's: `type`
@@ -1499,9 +1524,19 @@ not; a control for choosing is a question nobody asked.
   composerMenu={false}           // or your own: [{ id, label, icon?, onSelect }]
   pane="none"                    // draw the artifact pane yourself
   surface="panes"                // the conversation as a card of its own
+  fill="container"               // as tall as its parent, not the window
 />
 ```
 
+**Embedded, use `fill="container"`.** By default the chat is as tall as the
+window, which is what a page that is nothing but the chat wants. Anywhere
+smaller — a card in a shell, a sidebar, a split — it has to take its parent's
+height instead, or it hangs past the bottom of it: measured in a card inset 12px
+top and bottom, the default overran it by 24px and a docked composer lost half
+of itself to the card's clip. The parent has to have a height to give. The
+software keyboard is then the host's to handle, because the chat no longer
+knows where the window's edge is.
+
 | Prop | Off means |
 | --- | --- |
 | `highlights={false}` | Answers are prose: no marker layer, nothing over the text in the tab order, no highlight menu — and no saved highlights or selection-mode pair, since both are about marking |

package/dist/ChatExperience/ChatExperience.d.ts

@@ -167,6 +167,23 @@ export interface ChatExperienceProps {
      * With a `chat` of your own, give its `useChatTurns` `nextTurn: "at-send"`.
      */
     composer?: "inline" | "docked";
+    /**
+     * What the chat is as tall as.
+     *
+     * `"window"` (the default): the whole window, which is what a page that is
+     * nothing but the chat wants, and why it needs no height from its host.
+     *
+     * `"container"`: whatever its parent gives it. For a chat embedded in a
+     * card, a sidebar, a split — anywhere smaller than the window, which is
+     * nearly every embed. The parent has to have a height to give; the chat
+     * fills it and scrolls inside it. Measured in a host whose card was inset
+     * 12px top and bottom, `"window"` hung 24px past the card and a docked
+     * composer lost half of itself to the card's clip.
+     *
+     * The software keyboard is the host's to handle here: the chat no longer
+     * knows where the window's bottom edge is relative to itself.
+     */
+    fill?: "window" | "container";
     /** The theme, if the host keeps it. Left off, this manages its own and puts
         a toggle in the header; `data-theme` on the root element either way, and
         unset until somebody chooses, so the kit follows the system preference —
@@ -218,4 +235,4 @@ export interface ChatExperienceProps {
     onDecideApproval?: (write: PartWriter, turnId: string, partId: string, decision: Decision) => void;
     className?: string;
 }
-export declare function ChatExperience({ onSend, chat: hostChat, renderPart, labels, headerActions: builtInActions, composerMenu, onTranscribe, onThreadReply, title: titleProp, backHref, backLabel, actions, placeholder, empty, contextTotal, contextBase, artifact, openArtifactId: openArtifactProp, onOpenArtifactChange, pane: paneMode, surface, composer, theme: themeProp, onThemeChange, cursor, selectionToggle, highlights: marking, bookmarks, anchorOffset, endOffset, animationConfig, foldMotion, feedDelay, onAnswerQuestion, onEditQuestion, onDecideApproval, className, }: ChatExperienceProps): import("react").JSX.Element;
+export declare function ChatExperience({ onSend, chat: hostChat, renderPart, labels, headerActions: builtInActions, composerMenu, onTranscribe, onThreadReply, title: titleProp, backHref, backLabel, actions, placeholder, empty, contextTotal, contextBase, artifact, openArtifactId: openArtifactProp, onOpenArtifactChange, pane: paneMode, surface, composer, fill: fillMode, theme: themeProp, onThemeChange, cursor, selectionToggle, highlights: marking, bookmarks, anchorOffset, endOffset, animationConfig, foldMotion, feedDelay, onAnswerQuestion, onEditQuestion, onDecideApproval, className, }: ChatExperienceProps): import("react").JSX.Element;