@kortix/ui 0.0.0-stage → 0.14.4

package/dist/customize/triggers/schedule/trigger-list.js

@@ -0,0 +1,87 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * The Triggers list (Paper C03 rows, C09 trailing slot). One 52 px row per
+ * trigger: the clock, which carries its health; the name over its schedule;
+ * and at the end the next run over the last run. The row opens the trigger;
+ * the selected row is `bg-muted`. Actions live in the sheet.
+ */
+import { Checkbox } from '../../../primitives/checkbox.js';
+import { SessionDotMatrix } from '../../../primitives/dot-matrix/session-dot-matrix.js';
+import { useLocale, useTranslations } from '../../../i18n/index.js';
+import { cn } from '../../../internal/lib/utils.js';
+import { Fragment } from 'react';
+import { describeNextRun, describeWhen, triggerName, triggerSubtitle } from './schedule-copy.js';
+import { TriggerTile } from './trigger-tile.js';
+const DAY = 24 * 60 * 60 * 1000;
+/** "next Mon 09:00", "next 08:45" today, "On event" for webhooks and app events, "Paused" while paused. */
+export function nextRunLabel(trigger, t, locale, now = Date.now()) {
+    // An auto-pause (KRTX-1721) is runtime state: the manifest still says enabled.
+    if (!trigger.enabled || trigger.auto_paused_at)
+        return t.raw('texte159b06187d3');
+    if (trigger.type !== 'cron')
+        return t.raw('text84b05fbb7f76');
+    const iso = trigger.next_cron_at ?? trigger.next_fire_at;
+    const at = iso ? Date.parse(iso) : Number.NaN;
+    if (!Number.isFinite(at))
+        return '—';
+    const date = new Date(at);
+    const time = date.toLocaleTimeString(locale, { hour: '2-digit', minute: '2-digit', second: '2-digit', timeZoneName: 'short' });
+    const today = new Date(now).toDateString() === date.toDateString();
+    const day = today
+        ? null
+        : at - now < 6 * DAY
+            ? date.toLocaleDateString(locale, { weekday: 'short' })
+            : date.toLocaleDateString(locale, { month: 'short', day: 'numeric' });
+    return t('text27a2c8b3a0d2', { value0: day ? `${day} ${time}` : time });
+}
+/** "2d ago", "9h ago", "3w ago" in the viewer's locale, or "Never run". */
+export function lastRunLabel(trigger, t, locale, now = Date.now()) {
+    const iso = trigger.last_fired_at ?? trigger.event?.last_event_at ?? null;
+    const at = iso ? Date.parse(iso) : Number.NaN;
+    if (!Number.isFinite(at))
+        return t.raw('text3d40a69d3160');
+    const rtf = new Intl.RelativeTimeFormat(locale, { style: 'narrow', numeric: 'auto' });
+    const min = Math.floor(Math.max(0, now - at) / 60_000);
+    if (min < 1)
+        return rtf.format(0, 'second');
+    if (min < 60)
+        return rtf.format(-min, 'minute');
+    if (min < 24 * 60)
+        return rtf.format(-Math.floor(min / 60), 'hour');
+    if (min < 7 * 24 * 60)
+        return rtf.format(-Math.floor(min / (24 * 60)), 'day');
+    return rtf.format(-Math.floor(min / (7 * 24 * 60)), 'week');
+}
+export function TriggerList({ triggers, groups, eventNames, selectedSlug, runningSlug = null, onOpen, selection = null, projectPaused = false, }) {
+    const row = (trigger) => (_jsx(TriggerRow, { trigger: trigger, eventNames: eventNames, selected: !selection && trigger.slug === selectedSlug, running: trigger.slug === runningSlug, onOpen: () => onOpen(trigger), checked: selection ? selection.selected.has(trigger.slug) : null, projectPaused: projectPaused, onToggle: (range) => selection?.onToggle(trigger, range) }, trigger.slug));
+    return (
+    // A resting panel (`bg-card`, border, `rounded-lg`), so the rows sit on a
+    // surface in both themes; hover is one step up, the open row one more.
+    _jsx("ul", { role: selection ? 'listbox' : undefined, "aria-multiselectable": selection ? true : undefined, className: "bg-card border-border flex flex-col rounded-lg border p-1", children: groups
+            ? groups.map((group) => (_jsxs(Fragment, { children: [_jsx("li", { role: selection ? 'presentation' : undefined, className: "px-3 pt-3.5 pb-1.5", children: group.heading }), group.triggers.map(row)] }, group.key)))
+            : triggers.map(row) }));
+}
+function TriggerRow({ trigger, eventNames, selected, running, onOpen, checked, onToggle, projectPaused, }) {
+    const t = useTranslations('hardcodedUi.i18nComplete');
+    const locale = useLocale();
+    const name = triggerName(trigger);
+    const subtitle = triggerSubtitle(name, describeWhen(trigger, eventNames), trigger.prompt_template);
+    const selecting = checked !== null;
+    const rowClass = cn('flex h-14 w-full items-center gap-3 rounded-md px-3 text-left outline-none', 'transition-[background-color] duration-(--duration-fast)', 
+    // One variable paints the row and the clock's dot disc, so the cutout
+    // always matches: rest = card, hover = muted at 60% over card, open = muted.
+    'bg-(--row-surface) [--row-surface:var(--card)]', selected || checked
+        ? '[--row-surface:var(--muted)]'
+        : 'hover:[--row-surface:color-mix(in_oklab,var(--muted)_60%,var(--card))] focus-visible:[--row-surface:color-mix(in_oklab,var(--muted)_60%,var(--card))]');
+    const cells = (_jsxs(_Fragment, { children: [_jsx("span", { className: "flex size-5 shrink-0 items-center justify-center", children: selecting ? (_jsx(Checkbox, { checked: checked, tabIndex: -1, "aria-hidden": true, className: "pointer-events-none" })) : (_jsx(TriggerTile, { trigger: trigger, projectPaused: projectPaused, running: running, surface: "row" })) }), _jsxs("span", { className: "flex min-w-0 flex-1 flex-col", children: [_jsx("span", { className: "text-foreground truncate text-sm leading-tight font-medium", children: name }), subtitle ? (_jsx("span", { className: "text-muted-foreground truncate text-xs leading-tight", children: subtitle })) : null] }), _jsxs("span", { className: "flex w-24 shrink-0 flex-col items-end text-xs tabular-nums", children: [_jsx("span", { title: projectPaused ? undefined : describeNextRun(trigger) ?? undefined, className: cn('whitespace-nowrap', trigger.enabled && !trigger.auto_paused_at && !projectPaused ? 'text-foreground' : 'text-muted-foreground'), children: nextRunLabel(projectPaused ? { ...trigger, enabled: false } : trigger, t, locale) }), running ? (_jsx("span", { className: "flex h-4 items-center", children: _jsx(SessionDotMatrix, { sessionId: trigger.slug, size: 14, className: "shrink-0" }) })) : (_jsx("span", { className: "text-muted-foreground whitespace-nowrap", children: lastRunLabel(trigger, t, locale) }))] })] }));
+    if (selecting) {
+        return (_jsx("li", { role: "option", "aria-selected": checked, tabIndex: 0, onClick: (e) => onToggle(e.shiftKey), onKeyDown: (e) => {
+                if (e.key === ' ' || e.key === 'Enter') {
+                    e.preventDefault();
+                    onToggle(e.shiftKey);
+                }
+            }, className: cn(rowClass, 'cursor-pointer select-none'), children: cells }));
+    }
+    return (_jsx("li", { children: _jsx("button", { type: "button", onClick: onOpen, "aria-current": selected ? 'true' : undefined, className: rowClass, children: cells }) }));
+}

