@puredesktop/puredesktop-ui-bridge 2.1.8 → 2.1.9

package/src/ics/generateIcs.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, it } from 'vitest'
+import {
+  escapeIcsText,
+  foldIcsLine,
+  generateIcsCalendar,
+  generateIcsEventExport,
+  generateIcsReply,
+} from './generateIcs.js'
+
+const BASE = {
+  uid: 'uid-123@pure.science',
+  timestamp: '2026-07-04T10:00:00.000Z',
+  title: 'Project kickoff',
+  startsAt: '2026-07-10T09:00:00.000Z',
+  endsAt: '2026-07-10T10:00:00.000Z',
+}
+
+describe('generateIcsCalendar', () => {
+  it('emits a valid REQUEST with organizer and attendees', () => {
+    const ics = generateIcsCalendar({
+      ...BASE,
+      method: 'REQUEST',
+      sequence: 1,
+      description: 'Agenda:\n- intro; goals, scope',
+      location: 'Room 4',
+      organizer: { email: 'adam@pure.science', name: 'Adam' },
+      attendees: [
+        { email: 'boss@pure.science', name: 'Boss', rsvp: true, partstat: 'NEEDS-ACTION' },
+      ],
+    })
+
+    expect(ics).toContain('BEGIN:VCALENDAR')
+    expect(ics).toContain('METHOD:REQUEST')
+    expect(ics).toContain('UID:uid-123@pure.science')
+    expect(ics).toContain('SEQUENCE:1')
+    expect(ics).toContain('DTSTART:20260710T090000Z')
+    expect(ics).toContain('DTEND:20260710T100000Z')
+    expect(ics).toContain('DTSTAMP:20260704T100000Z')
+    expect(ics).toContain('SUMMARY:Project kickoff')
+    expect(ics).toContain('DESCRIPTION:Agenda:\\n- intro\\; goals\\, scope')
+    expect(ics).toContain('ORGANIZER;CN=Adam:mailto:adam@pure.science')
+    expect(ics).toContain(
+      'ATTENDEE;CN=Boss;PARTSTAT=NEEDS-ACTION;RSVP=TRUE:mailto:boss@pure.science',
+    )
+    expect(ics.endsWith('END:VCALENDAR\r\n')).toBe(true)
+    // CRLF line endings throughout.
+    expect(ics.includes('\n')).toBe(true)
+    expect(ics.split('\r\n').some(line => line.includes('\n'))).toBe(false)
+  })
+
+  it('emits DATE values for all-day events', () => {
+    const ics = generateIcsCalendar({
+      ...BASE,
+      method: 'REQUEST',
+      allDay: true,
+      startsAt: '2026-07-10',
+      endsAt: '2026-07-11',
+    })
+    expect(ics).toContain('DTSTART;VALUE=DATE:20260710')
+    expect(ics).toContain('DTEND;VALUE=DATE:20260711')
+  })
+
+  it('defaults CANCEL to STATUS:CANCELLED', () => {
+    const ics = generateIcsCalendar({ ...BASE, method: 'CANCEL', sequence: 3 })
+    expect(ics).toContain('METHOD:CANCEL')
+    expect(ics).toContain('STATUS:CANCELLED')
+    expect(ics).toContain('SEQUENCE:3')
+  })
+
+  it('includes RRULE when provided', () => {
+    const ics = generateIcsCalendar({
+      ...BASE,
+      method: 'REQUEST',
+      rrule: 'FREQ=WEEKLY;INTERVAL=2;COUNT=5',
+    })
+    expect(ics).toContain('RRULE:FREQ=WEEKLY;INTERVAL=2;COUNT=5')
+  })
+
+  it('rejects invalid dates', () => {
+    expect(() =>
+      generateIcsCalendar({ ...BASE, method: 'REQUEST', startsAt: 'garbage' }),
+    ).toThrow(/Invalid ICS date-time/)
+  })
+
+  it('omits METHOD and forces no STATUS for a plain export (no method)', () => {
+    const ics = generateIcsCalendar({ ...BASE })
+    expect(ics).toContain('BEGIN:VCALENDAR')
+    expect(ics).toContain('END:VCALENDAR')
+    expect(ics).toContain('BEGIN:VEVENT')
+    expect(ics).toContain('END:VEVENT')
+    expect(ics).toContain('SUMMARY:Project kickoff')
+    expect(ics).toContain('DTSTART:20260710T090000Z')
+    expect(ics).toContain('DTEND:20260710T100000Z')
+    expect(ics).not.toContain('METHOD:')
+    expect(ics).not.toContain('STATUS:')
+  })
+})
+
+describe('generateIcsEventExport', () => {
+  it('produces a plain VCALENDAR with the event and no METHOD', () => {
+    const ics = generateIcsEventExport({
+      ...BASE,
+      description: 'Agenda',
+      location: 'Room 4',
+    })
+    expect(ics).toContain('BEGIN:VEVENT')
+    expect(ics).toContain('SUMMARY:Project kickoff')
+    expect(ics).toContain('DTSTART:20260710T090000Z')
+    expect(ics).toContain('LOCATION:Room 4')
+    expect(ics).not.toContain('METHOD:')
+  })
+})
+
+describe('generateIcsReply', () => {
+  it('answers an invite with the attendee partstat and echoed sequence', () => {
+    const ics = generateIcsReply({
+      uid: 'uid-123@pure.science',
+      sequence: 2,
+      timestamp: '2026-07-04T10:00:00.000Z',
+      title: 'Project kickoff',
+      startsAt: '2026-07-10T09:00:00.000Z',
+      endsAt: '2026-07-10T10:00:00.000Z',
+      organizer: { email: 'boss@pure.science' },
+      attendee: { email: 'adam@pure.science', name: 'Adam' },
+      response: 'accepted',
+    })
+    expect(ics).toContain('METHOD:REPLY')
+    expect(ics).toContain('SEQUENCE:2')
+    expect(ics).toContain(
+      'ATTENDEE;CN=Adam;PARTSTAT=ACCEPTED:mailto:adam@pure.science',
+    )
+    expect(ics).toContain('ORGANIZER:mailto:boss@pure.science')
+  })
+})
+
+describe('formatting helpers', () => {
+  it('escapes TEXT values per RFC 5545', () => {
+    expect(escapeIcsText('a,b;c\\d\ne')).toBe('a\\,b\\;c\\\\d\\ne')
+  })
+
+  it('folds long lines with leading-space continuations', () => {
+    const folded = foldIcsLine(`SUMMARY:${'x'.repeat(200)}`)
+    const lines = folded.split('\r\n')
+    expect(lines.length).toBeGreaterThan(2)
+    expect(lines[0]?.length).toBe(75)
+    for (const continuation of lines.slice(1)) {
+      expect(continuation.startsWith(' ')).toBe(true)
+      expect(continuation.length).toBeLessThanOrEqual(75)
+    }
+    // Unfolding restores the original.
+    expect(folded.replace(/\r\n /g, '')).toBe(`SUMMARY:${'x'.repeat(200)}`)
+  })
+})

