@flamingo-stack/openframe-frontend-core 0.0.564-snapshot.20260824155539 → 0.0.564

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flamingo-stack/openframe-frontend-core",
-  "version": "0.0.564-snapshot.20260824155539",
+  "version": "0.0.564",
   "description": "Shared design system and components for all Flamingo platforms",
   "type": "module",
   "main": "./dist/index.js",

package/src/components/chat/__tests__/ticket-event.test.ts

@@ -134,21 +134,6 @@ describe('chat stream reducer — ticket event', () => {
     ])
     expect(events(trailingSegments(reducer))).toHaveLength(3)
   })
-
-  it('stamps a live card with its arrival time, not the bubble timestamp', () => {
-    // The chunk carries no event time, so arrival IS the event time for a
-    // genuinely live receipt. Without the stamp the card renders the trailing
-    // bubble's timestamp — the turn's FIRST row, minutes stale by the time a
-    // resolve/reopen lands.
-    const reducer = createChatStreamReducer({ transport: 'nats' })
-    const before = Date.now()
-    feed(reducer, [resolvedChunk(1)])
-    const after = Date.now()
-    const [card] = events(trailingSegments(reducer))
-    expect(card.occurredAt).toBeInstanceOf(Date)
-    expect(card.occurredAt!.getTime()).toBeGreaterThanOrEqual(before)
-    expect(card.occurredAt!.getTime()).toBeLessThanOrEqual(after)
-  })
 })
 
 describe('accumulator — hydrate/catch-up overlap', () => {
@@ -277,75 +262,4 @@ describe('processHistoricalMessages — ticket event', () => {
     ])
     expect(messages.flatMap((m) => events(m.content))).toHaveLength(0)
   })
-
-  it('stamps each card with its OWN row time, not the bubble timestamp', () => {
-    // The reported bug: resolve/reopen rows grouped into one assistant bubble
-    // all rendered the bubble's timestamp — the FIRST row of the turn (the
-    // ticket-creation-era greeting), so every lifecycle card read the same
-    // stale time.
-    const rowAt = (id: string, createdAt: string, data: Record<string, unknown>): HistoricalMessage => ({
-      id,
-      createdAt,
-      owner: { type: 'ASSISTANT' },
-      messageData: [data as never],
-    })
-    const { messages } = processHistoricalMessages([
-      rowAt('m1', '2026-08-20T13:54:00Z', { type: 'TEXT', text: 'Hi! How can I help?' }),
-      rowAt('m2', '2026-08-20T14:10:00Z', { type: 'TICKET_EVENT', kind: 'RESOLVED', actorType: 'AI' }),
-      rowAt('m3', '2026-08-20T14:33:00Z', {
-        type: 'TICKET_EVENT',
-        kind: 'REOPENED',
-        actorType: 'CLIENT',
-        targetStatusKind: 'AI_ASSISTANCE',
-      }),
-    ])
-    expect(messages).toHaveLength(1)
-    // The bubble keeps the first row's time…
-    expect(messages[0].timestamp).toEqual(new Date('2026-08-20T13:54:00Z'))
-    // …but each card carries the time of its own event.
-    const cards = events(messages[0].content)
-    expect(cards.map((c) => c.occurredAt)).toEqual([
-      new Date('2026-08-20T14:10:00Z'),
-      new Date('2026-08-20T14:33:00Z'),
-    ])
-  })
-})
-
-describe('accumulator — occurredAt across the hydrate/catch-up overlap', () => {
-  it('keeps the hydrated row time when the seq-stamped redelivery carries none', () => {
-    const accumulator = new MessageSegmentAccumulator()
-    accumulator.addTicketEvent(
-      { kind: 'RESOLVED', actorId: 'fae', actorName: 'Fae', actorType: 'AI' },
-      undefined,
-      new Date('2026-08-20T14:10:00Z'),
-    )
-    // Same event redelivered live (JetStream catch-up): seq known, time not.
-    const segments = accumulator.addTicketEvent(
-      { kind: 'RESOLVED', actorId: 'fae', actorName: 'Fae', actorType: 'AI' },
-      412,
-    )
-    const rendered = events(segments)
-    expect(rendered).toHaveLength(1)
-    expect(rendered[0].streamSeq).toBe(412)
-    expect(rendered[0].occurredAt).toEqual(new Date('2026-08-20T14:10:00Z'))
-  })
-
-  it('keeps the hydrated row time over a LATE redelivery arrival stamp', () => {
-    // Reconnect catch-up redelivers an hour-old event stamped with its (late)
-    // arrival time — the hydrated twin's real row time must win.
-    const accumulator = new MessageSegmentAccumulator()
-    accumulator.addTicketEvent(
-      { kind: 'RESOLVED', actorId: 'fae', actorName: 'Fae', actorType: 'AI' },
-      undefined,
-      new Date('2026-08-20T14:10:00Z'),
-    )
-    const segments = accumulator.addTicketEvent(
-      { kind: 'RESOLVED', actorId: 'fae', actorName: 'Fae', actorType: 'AI' },
-      412,
-      new Date('2026-08-20T15:10:00Z'),
-    )
-    const rendered = events(segments)
-    expect(rendered).toHaveLength(1)
-    expect(rendered[0].occurredAt).toEqual(new Date('2026-08-20T14:10:00Z'))
-  })
 })

package/src/components/chat/chat-message-enhanced.tsx