package/dist/customize/triggers/schedule/trigger-options.d.ts

@@ -0,0 +1,14 @@
+import { type PatchDraft } from './composer-parts.js';
+import { type ComposerDraft } from './trigger-composer-logic.js';
+/** Options: everything with a sane default, folded away until asked for. */
+export declare function TriggerOptions({ projectId, draft, patch, name, open, onOpenChange, error, edit, }: {
+    projectId: string;
+    draft: ComposerDraft;
+    patch: PatchDraft;
+    name: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    error?: string;
+    /** A saved trigger: its ID is fixed, it is paused or resumed from the header, and a webhook's secret sits in the When block. */
+    edit?: boolean;
+}): import("react").JSX.Element;

package/dist/customize/triggers/schedule/trigger-options.js

@@ -0,0 +1,38 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Disclosure, DisclosureContent } from '../../../primitives/disclosure.js';
+import { Input } from '../../../primitives/input.js';
+import { Label } from '../../../primitives/label.js';
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '../../../primitives/select.js';
+import { Switch } from '../../../primitives/switch.js';
+import { SharingPicker } from '../../../access/sharing-picker.js';
+import { useTranslations as useI18nTranslations } from '../../../i18n/index.js';
+import { PROJECT_SESSION_NAME_LOOKUP_LIMIT, listProjectSessions } from '@kortix/sdk';
+import { contract, qk } from '@kortix/sdk/react';
+import { useQuery } from '@tanstack/react-query';
+import { FoldTrigger, InlineError } from './composer-parts.js';
+import { ConditionsEditor, RunLocationFields } from './schedule-fields.js';
+import { slugify } from './trigger-composer-logic.js';
+import { triggerSessionAccessCopy } from './trigger-session-access-copy.js';
+function OptionField({ label, hint, children, }) {
+    return (_jsxs("section", { className: "space-y-2", children: [_jsx("p", { className: "text-foreground text-sm font-medium", children: label }), children, hint ? (_jsx("p", { className: "text-muted-foreground text-xs leading-relaxed text-pretty", children: hint })) : null] }));
+}
+/** Options: everything with a sane default, folded away until asked for. */
+export function TriggerOptions({ projectId, draft, patch, name, open, onOpenChange, error, edit = false, }) {
+    const tI18nComplete = useI18nTranslations('hardcodedUi.i18nComplete');
+    const tComposer = useI18nTranslations('triggerComposer');
+    const sessions = useQuery({
+        queryKey: qk.project.sessions(projectId),
+        queryFn: () => listProjectSessions(projectId, { limit: PROJECT_SESSION_NAME_LOOKUP_LIMIT }),
+        enabled: draft.mode === 'pinned',
+        ...contract('inventory'),
+    });
+    const isCron = draft.kind === 'cron';
+    return (_jsxs(Disclosure, { className: "group", open: open, onOpenChange: onOpenChange, children: [_jsx(FoldTrigger, { children: tI18nComplete.raw('textd0db8b5e364b') }), _jsx(DisclosureContent, { children: _jsxs("div", { className: "space-y-6 pt-4", children: [_jsxs(OptionField, { label: tI18nComplete.raw('text345e6cf10469'), hint: tI18nComplete.raw('text319d909352ff'), children: [_jsx(RunLocationFields, { mode: draft.mode, onModeChange: (mode) => patch({
+                                        mode,
+                                        ...(mode !== 'pinned' ? { pinnedSessionId: null } : {}),
+                                        ...(mode !== 'keyed' ? { sessionKey: '' } : {}),
+                                    }), pinnedSessionId: draft.pinnedSessionId, onPinnedSessionChange: (pinnedSessionId) => patch({ pinnedSessionId }), sessionKey: draft.sessionKey, onSessionKeyChange: (sessionKey) => patch({ sessionKey }), sessions: sessions.data ?? [], sessionsLoading: sessions.isLoading }), _jsx(InlineError, { message: error })] }), _jsx(OptionField, { label: tI18nComplete.raw('textbc9424d3f527'), hint: tI18nComplete.raw('text8493c3761028'), children: _jsx(SharingPicker, { projectId: projectId, value: draft.sessionAccess, onChange: (sessionAccess) => patch({ sessionAccess }), showHeading: false, copy: triggerSessionAccessCopy(tI18nComplete) }) }), _jsx(OptionField, { label: tComposer('runLimits'), hint: tComposer('runLimitsHint'), children: _jsxs("div", { className: "grid grid-cols-2 gap-3", children: [_jsxs("div", { className: "space-y-1.5", children: [_jsx(Label, { htmlFor: "trigger-max-runs-per-hour", className: "text-muted-foreground text-xs font-normal", children: tComposer('perHour') }), _jsx(Input, { id: "trigger-max-runs-per-hour", type: "number", inputMode: "numeric", min: 1, step: 1, value: draft.maxRunsPerHour, onChange: (e) => patch({ maxRunsPerHour: e.target.value }), placeholder: "60", className: "text-sm tabular-nums" })] }), _jsxs("div", { className: "space-y-1.5", children: [_jsx(Label, { htmlFor: "trigger-max-runs-per-day", className: "text-muted-foreground text-xs font-normal", children: tComposer('perDay') }), _jsx(Input, { id: "trigger-max-runs-per-day", type: "number", inputMode: "numeric", min: 1, step: 1, value: draft.maxRunsPerDay, onChange: (e) => patch({ maxRunsPerDay: e.target.value }), placeholder: tComposer('noLimit'), className: "text-sm tabular-nums" })] })] }) }), draft.mode === 'fresh' && (_jsx(OptionField, { label: tComposer('overlap'), hint: tComposer('overlapHint'), children: _jsxs(Select, { value: draft.overlap, onValueChange: (v) => patch({ overlap: v }), children: [_jsx(SelectTrigger, { className: "w-full cursor-pointer text-sm", "aria-label": tComposer('overlap'), children: _jsx(SelectValue, {}) }), _jsxs(SelectContent, { children: [_jsx(SelectItem, { value: "default", className: "cursor-pointer", children: isCron ? tComposer('overlapDefaultSkip') : tComposer('overlapDefaultAllow') }), _jsx(SelectItem, { value: "skip", className: "cursor-pointer", children: tComposer('overlapSkip') }), _jsx(SelectItem, { value: "allow", className: "cursor-pointer", children: tComposer('overlapAllow') })] })] }) })), !isCron && (_jsx(OptionField, { label: tI18nComplete.raw('text94c7226773af'), hint: tI18nComplete.raw('text8e47e838d897'), children: _jsx(ConditionsEditor, { rows: draft.conditions, onChange: (conditions) => patch({ conditions }) }) })), draft.kind === 'webhook' && !edit && (_jsx(OptionField, { label: tI18nComplete.raw('text301cd463a175'), hint: tI18nComplete.raw('text432020e4f157'), children: _jsx(Input, { value: draft.secretName, onChange: (e) => patch({ secretName: e.target.value.toUpperCase() }), placeholder: "WEBHOOK_MY_TRIGGER_SECRET", className: "font-mono text-sm" }) })), !edit && (_jsxs(_Fragment, { children: [_jsx(OptionField, { label: tI18nComplete.raw('text7396f100afdf'), hint: isCron
+                                        ? tI18nComplete.raw('textfb2536db879a')
+                                        : tI18nComplete.raw('text9f2198f23b84'), children: _jsx(Input, { value: draft.customId, onChange: (e) => patch({ customId: e.target.value }), placeholder: name.trim() ? slugify(name.trim()) : 'daily-standup-digest', maxLength: 128, className: "font-mono text-sm" }) }), _jsx(OptionField, { label: tI18nComplete.raw('textd90c143bf007'), hint: tI18nComplete.raw('textbed03adbb73f'), children: _jsxs("div", { className: "bg-card flex items-center justify-between gap-3 rounded-md border px-3 py-2.5", children: [_jsx(Label, { htmlFor: "trigger-start-active", className: "text-sm font-normal", children: draft.startActive ? 'Active' : 'Paused' }), _jsx(Switch, { id: "trigger-start-active", checked: draft.startActive, onCheckedChange: (startActive) => patch({ startActive }) })] }) })] }))] }) })] }));
+}