package/src/ics/generateIcs.ts

@@ -0,0 +1,197 @@
+/**
+ * Minimal iCalendar (RFC 5545) writer for the mail↔calendar invite loop:
+ * `REQUEST` (send/update an invite), `REPLY` (RSVP), `CANCEL`.
+ *
+ * All date-times are emitted in UTC (`...Z`) so no VTIMEZONE component is
+ * needed; all-day events use DATE values. Output round-trips through the
+ * ICAL.js parser used by PureMail's invite reader.
+ */
+
+export type IcsMethod = 'REQUEST' | 'REPLY' | 'CANCEL'
+
+export type IcsPartstat =
+  | 'ACCEPTED'
+  | 'DECLINED'
+  | 'TENTATIVE'
+  | 'NEEDS-ACTION'
+
+export interface IcsPerson {
+  email: string
+  name?: string
+  partstat?: IcsPartstat
+  /** RSVP requested from this attendee (REQUEST invites). */
+  rsvp?: boolean
+}
+
+export interface IcsEventInput {
+  uid: string
+  /**
+   * iTIP method. Omit for a plain (non-iTIP) VCALENDAR — e.g. "Download .ics"
+   * of an event to share. When undefined, no `METHOD:` line is emitted.
+   */
+  method?: IcsMethod
+  /** Bumped by the organizer on every update; echoed in replies. */
+  sequence?: number
+  /** ISO timestamp for DTSTAMP — pass explicitly so output is deterministic. */
+  timestamp: string
+  title: string
+  description?: string
+  location?: string
+  /** ISO date-time (or YYYY-MM-DD when allDay). */
+  startsAt: string
+  endsAt: string
+  allDay?: boolean
+  organizer?: IcsPerson
+  attendees?: IcsPerson[]
+  status?: 'CONFIRMED' | 'CANCELLED' | 'TENTATIVE'
+  /** Full RRULE value, e.g. `FREQ=WEEKLY;INTERVAL=1` (no `RRULE:` prefix). */
+  rrule?: string
+}
+
+/** RFC 5545 §3.3.11 TEXT escaping. */
+export function escapeIcsText(value: string): string {
+  return value
+    .replace(/\\/g, '\\\\')
+    .replace(/;/g, '\\;')
+    .replace(/,/g, '\\,')
+    .replace(/\r?\n/g, '\\n')
+}
+
+/** RFC 5545 §3.1 line folding at 75 octets (approximated per char). */
+export function foldIcsLine(line: string): string {
+  if (line.length <= 75) return line
+  const parts: string[] = []
+  let rest = line
+  parts.push(rest.slice(0, 75))
+  rest = rest.slice(75)
+  while (rest.length > 74) {
+    parts.push(` ${rest.slice(0, 74)}`)
+    rest = rest.slice(74)
+  }
+  if (rest) parts.push(` ${rest}`)
+  return parts.join('\r\n')
+}
+
+function utcBasic(iso: string): string {
+  const date = new Date(iso)
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(`Invalid ICS date-time: ${iso}`)
+  }
+  return date
+    .toISOString()
+    .replace(/[-:]/g, '')
+    .replace(/\.\d{3}Z$/, 'Z')
+}
+
+function dateBasic(iso: string): string {
+  const day = iso.slice(0, 10)
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(day)) {
+    throw new Error(`Invalid ICS date: ${iso}`)
+  }
+  return day.replace(/-/g, '')
+}
+
+function personProperty(
+  property: 'ORGANIZER' | 'ATTENDEE',
+  person: IcsPerson,
+): string {
+  const params: string[] = []
+  if (person.name) params.push(`CN=${escapeIcsText(person.name)}`)
+  if (property === 'ATTENDEE') {
+    if (person.partstat) params.push(`PARTSTAT=${person.partstat}`)
+    if (person.rsvp) params.push('RSVP=TRUE')
+  }
+  const paramText = params.length ? `;${params.join(';')}` : ''
+  return `${property}${paramText}:mailto:${person.email}`
+}
+
+export function generateIcsCalendar(input: IcsEventInput): string {
+  const lines: string[] = [
+    'BEGIN:VCALENDAR',
+    'PRODID:-//PureScience//PureDesktop//EN',
+    'VERSION:2.0',
+    ...(input.method ? [`METHOD:${input.method}`] : []),
+    'BEGIN:VEVENT',
+    `UID:${escapeIcsText(input.uid)}`,
+    `DTSTAMP:${utcBasic(input.timestamp)}`,
+    `SEQUENCE:${input.sequence ?? 0}`,
+    input.allDay
+      ? `DTSTART;VALUE=DATE:${dateBasic(input.startsAt)}`
+      : `DTSTART:${utcBasic(input.startsAt)}`,
+    input.allDay
+      ? `DTEND;VALUE=DATE:${dateBasic(input.endsAt)}`
+      : `DTEND:${utcBasic(input.endsAt)}`,
+    `SUMMARY:${escapeIcsText(input.title)}`,
+  ]
+  if (input.description) {
+    lines.push(`DESCRIPTION:${escapeIcsText(input.description)}`)
+  }
+  if (input.location) {
+    lines.push(`LOCATION:${escapeIcsText(input.location)}`)
+  }
+  if (input.status ?? input.method === 'CANCEL') {
+    lines.push(`STATUS:${input.status ?? 'CANCELLED'}`)
+  }
+  if (input.rrule) lines.push(`RRULE:${input.rrule}`)
+  if (input.organizer) {
+    lines.push(personProperty('ORGANIZER', input.organizer))
+  }
+  for (const attendee of input.attendees ?? []) {
+    lines.push(personProperty('ATTENDEE', attendee))
+  }
+  lines.push('END:VEVENT', 'END:VCALENDAR')
+  return `${lines.map(foldIcsLine).join('\r\n')}\r\n`
+}
+
+/**
+ * Plain event export: a VCALENDAR with no iTIP METHOD, for "Download .ics"
+ * of an event to share.
+ */
+export function generateIcsEventExport(
+  input: Omit<IcsEventInput, 'method'>,
+): string {
+  return generateIcsCalendar(input)
+}
+
+export interface IcsReplyInput {
+  /** UID of the invite being answered — must match the original. */
+  uid: string
+  /** SEQUENCE of the invite being answered — echoed back. */
+  sequence?: number
+  timestamp: string
+  title: string
+  startsAt: string
+  endsAt: string
+  allDay?: boolean
+  organizer: IcsPerson
+  /** The account answering the invite. */
+  attendee: IcsPerson
+  response: 'accepted' | 'declined' | 'tentative'
+}
+
+const PARTSTAT_BY_RESPONSE: Record<IcsReplyInput['response'], IcsPartstat> = {
+  accepted: 'ACCEPTED',
+  declined: 'DECLINED',
+  tentative: 'TENTATIVE',
+}
+
+/** iMIP RSVP: a `METHOD:REPLY` VCALENDAR mailed back to the organizer. */
+export function generateIcsReply(input: IcsReplyInput): string {
+  return generateIcsCalendar({
+    uid: input.uid,
+    method: 'REPLY',
+    ...(input.sequence !== undefined ? { sequence: input.sequence } : {}),
+    timestamp: input.timestamp,
+    title: input.title,
+    startsAt: input.startsAt,
+    endsAt: input.endsAt,
+    ...(input.allDay ? { allDay: true } : {}),
+    organizer: input.organizer,
+    attendees: [
+      {
+        ...input.attendee,
+        partstat: PARTSTAT_BY_RESPONSE[input.response],
+      },
+    ],
+  })
+}

