@adea-ai/ui 0.67.1 → 0.68.0

package/README.md

@@ -448,3 +448,61 @@ draft state, persistence, message reconciliation and editor behavior. The model
 does not read storage or the clipboard, upload files, edit a textarea, or
 provide undo/history, previews or chips. Its selected source and Apache-2.0
 attribution are recorded in the issue #532 entry in `NOTICE`.
+
+## Transcript composition
+
+`TranscriptComposition` assembles ordered host-classified rows, contiguous groups,
+turn presentation and accessible fold controls. Import it from the public component
+subpath:
+
+```tsx
+import {
+  TranscriptComposition,
+  type TranscriptCompositionRendererProps,
+  type TranscriptRow,
+} from '@adea-ai/ui/components/conversation/transcript-composition'
+
+type Message = { text: string }
+const rows: readonly TranscriptRow<Message>[] = [
+  { id: 'question-1', value: { text: 'Inspect the cursor.' }, opensTurn: 'reset' },
+  {
+    id: 'tool-1',
+    value: { text: 'Read the cursor.' },
+    fold: 'tool',
+    call: { phase: 'request', id: 'call-1' },
+  },
+]
+
+function HostMessage(props: TranscriptCompositionRendererProps<Message>) {
+  return <article>{props.row.value.text}</article>
+}
+
+export function TranscriptPreview() {
+  return <TranscriptComposition rows={rows} renderRow={HostMessage} />
+}
+```
+
+Each row needs a stable unique `id` within its transcript. The host supplies the
+Solid row component and classifies turn boundaries, calls, conclusions,
+always-visible actions and redacted values. The renderer does not parse protocol
+payloads or decide permission, session, event, delivery or success state.
+
+Settled tool folds start closed and unmount their hidden row payloads. Live rows
+stay open until the host marks them settled; an explicit row choice survives that
+running-state transition. `foldMode="prose"` folds host-marked eligible activity
+before a host-designated conclusion, leaving that conclusion visible.
+The `foldState="collapsed"` command keeps hidden
+content mounted. It folds eligible rows before a host-marked conclusion; without
+that boundary it leaves prose visible and can still collapse explicitly classified
+tool calls. Always-visible rows stay in place. `disclosure` plus
+`onDisclosureChange` lets an application restore explicit choices from its own
+durable store using `transcriptDisclosureKey`.
+
+`bun run check:packed-transcript` installs the actual tarball without optional
+chart/carousel engines, compiles both published export conditions, and checks the
+same behavior in headless Chromium, WebKit and native Node SSR. It covers row-owner
+identity through loose-to-turn promotion, tool request counting, mounted prose,
+keyboard disclosure, visible actions and automated accessibility. This is shared
+composition evidence; bounded runtime projection, storage and production chat
+integration remain application acceptance gates. Attribution for the selected
+KiroCrew source contracts is recorded in the issue-specific `NOTICE` entry.

package/dist/NOTICE

@@ -291,3 +291,37 @@ refused. React, Lexical, browser clipboard/File handling, localStorage side-tabl
 recovery, backend message reconciliation, uploads, textarea editing, previews,
 chips, undo/history and submit/persistence authority are not included. This
 selected model is not rich editing, complete Chat, or application adoption.