package/dist/customize/triggers/schedule/trigger-readonly.d.ts

@@ -0,0 +1,8 @@
+import type { ProjectTrigger } from '@kortix/sdk';
+import { type EventAppIndex } from './event-trigger-copy.js';
+export declare function TriggerReadOnly({ trigger, apps, eventNames, agentLabel, }: {
+    trigger: ProjectTrigger;
+    apps: EventAppIndex;
+    eventNames: ReadonlyMap<string, string>;
+    agentLabel: string;
+}): import("react").JSX.Element;

package/dist/customize/triggers/schedule/trigger-readonly.js

@@ -0,0 +1,51 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+/** The sheet's body for a viewer who may not update the trigger: the same facts, as one read-only list. */
+import { useTranslations } from '../../../i18n/index.js';
+import { describeEventSource } from './event-trigger-copy.js';
+import { describeNextRun, describeRunLocation, describeWhen } from './schedule-copy.js';
+import { PropertyList, conditionNeedsValue, conditionsToRows, useConditionOperatorLabels } from './schedule-fields.js';
+function accessSummary(access) {
+    if (access.mode === 'project')
+        return 'Every project member can open trigger-created sessions.';
+    if (access.mode === 'members') {
+        const count = access.memberIds.length + access.groupIds.length;
+        return `${count} selected ${count === 1 ? 'member or group can' : 'members or groups can'} open trigger-created sessions.`;
+    }
+    return 'The trigger agent and project Managers can open trigger-created sessions.';
+}
+export function TriggerReadOnly({ trigger, apps, eventNames, agentLabel, }) {
+    const t = useTranslations('hardcodedUi.i18nComplete');
+    const operatorLabel = useConditionOperatorLabels();
+    const conditions = conditionsToRows(trigger.filter);
+    const when = [describeWhen(trigger, eventNames), describeNextRun(trigger)].filter(Boolean);
+    return (_jsx("section", { className: "bg-popover rounded-md border px-4 py-4", children: _jsx(PropertyList, { rows: [
+                { label: t.raw('textcf9c7aa24a26'), value: when.join(' · ') },
+                ...(trigger.event
+                    ? [
+                        {
+                            label: t.raw('text5441e7146193'),
+                            value: describeEventSource(trigger.event, t, apps),
+                        },
+                    ]
+                    : []),
+                {
+                    label: t.raw('textc74ea9dc9cd2'),
+                    value: _jsx("span", { className: "whitespace-pre-wrap", children: trigger.prompt_template }),
+                },
+                { label: t.raw('text11b39c93777e'), value: agentLabel },
+                { label: t.raw('text5e2c614c23f0'), value: trigger.model ?? t.raw('text57069bbd0d2e') },
+                { label: t.raw('text345e6cf10469'), value: describeRunLocation(trigger) },
+                { label: t.raw('textbc9424d3f527'), value: accessSummary(trigger.session_access) },
+                ...(trigger.type === 'cron'
+                    ? []
+                    : [
+                        {
+                            label: t.raw('text94c7226773af'),
+                            value: conditions.length === 0 ? (t.raw('textbce22443b335')) : (_jsx("span", { className: "space-y-0.5", children: conditions.map(({ path, operator = 'equals', value }) => (_jsx("code", { className: "block font-mono text-xs", children: operator === 'equals'
+                                        ? `${path} = ${value}`
+                                        : `${path} ${operatorLabel[operator]}${conditionNeedsValue(operator) ? ` ${value}` : ''}` }, path))) })),
+                        },
+                    ]),
+            ] }) }));
+}