package/src/index.ts

@@ -140,11 +140,14 @@ export {
   ConnectionSetupGrid,
   ConnectionSetupPage,
   ConnectionStepList,
+  ProviderConnection,
   type ConnectionOptionCardProps,
   type ConnectionOptionTone,
   type ConnectionSavedCardProps,
   type ConnectionSetupPageProps,
   type ConnectionStep,
+  type ProviderConnectionClient,
+  type ProviderConnectionProps,
 } from './components/common/connections/index.js'
 export {
   OpenReviewCard,

package/src/net/httpRetry.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, it, vi } from 'vitest'
+import {
+  retryAfterMs,
+  withHttpRetry,
+  type HttpRetryOptions,
+} from './httpRetry.js'
+
+function response(status: number, headers?: Record<string, string>) {
+  return { status, ok: status >= 200 && status < 300, headers }
+}
+
+function options(overrides: HttpRetryOptions = {}): HttpRetryOptions {
+  return {
+    sleep: vi.fn(async () => undefined),
+    random: () => 1,
+    now: () => 1_800_000_000_000,
+    ...overrides,
+  }
+}
+
+describe('withHttpRetry', () => {
+  it('returns a success immediately', async () => {
+    const attempt = vi.fn(async () => response(200))
+    const result = await withHttpRetry(attempt, options())
+    expect(result.status).toBe(200)
+    expect(attempt).toHaveBeenCalledTimes(1)
+  })
+
+  it('does not retry non-retryable client errors', async () => {
+    const attempt = vi.fn(async () => response(403))
+    const result = await withHttpRetry(attempt, options())
+    expect(result.status).toBe(403)
+    expect(attempt).toHaveBeenCalledTimes(1)
+  })
+
+  it('retries 429 and 5xx with exponential backoff until success', async () => {
+    const sleep = vi.fn(async (_ms: number) => undefined)
+    const responses = [response(429), response(500), response(200)]
+    const attempt = vi.fn(async () => responses.shift() ?? response(200))
+    const result = await withHttpRetry(
+      attempt,
+      options({ sleep, maxAttempts: 3 }),
+    )
+    expect(result.status).toBe(200)
+    expect(attempt).toHaveBeenCalledTimes(3)
+    expect(sleep).toHaveBeenCalledTimes(2)
+    // Full-jitter with random()=1 → the raw step: 500ms then 1000ms.
+    expect(sleep.mock.calls.map(call => call[0])).toEqual([500, 1000])
+  })
+
+  it('returns the last failure when the budget is exhausted', async () => {
+    const attempt = vi.fn(async () => response(503))
+    const result = await withHttpRetry(attempt, options({ maxAttempts: 2 }))
+    expect(result.status).toBe(503)
+    expect(attempt).toHaveBeenCalledTimes(2)
+  })
+
+  it('honors Retry-After seconds over computed backoff', async () => {
+    const sleep = vi.fn(async (_ms: number) => undefined)
+    const responses = [response(429, { 'retry-after': '2' }), response(200)]
+    const attempt = vi.fn(async () => responses.shift() ?? response(200))
+    await withHttpRetry(attempt, options({ sleep }))
+    expect(sleep).toHaveBeenCalledWith(2000)
+  })
+
+  it('retries a 401 exactly once', async () => {
+    const responses = [response(401), response(401)]
+    const attempt = vi.fn(async () => responses.shift() ?? response(200))
+    const result = await withHttpRetry(attempt, options())
+    // Second 401 is returned, not retried again.
+    expect(result.status).toBe(401)
+    expect(attempt).toHaveBeenCalledTimes(2)
+  })
+
+  it('recovers when the 401 retry succeeds', async () => {
+    const responses = [response(401), response(200)]
+    const attempt = vi.fn(async () => responses.shift() ?? response(200))
+    const result = await withHttpRetry(attempt, options())
+    expect(result.status).toBe(200)
+  })
+
+  it('retries thrown network errors and rethrows the last one', async () => {
+    const attempt = vi.fn(async () => {
+      throw new Error('socket hang up')
+    })
+    await expect(
+      withHttpRetry(attempt, options({ maxAttempts: 3 })),
+    ).rejects.toThrow('socket hang up')
+    expect(attempt).toHaveBeenCalledTimes(3)
+  })
+
+  it('recovers from a transient network error', async () => {
+    let first = true
+    const attempt = vi.fn(async () => {
+      if (first) {
+        first = false
+        throw new Error('reset')
+      }
+      return response(200)
+    })
+    const result = await withHttpRetry(attempt, options())
+    expect(result.status).toBe(200)
+  })
+})
+
+describe('retryAfterMs', () => {
+  const NOW = Date.parse('2026-07-04T10:00:00.000Z')
+
+  it('parses seconds and http-dates and rejects garbage', () => {
+    expect(retryAfterMs({ 'retry-after': '3' }, NOW)).toBe(3000)
+    expect(
+      retryAfterMs({ 'Retry-After': 'Sat, 04 Jul 2026 10:00:05 GMT' }, NOW),
+    ).toBe(5000)
+    expect(retryAfterMs({ 'retry-after': 'soon' }, NOW)).toBeNull()
+    expect(retryAfterMs(undefined, NOW)).toBeNull()
+  })
+})