+
+## Shared transcript composition translated from KiroCrew
+
+`packages/ui/src/components/conversation/transcript-grouping.ts`,
+`transcript-folding.ts` and the `transcript-composition.tsx` component substantially
+translate the ordered display grouping and turn disclosure contracts in
+`website/src/app-sdk/ChatMessageList.tsx`,
+`website/src/pages/chat/groupDisplayItems.ts`,
+`website/src/pages/chat/TurnBlock.tsx`,
+`website/src/pages/chat/CollapsibleToolGroup.tsx` and
+`website/src/pages/chat/rowDisclosure.tsx`, pinned at KiroCrew revision
+`283e136c0f902e965a535a7c9548c57c7504fed0`.
+
+    Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+    This product includes software developed at Amazon.com, Inc.
+    (https://www.amazon.com/). Licensed under the Apache License, Version 2.0.
+
+Retained: ordered host-classified turns and contiguous groups, structural sharing,
+stable row owners during loose-to-turn promotion, running/default disclosure,
+host-restorable explicit pins, distinct request counting, tool-payload unmounting,
+mounted interim prose, and visible host-marked actionable or interactive rows.
+The host supplies row identity, redaction, conclusion and call classifications;
+the renderer owns no protocol parser, permission, session, event or success
+authority. Solid/Kobalte-compatible controls and keyed row owners replace React,
+Redux and Framer Motion ownership. Relevant test contracts come from
+`website/src/test/groupDisplayItems.test.ts`,
+`website/src/test/groupDisplayItems.structuralSharing.test.ts`,
+`website/src/test/TurnBlock.test.tsx`,
+`website/src/test/TurnBlock.disclosurePin.test.tsx`,
+`website/src/test/TurnBlock.disclosureDurable.test.tsx`,
+`website/src/test/TurnBlock.rowMemo.test.tsx` and
+`website/src/test/rowDisclosure.test.tsx`; compiled and Solid packed consumers are
+exercised in headless Chromium, WebKit and native Node SSR. Full runtime projection,
+durable application storage and production Chat adoption remain host-owned gates.

package/dist/components/conversation/index.d.ts

@@ -4,6 +4,7 @@ export { ConversationAvatar, type ConversationAvatarKind, type ConversationAvata
 export { ConversationSurface, type ConversationSurfaceProps, type ConversationReadingPosition, } from './conversation-surface';
 export { ComposerAttachmentButton, ComposerHint, MessageComposer, type MessageComposerProps, } from './message-composer';
 export { MessageBody, MessageDayDivider, MessageGroup, MessageRow, type MessageRowProps, } from './message-row';
+export { TranscriptComposition, transcriptDisclosureKey, type TranscriptCompositionProps, type TranscriptCompositionFold, type TranscriptCompositionRowContext, type TranscriptCompositionRendererProps, type TranscriptDisplayKind, type GroupedTranscript, type TranscriptDisplayItem, type TranscriptFoldState, type TranscriptFoldMode, type TranscriptFoldPlan, type TranscriptMounting, type TranscriptRow, type TranscriptTurnItem, } from './transcript-composition';
 export { AttachmentCard, ThreadPanel, type AttachmentCardProps, type ThreadPanelProps, } from './thread-panel';
 export { countLines, expandAll, findTokenRanges, formatToken, isPasteBlock, nextSeq, pruneBlocks, recollapsePastes, remapCarriedBlocks, shouldCollapse, stripTrailingBlankLines, tokenRangeAt, PASTE_THRESHOLD_CHARS, PASTE_THRESHOLD_LINES, PASTE_TOKEN_REGEX, type PasteBlock, } from './paste-tokens';
 //# sourceMappingURL=index.d.ts.map

package/dist/components/conversation/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/conversation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAChG,OAAO,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAChG,OAAO,EACL,kBAAkB,EAClB,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,GAC7B,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACL,mBAAmB,EACnB,KAAK,wBAAwB,EAC7B,KAAK,2BAA2B,GACjC,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EACL,wBAAwB,EACxB,YAAY,EACZ,eAAe,EACf,KAAK,oBAAoB,GAC1B,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,YAAY,EACZ,UAAU,EACV,KAAK,eAAe,GACrB,MAAM,eAAe,CAAA;AACtB,OAAO,EACL,cAAc,EACd,WAAW,EACX,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,GACtB,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EACL,UAAU,EACV,SAAS,EACT,eAAe,EACf,WAAW,EACX,YAAY,EACZ,OAAO,EACP,WAAW,EACX,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACd,uBAAuB,EACvB,YAAY,EACZ,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,EACjB,KAAK,UAAU,GAChB,MAAM,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/conversation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAChG,OAAO,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAChG,OAAO,EACL,kBAAkB,EAClB,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,GAC7B,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACL,mBAAmB,EACnB,KAAK,wBAAwB,EAC7B,KAAK,2BAA2B,GACjC,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EACL,wBAAwB,EACxB,YAAY,EACZ,eAAe,EACf,KAAK,oBAAoB,GAC1B,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,YAAY,EACZ,UAAU,EACV,KAAK,eAAe,GACrB,MAAM,eAAe,CAAA;AACtB,OAAO,EACL,qBAAqB,EACrB,uBAAuB,EACvB,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,EAC9B,KAAK,+BAA+B,EACpC,KAAK,kCAAkC,EACvC,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAClB,KAAK,kBAAkB,GACxB,MAAM,0BAA0B,CAAA;AACjC,OAAO,EACL,cAAc,EACd,WAAW,EACX,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,GACtB,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EACL,UAAU,EACV,SAAS,EACT,eAAe,EACf,WAAW,EACX,YAAY,EACZ,OAAO,EACP,WAAW,EACX,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACd,uBAAuB,EACvB,YAAY,EACZ,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,EACjB,KAAK,UAAU,GAChB,MAAM,gBAAgB,CAAA"}

package/dist/components/conversation/index.js

@@ -4,6 +4,7 @@ import { ConversationAvatar } from "./conversation-avatar.js";
 import { ConversationSurface } from "./conversation-surface.js";
 import { ComposerAttachmentButton, ComposerHint, MessageComposer } from "./message-composer.js";
 import { MessageBody, MessageDayDivider, MessageGroup, MessageRow } from "./message-row.js";
+import { TranscriptComposition, transcriptDisclosureKey } from "./transcript-composition.js";
 import { AttachmentCard, ThreadPanel } from "./thread-panel.js";
 import { PASTE_THRESHOLD_CHARS, PASTE_THRESHOLD_LINES, PASTE_TOKEN_REGEX, countLines, expandAll, findTokenRanges, formatToken, isPasteBlock, nextSeq, pruneBlocks, recollapsePastes, remapCarriedBlocks, shouldCollapse, stripTrailingBlankLines, tokenRangeAt } from "./paste-tokens.js";
-export { AttachmentCard, BusySendButton, ChatComposer, ComposerAttachmentButton, ComposerHint, ConversationAvatar, ConversationSurface, MessageBody, MessageComposer, MessageDayDivider, MessageGroup, MessageRow, PASTE_THRESHOLD_CHARS, PASTE_THRESHOLD_LINES, PASTE_TOKEN_REGEX, ThreadPanel, countLines, expandAll, findTokenRanges, formatToken, isPasteBlock, nextSeq, pruneBlocks, recollapsePastes, remapCarriedBlocks, shouldCollapse, stripTrailingBlankLines, tokenRangeAt };
+export { AttachmentCard, BusySendButton, ChatComposer, ComposerAttachmentButton, ComposerHint, ConversationAvatar, ConversationSurface, MessageBody, MessageComposer, MessageDayDivider, MessageGroup, MessageRow, PASTE_THRESHOLD_CHARS, PASTE_THRESHOLD_LINES, PASTE_TOKEN_REGEX, ThreadPanel, TranscriptComposition, countLines, expandAll, findTokenRanges, formatToken, isPasteBlock, nextSeq, pruneBlocks, recollapsePastes, remapCarriedBlocks, shouldCollapse, stripTrailingBlankLines, tokenRangeAt, transcriptDisclosureKey };

package/dist/components/conversation/transcript-composition.d.ts

@@ -0,0 +1,66 @@
+import type { Component, ComponentProps } from 'solid-js';
+import { type TranscriptRow } from './transcript-grouping';
+import { type TranscriptFoldMode, type TranscriptMounting } from './transcript-folding';
+export type TranscriptFoldState = 'default' | 'collapsed' | 'expanded';
+export type TranscriptDisplayKind = 'single' | 'group' | 'turn';
+export type { GroupedTranscript, TranscriptDisplayItem, TranscriptRow, TranscriptTurnItem, } from './transcript-grouping';
+export type { TranscriptFoldMode, TranscriptFoldPlan, TranscriptMounting, } from './transcript-folding';
+export type TranscriptCompositionFold = Readonly<{
+    /** Stable host persistence key. Use with `transcriptDisclosureKey` to seed a store. */
+    key: string;
+    mode: TranscriptFoldMode;
+    mounting: TranscriptMounting;
+    /** Distinct host-classified request IDs in this contiguous fold segment. */
+    callCount: number;
+}>;
+export type TranscriptCompositionRowContext = Readonly<{
+    /** Original index in the caller's row array, including rows hidden by the host. */
+    index: number;
+    /** The row's current position in the generic display composition. */
+    displayKind: TranscriptDisplayKind;
+    group?: Readonly<{
+        index: number;
+        size: number;
+    }>;
+    turn?: Readonly<{
+        /** Derived from the first stable row ID; presentation bookkeeping only. */
+        id: string;
+        /** A presentation state, never proof of successful runtime completion. */
+        complete: boolean;
+        interim: boolean;
+    }>;
+    fold?: TranscriptCompositionFold;
+}>;
+export type TranscriptCompositionRendererProps<T> = Readonly<{
+    /** Reactive Solid prop; a row component keeps its DOM owner stable as values update. */
+    row: TranscriptRow<T>;
+    context: TranscriptCompositionRowContext;
+}>;
+export type TranscriptCompositionProps<T> = Omit<ComponentProps<'div'>, 'children'> & {
+    /** Ordered, already redacted rows with host-supplied semantic classifications. */
+    rows: readonly TranscriptRow<T>[];
+    /** Render one host row. Permission, session, event and protocol authority stay outside this component. */
+    renderRow: Component<TranscriptCompositionRendererProps<T>>;
+    /** The host's current run state. Live rows stay mounted and expanded until settled. */
+    running?: boolean;
+    /** Reset scope for row identity and disclosure. It is not inferred from display content. */
+    resetKey?: string | number | null;
+    /** Default settled fold policy. `tools` keeps prose visible; `prose` retains a proven conclusion. */
+    foldMode?: TranscriptFoldMode;
+    /** Global command state. `collapsed` keeps hidden content mounted; prose folds only before a host-marked conclusion. */
+    foldState?: TranscriptFoldState;
+    onFoldStateChange?: (state: TranscriptFoldState) => void;
+    /** Optional controlled disclosure map keyed by `transcriptDisclosureKey`. */
+    disclosure?: ReadonlyMap<string, boolean>;
+    onDisclosureChange?: (key: string, expanded: boolean) => void;
+};
+/** Stable, transcript-scoped key for host-owned disclosure restoration. */
+export declare function transcriptDisclosureKey(resetKey: string | number | null | undefined, mode: TranscriptFoldMode, firstRowId: string): string;
+/**
+ * Compose host-classified rows into stable turns, contiguous groups and disclosures.
+ * Row render owners are keyed by `id` in a single list, so loose rows keep their DOM
+ * owners when the grouping threshold promotes them into a turn. The caller owns row
+ * identity, protocol meaning, redaction, permissions and durable conversation state.
+ */
+export declare function TranscriptComposition<T>(props: TranscriptCompositionProps<T>): import("solid-js").JSX.Element;
+//# sourceMappingURL=transcript-composition.d.ts.map

package/dist/components/conversation/transcript-composition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcript-composition.d.ts","sourceRoot":"","sources":["../../../src/components/conversation/transcript-composition.tsx"],"names":[],"mappings":"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"}

package/dist/components/conversation/transcript-composition.js

@@ -0,0 +1,395 @@
+import { cn } from "../../lib/utils.js";
+import { Button } from "../ui/button/button.js";
+import { applyTranscriptRunningState, createTranscriptGrouper } from "./transcript-grouping.js";
+import { planTranscriptFold } from "./transcript-folding.js";
+import { createComponent, effect, insert, memo, mergeProps, setAttribute, spread, template } from "solid-js/web";
+import { ChevronDown } from "lucide-solid";
+import { For, Show, createComponent as createComponent$1, createMemo, createSignal, createUniqueId, splitProps } from "solid-js";
+//#region src/components/conversation/transcript-composition.tsx
+var _tmpl$ = /*#__PURE__*/ template(`<div data-slot=transcript-row class="flex min-w-0 flex-col gap-1"><div data-slot=transcript-row-content>`);
+var _tmpl$2 = /*#__PURE__*/ template(`<span>`);
+var _tmpl$3 = /*#__PURE__*/ template(`<div class="flex justify-end">`);
+var _tmpl$4 = /*#__PURE__*/ template(`<div data-slot=transcript-composition><div data-slot=transcript-rows class="flex min-w-0 flex-col gap-1">`);
+var encodeId = (value) => encodeURIComponent(value);
+/** Stable, transcript-scoped key for host-owned disclosure restoration. */
+function transcriptDisclosureKey(resetKey, mode, firstRowId) {
+	return `transcript:${encodeId(String(resetKey ?? ""))}:${mode}:${encodeId(firstRowId)}`;
+}
+function panelId(instanceId, resetKey, rowId) {
+	return `${instanceId}-row-${encodeId(resetKey)}-${encodeId(rowId)}`;
+}
+function buttonId(instanceId, resetKey, segmentKey) {
+	return `${instanceId}-fold-${encodeId(resetKey)}-${encodeId(segmentKey)}`;
+}
+function sameGroup(a, b) {
+	return a === b || !!a && !!b && a.index === b.index && a.size === b.size;
+}
+function sameTurn(a, b) {
+	return a === b || !!a && !!b && a.id === b.id && a.complete === b.complete && a.interim === b.interim;
+}
+function sameFold(a, b) {
+	return a === b || !!a && !!b && a.key === b.key && a.mode === b.mode && a.mounting === b.mounting && a.callCount === b.callCount;
+}
+function sameFoldGroup(a, b) {
+	return a === b || !!a && !!b && a.key === b.key && a.callCount === b.callCount && a.rows.length === b.rows.length && a.rows.every((row, index) => row === b.rows[index]);
+}
+function sameRecord(a, b) {
+	return a.row === b.row && a.index === b.index && a.displayKind === b.displayKind && sameGroup(a.group, b.group) && sameTurn(a.turn, b.turn) && sameFold(a.fold, b.fold) && sameFoldGroup(a.foldControl, b.foldControl);
+}
+function firstRow(item) {
+	return item.kind === "single" ? item.row : item.rows[0];
+}
+function appendTurnItem(item, displayKind, turn, indices, into) {
+	if (item.kind === "single") {
+		into.push({
+			row: item.row,
+			index: indices.get(item.row) ?? item.index,
+			displayKind,
+			turn
+		});
+		return;
+	}
+	item.rows.forEach((row, index) => {
+		into.push({
+			row,
+			index: indices.get(row) ?? item.startIndex + index,
+			displayKind,
+			group: {
+				index,
+				size: item.rows.length
+			},
+			turn
+		});
+	});
+}
+function appendDisplayItem(item, indices, into) {
+	if (item.kind !== "turn") {
+		appendTurnItem(item, item.kind, void 0, indices, into);
+		return;
+	}
+	const turn = {
+		id: item.items.map(firstRow).find((row) => row)?.id ?? "empty-turn",
+		complete: item.complete,
+		interim: !!item.interim
+	};
+	for (const child of item.items) appendTurnItem(child, "turn", turn, indices, into);
+}
+function buildDisclosures(records, defaultMode, foldState, resetKey) {
+	const controls = [];
+	let scope = [];
+	const flushScope = () => {
+		if (!scope.length) return;
+		const rows = scope.map((record) => record.row);
+		const hasInterimTurn = scope.some((record) => record.turn?.interim);
+		const hasConclusion = scope.some((record) => record.row.conclusion);
+		const mode = hasInterimTurn ? "interim" : foldState === "default" ? defaultMode : foldState === "collapsed" ? hasConclusion ? "prose" : "tools" : "interim";
+		const plan = planTranscriptFold(rows, {
+			mode,
+			settled: true
+		});
+		const foldable = plan.entries.flatMap((entry, index) => entry.mounting === "always" ? [] : [{
+			record: scope[index],
+			mounting: entry.mounting
+		}]);
+		if (foldable.length) {
+			const control = {
+				key: transcriptDisclosureKey(resetKey, mode, scope[0]?.row.id ?? foldable[0].record.row.id),
+				mode,
+				callCount: plan.callCount,
+				rows: foldable.map(({ record }) => record.row)
+			};
+			controls.push(control);
+			foldable.forEach(({ record, mounting }, index) => {
+				record.fold = {
+					key: control.key,
+					mode: control.mode,
+					mounting: foldState === "collapsed" ? "hide-when-collapsed" : mounting,
+					callCount: control.callCount
+				};
+				if (index === 0) record.foldControl = control;
+			});
+		}
+		scope = [];
+	};
+	for (const record of records) {
+		if (record.row.opensTurn && scope.length) flushScope();
+		scope.push(record);
+	}
+	flushScope();
+	return controls;
+}
+function foldLabel(mode, count, expanded) {
+	const subject = mode === "tools" ? count === 1 ? "1 tool call" : count > 1 ? `${count} tool calls` : "tool details" : mode === "prose" ? "earlier activity" : "interim activity";
+	return `${expanded ? "Hide" : "Show"} ${subject}`;
+}
+function TranscriptRowEntry(props) {
+	const current = props.record;
+	const id = () => panelId(props.prefix, props.resetKey(), current().row.id);
+	const foldControl = () => current().foldControl;
+	const disclosureKey = () => current().fold?.key;
+	const expanded = () => {
+		const key = disclosureKey();
+		return key ? props.expanded(key)() : true;
+	};
+	const collapsed = () => !!current().fold && !expanded();
+	const disabled = () => props.running() || props.foldState() !== "default";
+	const context = () => ({
+		index: current().index,
+		displayKind: current().displayKind,
+		group: current().group,
+		turn: current().turn,
+		fold: current().fold
+	});
+	const groupIndex = () => current().group?.index;
+	const groupSize = () => current().group?.size;
+	const renderable = () => current().fold?.mounting !== "unmount-when-collapsed" || !collapsed();
+	const renderHostRow = () => createComponent$1(props.renderRow, {
+		get row() {
+			return current().row;
+		},
+		get context() {
+			return context();
+		}
+	});
+	const controlLabel = () => {
+		const control = foldControl();
+		return control ? foldLabel(control.mode, control.callCount, expanded()) : "";
+	};
+	const controlRows = () => foldControl()?.rows.map((row) => panelId(props.prefix, props.resetKey(), row.id)).join(" ");
+	return (() => {
+		var _el$ = _tmpl$(), _el$2 = _el$.firstChild;
+		insert(_el$, createComponent(Show, {
+			get when() {
+				return foldControl();
+			},
+			children: (control) => createComponent(Button, {
+				get id() {
+					return buttonId(props.prefix, props.resetKey(), control().key);
+				},
+				type: "button",
+				variant: "ghost",
+				size: "sm",
+				"class": "w-full justify-start",
+				get ["aria-label"]() {
+					return controlLabel();
+				},
+				get ["aria-controls"]() {
+					return controlRows();
+				},
+				get ["aria-expanded"]() {
+					return expanded();
+				},
+				get ["aria-disabled"]() {
+					return disabled() || void 0;
+				},
+				onClick: () => props.onToggle(control().key, !expanded()),
+				get children() {
+					return [createComponent(ChevronDown, {
+						"aria-hidden": "true",
+						"class": "size-4 shrink-0"
+					}), (() => {
+						var _el$3 = _tmpl$2();
+						insert(_el$3, controlLabel);
+						return _el$3;
+					})()];
+				}
+			})
+		}), _el$2);
+		insert(_el$2, createComponent(Show, {
+			get when() {
+				return memo(() => !!renderable())() ? current() : void 0;
+			},
+			children: (record) => {
+				record();
+				return renderHostRow();
+			}
+		}));
+		effect((_p$) => {
+			var _v$ = current().displayKind, _v$2 = groupIndex(), _v$3 = groupSize(), _v$4 = id(), _v$5 = collapsed(), _v$6 = collapsed() || void 0;
+			_v$ !== _p$.e && setAttribute(_el$, "data-display-kind", _p$.e = _v$);
+			_v$2 !== _p$.t && setAttribute(_el$, "data-group-index", _p$.t = _v$2);
+			_v$3 !== _p$.a && setAttribute(_el$, "data-group-size", _p$.a = _v$3);
+			_v$4 !== _p$.o && setAttribute(_el$2, "id", _p$.o = _v$4);
+			_v$5 !== _p$.i && (_el$2.hidden = _p$.i = _v$5);
+			_v$6 !== _p$.n && setAttribute(_el$2, "aria-hidden", _p$.n = _v$6);
+			return _p$;
+		}, {
+			e: void 0,
+			t: void 0,
+			a: void 0,
+			o: void 0,
+			i: void 0,
+			n: void 0
+		});
+		return _el$;
+	})();
+}
+/**
+* Compose host-classified rows into stable turns, contiguous groups and disclosures.
+* Row render owners are keyed by `id` in a single list, so loose rows keep their DOM
+* owners when the grouping threshold promotes them into a turn. The caller owns row
+* identity, protocol meaning, redaction, permissions and durable conversation state.
+*/
+function TranscriptComposition(props) {
+	const [local, rest] = splitProps(props, [
+		"class",
+		"rows",
+		"renderRow",
+		"running",
+		"resetKey",
+		"foldMode",
+		"foldState",
+		"onFoldStateChange",
+		"disclosure",
+		"onDisclosureChange"
+	]);
+	const instanceId = createUniqueId();
+	const grouper = createTranscriptGrouper();
+	const [internalFoldState, setInternalFoldState] = createSignal("default");
+	const rowHandles = /* @__PURE__ */ new Map();
+	const disclosureSignals = /* @__PURE__ */ new Map();
+	let lastResetKey = String(local.resetKey ?? "");
+	const resetKey = () => String(local.resetKey ?? "");
+	const foldState = () => local.foldState ?? internalFoldState();
+	const running = () => !!local.running;
+	const localDisclosure = (key) => {
+		let signal = disclosureSignals.get(key);
+		if (!signal) {
+			const [get, set] = createSignal(void 0);
+			signal = {
+				get,
+				set
+			};
+			disclosureSignals.set(key, signal);
+		}
+		return signal;
+	};
+	const disclosureExpanded = (key) => {
+		const signal = localDisclosure(key);
+		return () => {
+			if (running()) return true;
+			if (foldState() === "collapsed") return false;
+			if (foldState() === "expanded") return true;
+			return local.disclosure?.get(key) ?? signal.get() ?? false;
+		};
+	};
+	const grouped = createMemo(() => grouper(local.rows));
+	const layout = createMemo(() => {
+		const identity = resetKey();
+		if (identity !== lastResetKey) {
+			rowHandles.clear();
+			disclosureSignals.clear();
+			lastResetKey = identity;
+		}
+		const indexByRow = new Map(local.rows.map((row, index) => [row, index]));
+		const display = applyTranscriptRunningState(grouped(), running());
+		const records = [];
+		display.forEach((item) => appendDisplayItem(item, indexByRow, records));
+		return {
+			rows: records,
+			controls: buildDisclosures(records, local.foldMode ?? "tools", foldState(), identity)
+		};
+	});
+	const handles = createMemo(() => {
+		const live = /* @__PURE__ */ new Set();
+		const identity = resetKey();
+		const result = layout().rows.map((record) => {
+			const key = `${identity}\u001f${record.row.id}`;
+			live.add(key);
+			let handle = rowHandles.get(key);
+			if (!handle) {
+				const [get, set] = createSignal(record);
+				handle = {
+					key,
+					get,
+					set,
+					last: record
+				};
+				rowHandles.set(key, handle);
+			} else if (!sameRecord(handle.last, record)) {
+				handle.last = record;
+				handle.set(record);
+			}
+			return handle;
+		});
+		for (const key of rowHandles.keys()) if (!live.has(key)) rowHandles.delete(key);
+		return result;
+	});
+	const allControlIds = () => layout().controls.flatMap((control) => control.rows.map((row) => panelId(instanceId, resetKey(), row.id))).join(" ");
+	const updateFoldState = () => {
+		if (running()) return;
+		const current = foldState();
+		const next = current === "default" ? "collapsed" : current === "collapsed" ? "expanded" : "default";
+		if (local.foldState === void 0) setInternalFoldState(next);
+		local.onFoldStateChange?.(next);
+	};
+	const updateDisclosure = (key, expanded) => {
+		if (running() || foldState() !== "default") return;
+		if (local.disclosure) {
+			local.onDisclosureChange?.(key, expanded);
+			return;
+		}
+		localDisclosure(key).set(expanded);
+		local.onDisclosureChange?.(key, expanded);
+	};
+	return (() => {
+		var _el$4 = _tmpl$4(), _el$6 = _el$4.firstChild;
+		spread(_el$4, mergeProps({
+			get ["data-fold-state"]() {
+				return foldState();
+			},
+			get ["class"]() {
+				return cn("flex w-full min-w-0 flex-col gap-1", local.class);
+			}
+		}, rest), false, true);
+		insert(_el$4, createComponent(Show, {
+			get when() {
+				return local.onFoldStateChange;
+			},
+			get children() {
+				var _el$5 = _tmpl$3();
+				insert(_el$5, createComponent(Button, {
+					id: `${instanceId}-fold-all`,
+					type: "button",
+					variant: "ghost",
+					size: "sm",
+					get ["aria-controls"]() {
+						return allControlIds() || void 0;
+					},
+					get ["aria-disabled"]() {
+						return running() || void 0;
+					},
+					onClick: updateFoldState,
+					get children() {
+						return memo(() => foldState() === "default")() ? "Collapse all activity" : foldState() === "collapsed" ? "Expand all activity" : "Restore default folding";
+					}
+				}));
+				return _el$5;
+			}
+		}), _el$6);
+		insert(_el$6, createComponent(For, {
+			get each() {
+				return handles();
+			},
+			children: (handle) => createComponent(TranscriptRowEntry, {
+				get record() {
+					return handle.get;
+				},
+				get renderRow() {
+					return local.renderRow;
+				},
+				prefix: instanceId,
+				resetKey,
+				expanded: disclosureExpanded,
+				running,
+				foldState,
+				onToggle: updateDisclosure
+			})
+		}));
+		return _el$4;
+	})();
+}
+//#endregion
+export { TranscriptComposition, transcriptDisclosureKey };
+
+//# sourceMappingURL=transcript-composition.js.map