package/dist/customize/triggers/schedule/trigger-runs-histogram.d.ts

@@ -0,0 +1,14 @@
+import type { ProjectTriggerRun } from '@kortix/sdk';
+/** A bar's window, epoch ms (`LogTimeRange` in `gateway-logs.tsx`). */
+export interface RunTimeRange {
+    start: number;
+    end: number;
+}
+/** "10:58 – 11:03 pm": the window's clock range (`fmtRange` in `gateway-logs.tsx`). */
+export declare function fmtRange(range: RunTimeRange): string;
+export declare function RunHistogram({ runs, live, onSelectRange, }: {
+    runs: ProjectTriggerRun[];
+    /** The newest page is the only page: the last tick reads "Now". */
+    live: boolean;
+    onSelectRange: (range: RunTimeRange) => void;
+}): import("react").JSX.Element | null;

package/dist/customize/triggers/schedule/trigger-runs-histogram.js

@@ -0,0 +1,68 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The Runs tab's histogram: the loaded runs over time, the Models page Logs
+ * histogram (`LogHistogram` in `gateway-logs.tsx`) fed with trigger runs.
+ * Same scale, spacing, colours, ticks, card and interaction: 48 equal time
+ * slices, bar height = runs per slice, a red cap = the failed share, a card on
+ * hover or keyboard focus, and a click narrows the list to that slice.
+ */
+import { HistogramBars } from '../../../primitives/histogram-bars.js';
+import { formatSessionCostCredits, formatSessionCostDuration, } from '../../../internal/billing/session-cost-format.js';
+import { useTranslations } from '../../../i18n/index.js';
+import { cn } from '../../../internal/lib/utils.js';
+import { Fragment, useMemo } from 'react';
+import { bucketRuns, medianDuration } from './trigger-runs-logic.js';
+/** "10:58 – 11:03 pm": the window's clock range (`fmtRange` in `gateway-logs.tsx`). */
+export function fmtRange(range) {
+    const clock = (ms) => new Date(ms).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+    return `${clock(range.start)} – ${clock(range.end)}`;
+}
+/** Bars per histogram, as on the Models page. */
+const HISTOGRAM_BUCKETS = 48;
+const fmtDuration = (ms) => formatSessionCostDuration(ms / 1000);
+/** The bucket card (Paper C15 `CH3-0`): range and run count, then Succeeded, Failed, Median duration, Cost. */
+function RunBucketCard({ bucket }) {
+    const t = useTranslations('hardcodedUi.i18nComplete');
+    const stats = [
+        [t.raw('text6d9a6f97a5fd'), bucket.succeeded.toLocaleString()],
+        [
+            t.raw('text031a8f0f659d'),
+            _jsx("span", { className: bucket.failed > 0 ? 'text-destructive' : undefined, children: bucket.failed.toLocaleString() }, "failed"),
+        ],
+        [t.raw('textfa14066e0399'), bucket.medianMs != null ? fmtDuration(bucket.medianMs) : '—'],
+        [t.raw('text204a5eb2cd28'), formatSessionCostCredits(bucket.cost)],
+    ];
+    // An open card sliding over an empty bucket: the range and "No runs", one line.
+    if (bucket.total === 0) {
+        return (_jsxs("div", { className: "flex items-baseline justify-between gap-3 text-xs tabular-nums", children: [_jsx("span", { className: "text-foreground font-medium whitespace-nowrap", children: fmtRange(bucket) }), _jsx("span", { className: "text-muted-foreground whitespace-nowrap", children: t.raw('text26735edf00f9') })] }));
+    }
+    return (_jsxs("div", { className: "flex flex-col gap-2 tabular-nums", children: [_jsxs("div", { className: "flex items-baseline justify-between gap-3 text-xs", children: [_jsx("span", { className: "text-foreground font-medium whitespace-nowrap", children: fmtRange(bucket) }), _jsxs("span", { className: "text-muted-foreground whitespace-nowrap", children: [bucket.total.toLocaleString(), " ", t('texte0ab721ade45', { count: bucket.total })] })] }), _jsx("div", { className: "border-border border-t" }), _jsx("dl", { className: "grid grid-cols-[1fr_auto] gap-x-4 gap-y-1 text-xs", children: stats.map(([label, value]) => (_jsxs(Fragment, { children: [_jsx("dt", { className: "text-muted-foreground", children: label }), _jsx("dd", { className: "text-foreground text-right", children: value })] }, label))) })] }));
+}
+/** One stat of the summary row: a 14 px value beside its 13 px muted label. */
+function Stat({ value, label, tone }) {
+    return (_jsxs("span", { className: "flex items-baseline gap-1.5", children: [_jsx("span", { className: cn('text-sm font-medium', tone ?? 'text-foreground'), children: value }), _jsx("span", { className: "text-muted-foreground text-xs", children: label })] }));
+}
+export function RunHistogram({ runs, live, onSelectRange, }) {
+    const t = useTranslations('hardcodedUi.i18nComplete');
+    const tLogs = useTranslations('gatewayLogs');
+    const buckets = useMemo(() => bucketRuns(runs, HISTOGRAM_BUCKETS), [runs]);
+    const failed = useMemo(() => buckets.reduce((n, b) => n + b.failed, 0), [buckets]);
+    const cost = useMemo(() => buckets.reduce((n, b) => n + b.cost, 0), [buckets]);
+    const median = useMemo(() => medianDuration(runs), [runs]);
+    if (buckets.length === 0)
+        return null;
+    const peak = Math.max(1, ...buckets.map((b) => b.total));
+    const tickAt = [0, 0.25, 0.5, 0.75].map((f) => Math.floor(f * (HISTOGRAM_BUCKETS - 1)));
+    const clock = (ms) => new Date(ms).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+    const credits = formatSessionCostCredits(cost);
+    // Paper C15 (`CBT-0`): the Models logs histogram, fed with runs.
+    return (_jsxs("section", { "aria-label": t.raw('textd2c58b300c07'), className: "bg-surface ring-border flex flex-col gap-2 rounded-lg px-4 pt-3.5 pb-2.5 ring-1", children: [_jsxs("div", { className: "flex flex-wrap items-baseline gap-x-5 gap-y-1 tabular-nums", children: [_jsx(Stat, { value: runs.length.toLocaleString(), label: t('texte0ab721ade45', { count: runs.length }) }), _jsx(Stat, { value: failed.toLocaleString(), label: t('text4001631320f1', { count: failed }), tone: failed > 0 ? 'text-destructive' : undefined }), median != null ? (_jsx(Stat, { value: fmtDuration(median), label: t.raw('textf1a06b0cb2ca') })) : null, _jsx(Stat, { value: credits, label: t('textd835122c9dd1', { count: Math.round(cost * 100) }) })] }), _jsx(HistogramBars, { className: "flex h-14 items-end gap-1.5", onSelect: (i) => onSelectRange({ start: buckets[i].start, end: buckets[i].end }), renderCard: (i) => _jsx(RunBucketCard, { bucket: buckets[i] }), bars: buckets.map((b) => ({
+                    key: b.start,
+                    ariaLabel: `${fmtRange(b)} · ${b.total} ${t('texte0ab721ade45', { count: b.total })}`,
+                    empty: b.total === 0,
+                    bar: (_jsx("span", { className: cn('flex w-full flex-col overflow-hidden rounded-xs transition-[background-color] duration-(--duration-normal)', b.total
+                            ? 'bg-muted-foreground/45 group-hover/bar:bg-foreground/70 group-focus-visible/bar:bg-foreground/70'
+                            : 'bg-muted group-hover/bar:bg-muted-foreground/45 group-focus-visible/bar:bg-muted-foreground/45'), style: { height: b.total ? `${Math.max(4, (b.total / peak) * 100)}%` : 2 }, children: b.failed > 0 ? (_jsx("span", { className: "bg-destructive w-full shrink-0", style: { height: `${Math.max(14, (b.failed / b.total) * 100)}%` } })) : null })),
+                })) }), _jsxs("div", { className: "text-muted-foreground flex justify-between text-xs tabular-nums", "aria-hidden": true, children: [tickAt.map((i) => (_jsx("span", { children: clock(buckets[i].start) }, i))), _jsx("span", { children: live ? tLogs('now') : clock(buckets[buckets.length - 1].end) })] })] }));
+}