package/src/net/httpRetry.ts

@@ -0,0 +1,111 @@
+/**
+ * Retry policy for provider API calls (Gmail, Google Calendar):
+ * - 429 and 5xx retry with exponential backoff, honoring `Retry-After`
+ *   (seconds or HTTP-date) when the server sends one.
+ * - 401 retries exactly once — the attempt callback re-requests its access
+ *   token per attempt, and the shell refreshes transparently, so a single
+ *   retry covers a token revoked mid-flight without loops.
+ * - Thrown attempt errors (network failures) retry like 5xx.
+ * The final response (or error) is returned/rethrown untouched so callers
+ * keep their existing error handling.
+ */
+
+export interface RetryableHttpResponse {
+  status: number
+  ok: boolean
+  headers?: Record<string, string>
+}
+
+export interface HttpRetryOptions {
+  /** Total attempts including the first (default 3). */
+  maxAttempts?: number
+  baseDelayMs?: number
+  maxDelayMs?: number
+  sleep?: (ms: number) => Promise<void>
+  /** 0..1 jitter source; injectable for tests. */
+  random?: () => number
+  now?: () => number
+}
+
+const DEFAULT_MAX_ATTEMPTS = 3
+const DEFAULT_BASE_DELAY_MS = 500
+const DEFAULT_MAX_DELAY_MS = 8_000
+
+function defaultSleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+export function retryAfterMs(
+  headers: Record<string, string> | undefined,
+  now: number,
+): number | null {
+  const raw =
+    headers?.['retry-after'] ??
+    headers?.['Retry-After'] ??
+    headers?.['RETRY-AFTER']
+  if (!raw) return null
+  const seconds = Number(raw)
+  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1000
+  const date = Date.parse(raw)
+  if (!Number.isNaN(date)) return Math.max(0, date - now)
+  return null
+}
+
+function isRetryableStatus(status: number): boolean {
+  return status === 429 || (status >= 500 && status <= 599)
+}
+
+export async function withHttpRetry<T extends RetryableHttpResponse>(
+  attempt: (attemptIndex: number) => Promise<T>,
+  options: HttpRetryOptions = {},
+): Promise<T> {
+  const maxAttempts = Math.max(1, options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS)
+  const baseDelayMs = options.baseDelayMs ?? DEFAULT_BASE_DELAY_MS
+  const maxDelayMs = options.maxDelayMs ?? DEFAULT_MAX_DELAY_MS
+  const sleep = options.sleep ?? defaultSleep
+  const random = options.random ?? Math.random
+  const now = options.now ?? Date.now
+
+  let unauthorizedRetried = false
+  let attemptIndex = 0
+  // Retry budget counts backoff retries; the single 401 retry is separate.
+  let retriesLeft = maxAttempts - 1
+
+  for (;;) {
+    let response: T | null = null
+    let failure: unknown = null
+    try {
+      response = await attempt(attemptIndex)
+    } catch (error) {
+      failure = error
+    }
+    attemptIndex += 1
+
+    if (response) {
+      if (response.ok || !isRetryableStatus(response.status)) {
+        if (response.status === 401 && !unauthorizedRetried) {
+          unauthorizedRetried = true
+          continue
+        }
+        return response
+      }
+    }
+
+    if (retriesLeft <= 0) {
+      if (failure !== null) throw failure
+      return response as T
+    }
+    retriesLeft -= 1
+
+    const serverDelay = response
+      ? retryAfterMs(response.headers, now())
+      : null
+    const backoffStep = Math.min(
+      maxDelayMs,
+      baseDelayMs * 2 ** (maxAttempts - 2 - retriesLeft),
+    )
+    // Half-to-full jitter keeps concurrent clients from thundering.
+    const jittered = backoffStep * (0.5 + random() / 2)
+    await sleep(Math.min(maxDelayMs, serverDelay ?? jittered))
+  }
+}