@@ -652,9 +652,7 @@ const ChatMessageEnhanced = forwardRef<HTMLDivElement, ChatMessageEnhancedProps>
                 } else if (segment.type === 'ticket_escalated') {
                   return <TicketEscalatedMessage key={index} data={segment.data} timestamp={timestamp} />
                 } else if (segment.type === 'ticket_event') {
-                  // The card's own event time; the bubble timestamp is the
-                  // turn's FIRST row and lags every later lifecycle event.
-                  return <TicketEventMessage key={index} data={segment.data} timestamp={segment.occurredAt ?? timestamp} />
+                  return <TicketEventMessage key={index} data={segment.data} timestamp={timestamp} />
                 } else if (segment.type === 'error') {
                   return (
                     <ErrorMessageDisplay

package/src/components/chat/stream/chat-stream-reducer.ts

@@ -1378,13 +1378,7 @@ export function createChatStreamReducer(
           reason: event.reason,
           targetStatusKind: event.targetStatusKind,
         }
-        // The chunk carries no event time, so stamp arrival — for a genuinely
-        // live event that IS the event time. Without it the card falls back to
-        // the enclosing bubble's timestamp: the turn's FIRST row, minutes
-        // stale by the time a resolve/reopen lands. A catch-up redelivery of
-        // an already-hydrated event does NOT regress to arrival time —
-        // `addTicketEvent` keeps the first-known `occurredAt` on upsert.
-        const segments = accumulator.addTicketEvent(data, seq, new Date())
+        const segments = accumulator.addTicketEvent(data, seq)
         applyAccumulated(before, segments)
         // The card alone is not enough for a host that also tracks the
         // ticket's state: a RESOLVED/REOPENED arriving live must move the

package/src/components/chat/types/message.types.ts

@@ -359,14 +359,6 @@ export type TicketEventSegment = {
   type: 'ticket_event'
   data: TicketEventData
   streamSeq?: number
-  /** When THIS event happened (history: the persisted row's `createdAt`;
-   *  live: chunk arrival). Kept beside `streamSeq`, not in `data`: the
-   *  upsert's payload-equality fallback must keep matching a redelivered
-   *  chunk to its hydrated twin, and their times come from different clocks.
-   *  Without it the card inherits the surrounding assistant bubble's
-   *  timestamp — the FIRST row of the whole turn, so every lifecycle card
-   *  reads the same stale time. */
-  occurredAt?: Date
 }
 
 export type ErrorSegment = {

package/src/components/chat/utils/message-segment-accumulator.ts

@@ -550,12 +550,11 @@ export class MessageSegmentAccumulator {
    * by the same actor is payload-identical to the first resolve, and matching
    * the old card meant the final one never rendered.
    */
-  addTicketEvent(data: TicketEventData, streamSeq?: number, occurredAt?: Date): MessageSegment[] {
+  addTicketEvent(data: TicketEventData, streamSeq?: number): MessageSegment[] {
     const segment: TicketEventSegment = {
       type: 'ticket_event',
       data,
       ...(streamSeq !== undefined ? { streamSeq } : {}),
-      ...(occurredAt !== undefined ? { occurredAt } : {}),
     }
     let existingIndex =
       streamSeq !== undefined
@@ -582,13 +581,7 @@ export class MessageSegmentAccumulator {
       }
     }
     if (existingIndex !== -1) {
-      // The FIRST-known time wins: the hydrated twin carries the row's real
-      // `createdAt`, while a catch-up redelivery only knows its (late) arrival
-      // time — replacing wholesale would regress the card to arrival or, with
-      // neither side stamped, to the bubble timestamp.
-      const existing = this.segments[existingIndex] as TicketEventSegment
-      const occurredAt = existing.occurredAt ?? segment.occurredAt
-      this.segments[existingIndex] = occurredAt !== undefined ? { ...segment, occurredAt } : segment
+      this.segments[existingIndex] = segment
       return this.getSegments()
     }
     this.segments.push(segment)
@@ -741,7 +734,7 @@ export class MessageSegmentAccumulator {
           this.addTicketEscalated(segment.data)
           break
         case 'ticket_event':
-          this.addTicketEvent(segment.data, segment.streamSeq, segment.occurredAt)
+          this.addTicketEvent(segment.data, segment.streamSeq)
           break
         case 'error':
           this.addError(segment.title, segment.details)

package/src/components/chat/utils/process-historical-messages.ts

@@ -330,7 +330,6 @@ function applyHistoryEvent(
   options: MessageProcessingOptions,
   escalatedApprovals?: EscalatedApprovals,
   offerResolutions?: OfferResolutions,
-  rowCreatedAt?: Date,
 ): void {
   // batchApprovalsEnabled is owned by the consumer (oss-tenant chat client /
   // openframe-frontend tickets). Defaults to ON so consumers that haven't
@@ -363,21 +362,14 @@ function applyHistoryEvent(
     // same event matches this segment by payload equality (see
     // `addTicketEvent`).
     case 'ticket-event':
-      // `rowCreatedAt` is the persisted row's own time — without it the card
-      // renders the enclosing assistant bubble's timestamp, i.e. the FIRST
-      // row of the turn, and every lifecycle card reads the same stale time.
-      accumulator.addTicketEvent(
-        {
-          kind: event.kind,
-          actorId: event.actorId,
-          actorName: event.actorName,
-          actorType: event.actorType,
-          reason: event.reason,
-          targetStatusKind: event.targetStatusKind,
-        },
-        undefined,
-        rowCreatedAt,
-      )
+      accumulator.addTicketEvent({
+        kind: event.kind,
+        actorId: event.actorId,
+        actorName: event.actorName,
+        actorType: event.actorType,
+        reason: event.reason,
+        targetStatusKind: event.targetStatusKind,
+      })
       break
 
     case 'escalation-offer-resolved':
@@ -746,7 +738,6 @@ export function processHistoricalMessages(
           { displayApprovalTypes, batchApprovalsEnabled, escalationOfferStates },
           escalatedApprovals,
           offerResolutions,
-          new Date(msg.createdAt),
         )
       })