package/dist/customize/triggers/schedule/trigger-runs-logic.d.ts

@@ -0,0 +1,49 @@
+import type { ProjectTriggerRun } from '@kortix/sdk';
+/** The one label a run shows: the fire outcome, refined by the agent turn's outcome once it fired. */
+export type RunState = 'queued' | 'running' | 'started' | 'succeeded' | 'failed' | 'rejected' | 'skipped';
+export declare function runState(run: Pick<ProjectTriggerRun, 'status' | 'run_status'>): RunState;
+/** Poll the run list every 5 s while any shown run is still in flight; otherwise not at all. */
+export declare const RUNS_POLL_MS = 5000;
+export declare function runsInFlight(runs: readonly Pick<ProjectTriggerRun, 'status' | 'run_status'>[]): boolean;
+/** Replay is offered on a failed or rejected fire whose payload was stored whole. */
+export declare function canReplay(run: Pick<ProjectTriggerRun, 'status' | 'run_status' | 'payload'>): boolean;
+/** The payload editor's text, as the object `fire` takes. */
+export declare function parsePayload(text: string): {
+    ok: true;
+    value: Record<string, unknown>;
+} | {
+    ok: false;
+    error: 'json' | 'object';
+};
+/** One histogram bar: a time slice of the loaded runs (the Models logs pattern). */
+export interface RunBucket {
+    /** Start of the slice, epoch ms. */
+    start: number;
+    /** End of the slice, epoch ms. The last slice includes its end. */
+    end: number;
+    total: number;
+    /** Runs whose agent turn finished, or that fired without a turn to wait on. */
+    succeeded: number;
+    /** Runs that read Failed or Rejected. */
+    failed: number;
+    medianMs: number | null;
+    /** Summed `cost_usd`. */
+    cost: number;
+}
+type BucketRun = Pick<ProjectTriggerRun, 'started_at' | 'status' | 'run_status' | 'duration_ms' | 'cost_usd'>;
+/**
+ * The loaded runs split into `count` equal time slices by `started_at`, from
+ * the oldest loaded run to the newest: `bucketLogStats` in `gateway-logs.tsx`,
+ * over runs. It describes the window on screen, not all history.
+ */
+export declare function bucketRuns(runs: readonly BucketRun[], count: number): RunBucket[];
+/** The median `duration_ms` of the runs that have one, or null. */
+export declare function medianDuration(runs: readonly Pick<ProjectTriggerRun, 'duration_ms'>[]): number | null;
+/** True when the run started inside the window (both ends inclusive). */
+export declare function inRunRange(run: Pick<ProjectTriggerRun, 'started_at'>, range: {
+    start: number;
+    end: number;
+} | null): boolean;
+/** The source a trigger's own runs come from; a row names any other one (manual, replay, reminder). */
+export declare function isDefaultSource(triggerType: 'cron' | 'webhook' | 'event' | 'monitor', source: ProjectTriggerRun['source']): boolean;
+export {};