package/src/theme/appAccents.ts

@@ -115,6 +115,12 @@ const APP_IDENTITY_ACCENTS: Record<string, DerivedAppAccent> = {
     accentMuted: 'oklch(0.955 0.03 282)',
     accentText: 'oklch(0.43 0.12 282)',
   },
+  gantt: {
+    accent: 'oklch(0.55 0.125 306)',
+    accentHover: 'oklch(0.43 0.12 306)',
+    accentMuted: 'oklch(0.955 0.03 306)',
+    accentText: 'oklch(0.43 0.12 306)',
+  },
   review: {
     accent: 'oklch(0.55 0.125 300)',
     accentHover: 'oklch(0.43 0.12 300)',

package/src/theme/appIdentityCss.mjs

@@ -52,6 +52,10 @@ export const appIdentityCss = `
     --pure-violet: oklch(0.55 0.125 282);
     --pure-violet-bg: oklch(0.955 0.03 282);
     --pure-violet-tx: oklch(0.43 0.12 282);
+    --pure-gantt: oklch(0.55 0.125 306);
+    --pure-gantt-bg: oklch(0.955 0.03 306);
+    --pure-gantt-tx: oklch(0.43 0.12 306);
+    --pure-gantt-blk: oklch(0.4 0.07 306);
     --pure-purple: oklch(0.55 0.125 300);
     --pure-purple-bg: oklch(0.955 0.03 300);
     --pure-purple-tx: oklch(0.43 0.12 300);
@@ -168,6 +172,13 @@ export const appIdentityCss = `
     --app-text: var(--pure-violet-tx);
   }
 