package/dist/customize/triggers/schedule/trigger-runs-logic.js

@@ -0,0 +1,90 @@
+export function runState(run) {
+    if (run.status !== 'fired')
+        return run.status;
+    if (run.run_status === 'running')
+        return 'running';
+    if (run.run_status === 'succeeded')
+        return 'succeeded';
+    if (run.run_status === 'failed')
+        return 'failed';
+    return 'started';
+}
+/** Poll the run list every 5 s while any shown run is still in flight; otherwise not at all. */
+export const RUNS_POLL_MS = 5000;
+export function runsInFlight(runs) {
+    return runs.some((r) => r.status === 'queued' || r.status === 'running' || r.run_status === 'running');
+}
+/** Replay is offered on a failed or rejected fire whose payload was stored whole. */
+export function canReplay(run) {
+    const state = runState(run);
+    return (state === 'failed' || state === 'rejected') && run.payload?.truncated !== true;
+}
+/** The payload editor's text, as the object `fire` takes. */
+export function parsePayload(text) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        return { ok: false, error: 'json' };
+    }
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return { ok: false, error: 'object' };
+    }
+    return { ok: true, value: value };
+}
+/**
+ * The loaded runs split into `count` equal time slices by `started_at`, from
+ * the oldest loaded run to the newest: `bucketLogStats` in `gateway-logs.tsx`,
+ * over runs. It describes the window on screen, not all history.
+ */
+export function bucketRuns(runs, count) {
+    const at = (r) => Date.parse(r.started_at);
+    const timed = runs.filter((r) => Number.isFinite(at(r)));
+    if (timed.length === 0 || count < 1)
+        return [];
+    const times = timed.map(at);
+    const min = Math.min(...times);
+    const max = Math.max(...times);
+    const size = Math.max(1, max - min) / count;
+    const groups = Array.from({ length: count }, () => []);
+    for (const run of timed)
+        groups[Math.min(count - 1, Math.floor((at(run) - min) / size))].push(run);
+    return groups.map((group, i) => ({
+        start: min + i * size,
+        end: i === count - 1 ? max : min + (i + 1) * size,
+        total: group.length,
+        succeeded: group.filter((r) => {
+            const state = runState(r);
+            return state === 'succeeded' || state === 'started';
+        }).length,
+        failed: group.filter((r) => {
+            const state = runState(r);
+            return state === 'failed' || state === 'rejected';
+        }).length,
+        medianMs: medianDuration(group),
+        cost: group.reduce((n, r) => n + (r.cost_usd ?? 0), 0),
+    }));
+}
+/** The median `duration_ms` of the runs that have one, or null. */
+export function medianDuration(runs) {
+    const values = runs
+        .map((r) => r.duration_ms)
+        .filter((v) => v != null && Number.isFinite(v) && v >= 0)
+        .sort((a, b) => a - b);
+    if (values.length === 0)
+        return null;
+    const mid = Math.floor(values.length / 2);
+    return values.length % 2 ? values[mid] : (values[mid - 1] + values[mid]) / 2;
+}
+/** True when the run started inside the window (both ends inclusive). */
+export function inRunRange(run, range) {
+    if (!range)
+        return true;
+    const t = Date.parse(run.started_at);
+    return t >= range.start && t <= range.end;
+}
+/** The source a trigger's own runs come from; a row names any other one (manual, replay, reminder). */
+export function isDefaultSource(triggerType, source) {
+    return source === triggerType;
+}