+  [data-app='gantt'] {
+    --app-acc: var(--pure-gantt);
+    --app-block: var(--pure-gantt-blk);
+    --app-bg: var(--pure-gantt-bg);
+    --app-text: var(--pure-gantt-tx);
+  }
+
   [data-app='review'] {
     --app-acc: var(--pure-purple);
     --app-bg: var(--pure-purple-bg);

package/src/theme/appIdentityCss.ts

@@ -68,6 +68,10 @@ export const appIdentityCss = `
     --pure-violet-bg: oklch(0.955 0.03 282);
     --pure-violet-tx: oklch(0.43 0.12 282);
     --pure-violet-blk: oklch(0.4 0.07 282);
+    --pure-gantt: oklch(0.55 0.125 306);
+    --pure-gantt-bg: oklch(0.955 0.03 306);
+    --pure-gantt-tx: oklch(0.43 0.12 306);
+    --pure-gantt-blk: oklch(0.4 0.07 306);
     --pure-purple: oklch(0.55 0.125 300);
     --pure-purple-bg: oklch(0.955 0.03 300);
     --pure-purple-tx: oklch(0.43 0.12 300);
@@ -206,6 +210,13 @@ export const appIdentityCss = `
     --app-text: var(--pure-violet-tx);
   }
 
+  [data-app='gantt'] {
+    --app-acc: var(--pure-gantt);
+    --app-block: var(--pure-gantt-blk);
+    --app-bg: var(--pure-gantt-bg);
+    --app-text: var(--pure-gantt-tx);
+  }
+
   [data-app='review'] {
     --app-acc: var(--pure-purple);
     --app-block: var(--pure-purple-blk);

package/src/theme/themes/dark.ts

@@ -46,7 +46,9 @@ export const darkTheme: PlatformTheme = createPlatformTheme(
     semanticRedMuted: '#3a211d',
     semanticRedBorder: '#753f38',
     focus: accent,
-    selection: '#313135',
+    // Must contrast with surface-hover (#2c2c30) — otherwise text selected
+    // inside a focused/hovered field is invisible.
+    selection: neutral[600],
     /** Embedded plugin iframe canvas — must stay dark in dark mode */
     appViewport: '#202024',
     chromeTitlebar: '#202024',

package/src/theme/themes/light.ts

@@ -49,7 +49,9 @@ export const lightTheme: PlatformTheme = createPlatformTheme(
     semanticRedMuted: '#f4dfdc',
     semanticRedBorder: '#dfb7b1',
     focus: accent,
-    selection: neutral[100],
+    // Must contrast with surface-hover (also neutral[100]) — otherwise text
+    // selected inside a focused/hovered field is invisible.
+    selection: neutral[200],
     appViewport: neutral[25],
     chromeTitlebar: neutral[25],
     chromeTabStrip: neutral[75],