package/dist/customize/triggers/schedule/trigger-runs-panel.d.ts

@@ -0,0 +1,32 @@
+import { type ProjectTrigger, type ProjectTriggerRun } from '@kortix/sdk';
+import { useTriggerRuns } from '@kortix/sdk/react';
+type RunsQuery = Pick<ReturnType<typeof useTriggerRuns>, 'data' | 'isLoading' | 'isError' | 'refetch' | 'fetchNextPage' | 'hasNextPage' | 'isFetchingNextPage'>;
+export declare function runsOf(query: Pick<RunsQuery, 'data'>): ProjectTriggerRun[];
+/** The polling interval for a run list, from the runs it shows now. */
+export declare function useRunsPoll(): {
+    refetchInterval: number | false;
+    observe(runs: ProjectTriggerRun[]): void;
+};
+export declare function TriggerRunsPanel({ projectId, trigger, canFire, onRun, running, }: {
+    projectId: string;
+    trigger: ProjectTrigger;
+    canFire: boolean;
+    /** The sheet's Run now, offered by the empty state. */
+    onRun?: () => void;
+    running?: boolean;
+}): import("react").JSX.Element;
+export declare function RunRow({ projectId, trigger, run, newDay, replay, initialOpen, }: {
+    projectId: string;
+    trigger: ProjectTrigger;
+    run: ProjectTriggerRun;
+    /** The first row of its day: the day divider sits above it. */
+    newDay: boolean;
+    replay: {
+        pending: boolean;
+        disabled: boolean;
+        onReplay: () => void;
+    } | null;
+    /** Start expanded (a deep link to one run, and the render tests). */
+    initialOpen?: boolean;
+}): import("react").JSX.Element;
+export {};