@kortix/ui 0.14.3 → 0.14.5

package/dist/customize/triggers/schedule/event-trigger-fields.js

@@ -0,0 +1,47 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * The App event pieces of the trigger form: list an app's events, fill the
+ * chosen event's config, and write the prompt with the event's fields as
+ * clickable variables. Each piece is a controlled component so the composer
+ * and the detail sheet share them.
+ */
+import Hint from '../../../primitives/hint.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 { Textarea } from '../../../primitives/textarea.js';
+import { useTranslations as useI18nTranslations } from '../../../i18n/index.js';
+import { humanizeEventType, payloadVariables, } from './event-trigger-copy.js';
+/* ─── Event ─────────────────────────────────────────────────────────────── */
+export function matchesEventQuery(eventType, query) {
+    const q = query.trim().toLowerCase();
+    if (!q)
+        return true;
+    return [eventType.name, eventType.description, humanizeEventType(eventType.type)].some((field) => field.toLowerCase().includes(q));
+}
+/* ─── Config form ───────────────────────────────────────────────────────── */
+/** A form generated from an event's `config_schema`. Renders nothing for an empty schema. */
+export function EventConfigForm({ fields, draft, onChange, disabled, errors, }) {
+    const tI18nComplete = useI18nTranslations('hardcodedUi.i18nComplete');
+    const set = (key, value) => onChange({ ...draft, [key]: value });
+    return (_jsx("div", { className: "space-y-4", children: fields.map((field) => {
+            const id = `event-config-${field.key}`;
+            const value = draft[field.key] ?? '';
+            const error = errors?.[field.key];
+            return (_jsxs("div", { className: "space-y-1.5", children: [field.kind === 'boolean' ? (_jsxs("div", { className: "bg-card flex items-center justify-between gap-3 rounded-md border px-3 py-2.5", children: [_jsx(Label, { htmlFor: id, className: "text-sm font-normal", children: field.label }), _jsx(Switch, { id: id, checked: value === 'true', disabled: disabled, onCheckedChange: (checked) => set(field.key, String(checked)) })] })) : (_jsxs(_Fragment, { children: [_jsxs(Label, { htmlFor: id, className: "text-sm font-medium", children: [field.label, field.required ? (_jsxs("span", { className: "text-muted-foreground font-normal", children: [' ', tI18nComplete.raw('text89db19f651b1')] })) : null] }), field.kind === 'enum' ? (_jsxs(Select, { value: value, onValueChange: (v) => set(field.key, v), disabled: disabled, children: [_jsx(SelectTrigger, { id: id, "aria-invalid": error ? true : undefined, className: "w-full cursor-pointer text-sm", children: _jsx(SelectValue, { placeholder: tI18nComplete.raw('text0b24aed53ab6') }) }), _jsx(SelectContent, { children: field.options.map((option) => (_jsx(SelectItem, { value: option, className: "cursor-pointer", children: option }, option))) })] })) : field.kind === 'list' ? (_jsx(Textarea, { id: id, value: value, rows: 3, disabled: disabled, placeholder: field.example
+                                    ? tI18nComplete('text5914bebd5241', { example: field.example })
+                                    : tI18nComplete.raw('text791210221e4a'), "aria-invalid": error ? true : undefined, onChange: (e) => set(field.key, e.target.value) })) : (_jsx(Input, { id: id, value: value, disabled: disabled, inputMode: field.kind === 'string' ? undefined : 'decimal', placeholder: field.example ?? undefined, "aria-invalid": error ? true : undefined, onChange: (e) => set(field.key, e.target.value) }))] })), field.description ? (_jsx("p", { className: "text-muted-foreground text-xs leading-relaxed text-pretty", children: field.description })) : null, error ? (_jsx("p", { role: "alert", className: "text-destructive text-xs", children: error })) : null] }, field.key));
+        }) }));
+}
+/* ─── Prompt variables ──────────────────────────────────────────────────── */
+/** One chip per field of `event.data`, showing the field's name; a click hands the full `{{ event.data.<field> }}` token to `onInsert`. */
+export function PromptVariableHints({ payloadSchema, onInsert, }) {
+    const tI18nComplete = useI18nTranslations('hardcodedUi.i18nComplete');
+    const variables = payloadVariables(payloadSchema);
+    return (_jsxs("div", { className: "space-y-1.5", children: [_jsx("p", { className: "text-muted-foreground text-xs leading-relaxed text-pretty", children: tI18nComplete.rich(variables.length > 0 ? 'text126ba406a50a' : 'text25a3107603e6', {
+                    token: '{{ event.data }}',
+                    code: (chunks) => _jsx("code", { className: "font-mono", children: chunks }),
+                }) }), variables.length > 0 ? (_jsx("div", { className: "flex flex-wrap gap-1", children: variables.map((variable) => (_jsx(Hint, { label: variable.description ?? variable.token, side: "top", children: _jsx("button", { type: "button", "aria-label": variable.token, onClick: () => onInsert(variable.token), className: "bg-muted text-muted-foreground hover:text-foreground hover:bg-accent duration-fast cursor-pointer rounded-sm px-1.5 py-0.5 text-xs transition-colors", children: variable.field }) }, variable.field))) })) : null] }));
+}

package/dist/customize/triggers/schedule/schedule-builder.d.ts

@@ -0,0 +1,25 @@
+import { type ReactNode } from 'react';
+type Frequency = 'minutes' | 'hourly' | 'daily' | 'weekly' | 'monthly';
+interface ScheduleState {
+    frequency: Frequency;
+    interval: number;
+    hour: number;
+    minute: number;
+    weekdays: number[];
+    monthDay: number;
+}
+interface ScheduleBuilderProps {
+    value: string;
+    onChange: (cronExpr: string) => void;
+    disabled?: boolean;
+    allowOnce?: boolean;
+    runAt?: string | null;
+    onRunAtChange?: (iso: string | null) => void;
+    /** A last field for the repeating row, e.g. the host's timezone select. */
+    trailing?: ReactNode;
+}
+declare function stateToCron(state: ScheduleState): string;
+declare function cronToState(expression: string): ScheduleState | null;
+declare function describeSchedule(state: ScheduleState): string;
+export declare function ScheduleBuilder({ value, onChange, disabled, allowOnce, runAt, onRunAtChange, trailing, }: ScheduleBuilderProps): import("react").JSX.Element;
+export { cronToState, describeSchedule, stateToCron, type ScheduleState };

package/dist/customize/triggers/schedule/schedule-builder.js

@@ -0,0 +1,284 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { CalendarDotsIcon as CalendarClock, CaretDownIcon as ChevronDown } from '@phosphor-icons/react';
+import { useTranslations } from '../../../i18n/index.js';
+import { useCallback, useEffect, useState } from 'react';
+import { Button } from '../../../primitives/button.js';
+import { Input } from '../../../primitives/input.js';
+import { Label } from '../../../primitives/label.js';
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue, } from '../../../primitives/select.js';
+import { errorToast, warningToast } from '../../../primitives/toast.js';
+import { APP_REGISTRY_TRANSLATION_KEYS } from '../../../i18n/ui-catalog/app-registry-translation-keys.generated.js';
+import { localizeUiCatalog } from '../../../i18n/ui-catalog/localize-ui-catalog.js';
+import { cn } from '../../../internal/lib/utils.js';
+const DEFAULT_STATE = {
+    frequency: 'daily',
+    interval: 15,
+    hour: 9,
+    minute: 0,
+    weekdays: [1, 2, 3, 4, 5],
+    monthDay: 1,
+};
+const WEEKDAY_BUTTONS = [
+    { value: 1, label: 'Mo' },
+    { value: 2, label: 'Tu' },
+    { value: 3, label: 'We' },
+    { value: 4, label: 'Th' },
+    { value: 5, label: 'Fr' },
+    { value: 6, label: 'Sa' },
+    { value: 0, label: 'Su' },
+];
+const HOURS = Array.from({ length: 24 }, (_, index) => index);
+const MINUTE_OPTIONS = [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55];
+const CADENCES = [
+    { value: 'minutes', label: 'Every few minutes' },
+    { value: 'hourly', label: 'Every few hours' },
+    { value: 'daily', label: 'Every day' },
+    { value: 'weekdays', label: 'Weekdays' },
+    { value: 'weekends', label: 'Weekends' },
+    { value: 'weekly', label: 'Custom days' },
+    { value: 'monthly', label: 'Every month' },
+];
+function stateToCron(state) {
+    switch (state.frequency) {
+        case 'minutes':
+            return `0 */${state.interval} * * * *`;
+        case 'hourly':
+            return `0 ${state.minute} */${state.interval} * * *`;
+        case 'daily':
+            return `0 ${state.minute} ${state.hour} * * *`;
+        case 'weekly':
+            return `0 ${state.minute} ${state.hour} * * ${[...state.weekdays].sort().join(',')}`;
+        case 'monthly':
+            return `0 ${state.minute} ${state.hour} ${state.monthDay} * *`;
+    }
+}
+function cronToState(expression) {
+    try {
+        const parts = expression.trim().split(/\s+/);
+        if (parts.length !== 6)
+            return null;
+        const [, minute, hour, day, , weekday] = parts;
+        if (minute.startsWith('*/') && hour === '*' && day === '*' && weekday === '*') {
+            return {
+                ...DEFAULT_STATE,
+                frequency: 'minutes',
+                interval: Number.parseInt(minute.slice(2), 10) || 15,
+            };
+        }
+        if (hour.startsWith('*/') && day === '*' && weekday === '*') {
+            return {
+                ...DEFAULT_STATE,
+                frequency: 'hourly',
+                interval: Number.parseInt(hour.slice(2), 10) || 1,
+                minute: Number.parseInt(minute, 10) || 0,
+            };
+        }
+        if (day !== '*' && !day.includes('/') && weekday === '*') {
+            return {
+                ...DEFAULT_STATE,
+                frequency: 'monthly',
+                hour: Number.parseInt(hour, 10) || 9,
+                minute: Number.parseInt(minute, 10) || 0,
+                monthDay: Number.parseInt(day, 10) || 1,
+            };
+        }
+        if (day === '*' && weekday !== '*') {
+            const weekdays = weekday.includes('-')
+                ? Array.from({ length: Number(weekday.split('-')[1]) - Number(weekday.split('-')[0]) + 1 }, (_, index) => Number(weekday.split('-')[0]) + index)
+                : weekday.split(',').map(Number).filter(Number.isFinite);
+            if (weekdays.length === 0)
+                return null;
+            return {
+                ...DEFAULT_STATE,
+                frequency: 'weekly',
+                hour: Number.parseInt(hour, 10) || 9,
+                minute: Number.parseInt(minute, 10) || 0,
+                weekdays,
+            };
+        }
+        if (day === '*' && weekday === '*' && !hour.includes('*') && !hour.includes('/')) {
+            return {
+                ...DEFAULT_STATE,
+                frequency: 'daily',
+                hour: Number.parseInt(hour, 10) || 9,
+                minute: Number.parseInt(minute, 10) || 0,
+            };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function ordinal(value) {
+    if (value >= 11 && value <= 13)
+        return 'th';
+    return value % 10 === 1 ? 'st' : value % 10 === 2 ? 'nd' : value % 10 === 3 ? 'rd' : 'th';
+}
+function describeSchedule(state) {
+    const time = `${String(state.hour).padStart(2, '0')}:${String(state.minute).padStart(2, '0')}`;
+    const names = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+    switch (state.frequency) {
+        case 'minutes':
+            return `Runs every ${state.interval} minute${state.interval === 1 ? '' : 's'}`;
+        case 'hourly':
+            return state.interval === 1
+                ? `Runs every hour at :${String(state.minute).padStart(2, '0')}`
+                : `Runs every ${state.interval} hours at :${String(state.minute).padStart(2, '0')}`;
+        case 'daily':
+            return `Runs every day at ${time}`;
+        case 'weekly': {
+            const sorted = [...state.weekdays].sort();
+            if (sorted.join(',') === '1,2,3,4,5')
+                return `Runs weekdays at ${time}`;
+            if (sorted.join(',') === '0,6')
+                return `Runs weekends at ${time}`;
+            if (sorted.length === 7)
+                return `Runs every day at ${time}`;
+            return `Runs ${sorted.map((day) => names[day]).join(', ')} at ${time}`;
+        }
+        case 'monthly':
+            return `Runs on the ${state.monthDay}${ordinal(state.monthDay)} of each month at ${time}`;
+    }
+}
+function pad2(value) {
+    return String(value).padStart(2, '0');
+}
+function isoToLocalInput(iso) {
+    const date = new Date(iso);
+    if (Number.isNaN(date.getTime()))
+        return '';
+    return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}T${pad2(date.getHours())}:${pad2(date.getMinutes())}`;
+}
+function localInputToIso(value) {
+    if (!value)
+        return null;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+function defaultRunAtIso() {
+    const date = new Date();
+    date.setHours(date.getHours() + 1, 0, 0, 0);
+    return date.toISOString();
+}
+function describeRunAt(iso, tI18nComplete) {
+    const date = new Date(iso);
+    if (Number.isNaN(date.getTime()))
+        return tI18nComplete.raw('text3b4153c0d3c8');
+    const formatted = date.toLocaleString(undefined, {
+        weekday: 'short',
+        month: 'short',
+        day: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit',
+    });
+    return date.getTime() <= Date.now() ? `${formatted} is in the past` : `Runs once on ${formatted}`;
+}
+function cadenceFor(state) {
+    if (state.frequency !== 'weekly')
+        return state.frequency;
+    const weekdays = [...state.weekdays].sort().join(',');
+    if (weekdays === '1,2,3,4,5')
+        return 'weekdays';
+    if (weekdays === '0,6')
+        return 'weekends';
+    return 'weekly';
+}
+export function ScheduleBuilder({ value, onChange, disabled, allowOnce, runAt, onRunAtChange, trailing, }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const tTrigger = useTranslations('triggerComposer');
+    const [state, setState] = useState(() => cronToState(value) ?? DEFAULT_STATE);
+    const [showCron, setShowCron] = useState(() => cronToState(value) === null);
+    const [rawCron, setRawCron] = useState(value);
+    const [cronError, setCronError] = useState(null);
+    const onceMode = Boolean(allowOnce && onRunAtChange && runAt != null);
+    const isCustom = cronToState(rawCron) === null;
+    const hasPastRunAt = Boolean(runAt && new Date(runAt).getTime() <= Date.now());
+    useEffect(() => {
+        const parsed = cronToState(value);
+        if (parsed)
+            setState(parsed);
+        setRawCron(value);
+        setShowCron((visible) => visible || !parsed);
+    }, [value]);
+    const update = useCallback((partial) => {
+        const next = { ...state, ...partial };
+        setState(next);
+        const cron = stateToCron(next);
+        setRawCron(cron);
+        setCronError(null);
+        onChange(cron);
+    }, [onChange, state]);
+    const selectCadence = (cadence) => {
+        const presets = {
+            minutes: { frequency: 'minutes' },
+            hourly: { frequency: 'hourly' },
+            daily: { frequency: 'daily' },
+            weekdays: { frequency: 'weekly', weekdays: [1, 2, 3, 4, 5] },
+            weekends: { frequency: 'weekly', weekdays: [0, 6] },
+            weekly: { frequency: 'weekly' },
+            monthly: { frequency: 'monthly' },
+        };
+        onRunAtChange?.(null);
+        update(presets[cadence]);
+    };
+    const selectOnce = () => onRunAtChange?.(runAt ?? defaultRunAtIso());
+    const toggleWeekday = (day) => {
+        const weekdays = state.weekdays.includes(day)
+            ? state.weekdays.filter((value) => value !== day)
+            : [...state.weekdays, day];
+        if (weekdays.length === 0) {
+            warningToast(tI18nComplete.raw('text82457b59d590'));
+            return;
+        }
+        update({ weekdays });
+    };
+    const onRawCronEdit = (expression) => {
+        setRawCron(expression);
+        const parsed = cronToState(expression);
+        if (parsed) {
+            setState(parsed);
+            setCronError(null);
+        }
+        onChange(expression);
+    };
+    const validateRawCron = () => {
+        if (!isCustom) {
+            setCronError(null);
+            return;
+        }
+        const message = 'Use a supported six-field cron expression.';
+        setCronError(message);
+        errorToast(tI18nComplete.raw('text641c87998713'), { description: message });
+    };
+    const cadence = cadenceFor(state);
+    const canOnce = Boolean(allowOnce && onRunAtChange);
+    const cadences = localizeUiCatalog(CADENCES, tI18nComplete, APP_REGISTRY_TRANSLATION_KEYS);
+    const weekdayButtons = localizeUiCatalog(WEEKDAY_BUTTONS, tI18nComplete, APP_REGISTRY_TRANSLATION_KEYS);
+    const intervalUnit = (value) => state.frequency === 'minutes' ? 'minutes' : `hour${value === 1 ? '' : 's'}`;
+    return (_jsxs("div", { className: cn('space-y-3', disabled && 'pointer-events-none opacity-60 select-none'), children: [_jsxs("div", { className: "flex flex-wrap items-end gap-3", children: [_jsx(ScheduleField, { label: tI18nComplete.raw('textb6b7a0065808'), className: "w-full sm:w-44", children: _jsxs(Select, { value: onceMode ? 'once' : cadence, onValueChange: (next) => next === 'once' ? selectOnce() : selectCadence(next), disabled: disabled, children: [_jsx(SelectTrigger, { className: "h-9 w-full", children: _jsx(SelectValue, {}) }), _jsxs(SelectContent, { children: [cadences.map((option) => (_jsx(SelectItem, { value: option.value, children: option.label }, option.value))), canOnce ? (_jsx(SelectItem, { value: "once", children: tI18nComplete.raw('textd88f6d8372f4') })) : null] })] }) }), onceMode ? (_jsx(ScheduleField, { label: tI18nComplete.raw('text4b4c31294fb5'), className: "w-full sm:w-auto", children: _jsx(Input, { type: "datetime-local", value: runAt ? isoToLocalInput(runAt) : '', min: isoToLocalInput(new Date().toISOString()), onChange: (event) => onRunAtChange?.(localInputToIso(event.target.value)), onBlur: () => {
+                                if (hasPastRunAt)
+                                    warningToast(tI18nComplete.raw('textabf586cc6ecb'));
+                            }, "aria-invalid": hasPastRunAt, className: "h-9 w-full sm:w-auto", disabled: disabled }) })) : (_jsxs(_Fragment, { children: [(state.frequency === 'minutes' || state.frequency === 'hourly') && (_jsx(ScheduleField, { label: tTrigger('every'), className: "w-32", children: _jsxs(Select, { value: String(state.interval), onValueChange: (value) => update({ interval: Number(value) }), disabled: disabled, children: [_jsx(SelectTrigger, { className: "h-9 w-full", children: _jsx(SelectValue, {}) }), _jsx(SelectContent, { children: (state.frequency === 'minutes'
+                                                ? [1, 2, 3, 5, 10, 15, 20, 30, 45]
+                                                : [1, 2, 3, 4, 6, 8, 12]).map((value) => (_jsxs(SelectItem, { value: String(value), children: [value, " ", intervalUnit(value)] }, value))) })] }) })), state.frequency === 'monthly' && (_jsx(ScheduleField, { label: tTrigger('dayOfMonth'), className: "w-28", children: _jsxs(Select, { value: String(state.monthDay), onValueChange: (value) => update({ monthDay: Number(value) }), disabled: disabled, children: [_jsx(SelectTrigger, { className: "h-9 w-full", children: _jsx(SelectValue, {}) }), _jsx(SelectContent, { children: Array.from({ length: 31 }, (_, index) => index + 1).map((value) => (_jsx(SelectItem, { value: String(value), children: value }, value))) })] }) })), state.frequency !== 'minutes' && (_jsx(ScheduleField, { label: state.frequency === 'hourly'
+                                    ? tI18nComplete.raw('text5f2ed72dfcbc')
+                                    : tI18nComplete.raw('text33b93476cf59'), children: _jsxs("div", { className: "flex items-center gap-1.5", children: [state.frequency !== 'hourly' && (_jsxs(_Fragment, { children: [_jsxs(Select, { value: String(state.hour), onValueChange: (value) => update({ hour: Number(value) }), disabled: disabled, children: [_jsx(SelectTrigger, { className: "h-9 w-18 tabular-nums", children: _jsx(SelectValue, {}) }), _jsx(SelectContent, { children: HOURS.map((value) => (_jsx(SelectItem, { value: String(value), children: pad2(value) }, value))) })] }), _jsx("span", { className: "text-muted-foreground", children: ":" })] })), _jsxs(Select, { value: String(state.minute), onValueChange: (value) => update({ minute: Number(value) }), disabled: disabled, children: [_jsx(SelectTrigger, { className: "h-9 w-18 tabular-nums", children: _jsx(SelectValue, {}) }), _jsx(SelectContent, { children: MINUTE_OPTIONS.map((value) => (_jsx(SelectItem, { value: String(value), children: state.frequency === 'hourly' ? `:${pad2(value)}` : pad2(value) }, value))) })] })] }) })), trailing] }))] }), !onceMode && cadence === 'weekly' && (_jsx("div", { className: "flex flex-wrap gap-1.5", "aria-label": tI18nComplete.raw('text2069f4549744'), children: weekdayButtons.map(({ value, label }) => {
+                    const selected = state.weekdays.includes(value);
+                    return (_jsx(Button, { type: "button", variant: selected ? 'secondary' : 'outline', size: "sm", "aria-pressed": selected, onClick: () => toggleWeekday(value), disabled: disabled, className: "min-w-10 transition-transform active:scale-[0.96]", children: label }, value));
+                }) })), onceMode && runAt && hasPastRunAt ? (_jsx(SchedulePreview, { text: describeRunAt(runAt, tI18nComplete), error: true })) : null, !onceMode && isCustom ? (_jsx(SchedulePreview, { text: tI18nComplete.raw('text7afd348d0d4b') })) : null, !onceMode && (_jsxs("div", { className: "space-y-2", children: [_jsxs(Button, { type: "button", variant: "text", size: "xs", onClick: () => setShowCron((visible) => !visible), disabled: disabled, className: "text-muted-foreground hover:text-foreground -ml-1 transition-transform active:scale-[0.96]", children: [_jsx(ChevronDown, { className: cn('size-3 transition-transform duration-(--duration-normal)', showCron && 'rotate-180') }), showCron
+                                ? tI18nComplete.raw('text6c848b936d1d')
+                                : tI18nComplete.raw('text1fa1b04791a4')] }), showCron && (_jsxs("div", { className: "space-y-1.5", children: [_jsx(Label, { className: "text-xs", htmlFor: "schedule-cron-expression", children: tI18nComplete.raw('text4ab444f5a66a') }), _jsx(Input, { id: "schedule-cron-expression", type: "text", value: rawCron, onChange: (event) => onRawCronEdit(event.target.value), onBlur: validateRawCron, "aria-invalid": Boolean(cronError), className: "h-9 font-mono text-sm", placeholder: "0 0 9 * * *", disabled: disabled }), _jsx("p", { className: cn('text-muted-foreground text-xs', cronError && 'text-destructive'), children: cronError ??
+                                    (isCustom
+                                        ? tI18nComplete.raw('textef7f45ff7f0a')
+                                        : tI18nComplete.raw('textcc0c25063f43')) })] }))] }))] }));
+}
+/** One stacked field of the schedule row: a small label over its control. */
+function ScheduleField({ label, className, children, }) {
+    return (_jsxs("div", { className: cn('space-y-1.5', className), children: [_jsx(Label, { className: "text-xs first-letter:uppercase", children: label }), children] }));
+}
+function SchedulePreview({ text, error = false }) {
+    return (_jsxs("p", { className: cn('text-muted-foreground flex items-center gap-2 text-xs tabular-nums', error && 'text-destructive'), children: [_jsx(CalendarClock, { className: "size-3.5 shrink-0" }), text] }));
+}
+export { cronToState, describeSchedule, stateToCron };

package/dist/customize/triggers/schedule/schedule-copy.d.ts

@@ -0,0 +1,139 @@
+import type { UiTranslator } from '../../../i18n/index.js';
+/**
+ * Plain-language copy for schedules and webhooks.
+ *
+ * Everything a person reads on the Schedules and Webhooks screens is built
+ * here, so the two screens can never drift and so the wording can be tested
+ * without rendering anything. The rule: **the UI never shows the wire word.**
+ * A cron expression reads as "Every day at 09:00", `session_mode: 'keyed'`
+ * reads as "One session per conversation", and `secret_env` reads as "Signed".
+ *
+ * Where a value genuinely has no plain equivalent — a hand-written cron
+ * expression, the trigger id, the file it is saved in — the plain summary
+ * wins in the list and the exact value stays available under Advanced or
+ * Details. Hiding it entirely would be dishonest; leading with it is what
+ * made these screens read as a config file.
+ */
+import type { ProjectTrigger } from '@kortix/sdk';
+export type TriggerKind = 'cron' | 'webhook' | 'event';
+/**
+ * `ProjectTrigger['type']` on the wire also carries `'monitor'` — a separate
+ * experimental feature (Monitors) with its own surface, not something this
+ * screen edits. `ScheduleView` filters every list through this before it
+ * reaches the table, the row actions, or the detail sheet, so `trigger.type`
+ * is safe to treat as {@link TriggerKind} anywhere downstream of that filter.
+ */
+export declare function isTriggerKind(type: ProjectTrigger['type']): type is TriggerKind;
+/**
+ * Triggers the customer wrote. The starter ships every new project a
+ * `harness-reflector` cron that keeps the project's memory current; it is
+ * infrastructure, not something the customer configured, so the Triggers page
+ * must not show it (KRTX-1299). `agent` matches the shipped template exactly;
+ * `slug` covers a renamed trigger on the same agent.
+ */
+export declare function isCustomerTrigger(trigger: ProjectTrigger): boolean;
+/** Shown when an expression is valid cron but has no plain-English shape. */
+export declare const CUSTOM_TIMING_LABEL = "Custom timing";
+/**
+ * A 6-field cron expression as a sentence a person can check at a glance.
+ * Covers every shape the schedule picker can produce, plus the common
+ * hand-written ones. Anything else falls back to {@link CUSTOM_TIMING_LABEL} —
+ * the raw expression is still shown under Advanced, never in the list.
+ */
+export declare function describeCadence(expression: string): string;
+/** A one-off run as a date a person can read. */
+export declare function describeOneOff(iso: string): string;
+/**
+ * The one line that answers "when does this run?" — the same sentence in the
+ * list, the detail panel, and the delete confirmation.
+ */
+export declare function describeWhen(trigger: ProjectTrigger, eventNames?: ReadonlyMap<string, string>): string;
+/** Exact cron occurrence and actual scheduled execution, explicitly in UTC. */
+export declare function describeNextRun(trigger: ProjectTrigger): string | null;
+/** Never blank: falls back to what the automation does, then to its kind. */
+export declare function triggerName(trigger: ProjectTrigger): string;
+export type TriggerStatus = {
+    label: 'Active' | 'Paused';
+    active: boolean;
+};
+export declare function triggerStatus(enabled: boolean, tI18nComplete: UiTranslator): TriggerStatus;
+/**
+ * The one status a trigger shows on every surface: the list, the sheet header
+ * and the connector tab. Paused outranks the rest (a paused trigger holds no
+ * subscription), then the subscription's own state, then a failed last run.
+ */
+export type TriggerBadgeState = 'live' | 'needs_connection' | 'error' | 'pending' | 'paused';
+export declare function triggerBadgeState(trigger: ProjectTrigger): TriggerBadgeState;
+/**
+ * "Never", "Just now", "12 minutes ago", "3 hours ago", "5 days ago", then an
+ * absolute date. `now` is a parameter so this is testable without faking time.
+ */
+export declare function describeLastRun(iso: string | null | undefined, now?: number): string;
+export type SessionMode = ProjectTrigger['session_mode'];
+export declare const SESSION_MODES: readonly SessionMode[];
+/** The wire calls the last one "keyed". Nobody setting up a webhook does. */
+export declare const SESSION_MODE_LABEL: Record<SessionMode, string>;
+export declare const SESSION_MODE_HELP: Record<SessionMode, string>;
+/** One-line summary for read-only views and the list. */
+export declare function describeRunLocation(trigger: ProjectTrigger): string;
+export type SecurityState = {
+    label: 'Signed' | 'Not signed';
+    signed: boolean;
+    /** Sentence for the detail panel. */
+    detail: string;
+};
+export declare function describeSecurity(trigger: ProjectTrigger, tI18nComplete: UiTranslator): SecurityState;
+/** "Runs on every request" / "Runs when 2 things match". */
+export declare function describeConditions(filter: Record<string, string> | null | undefined): string;
+/**
+ * Per-kind wording for the Schedules and Webhooks screens, heading included.
+ *
+ * The heading lived in `packages/ui/src/customize/settings/rail.ts` for as long as
+ * these were two tabs of the Settings overlay — every pane in that overlay
+ * takes its title and description from its rail entry, and being the one
+ * exception is what let the copy drift before. They are capability PAGES now
+ * (`/projects/<id>/schedules`, `/projects/<id>/webhooks`), not panes, so they
+ * have no rail entry to read: a rail lookup that finds nothing renders no
+ * heading and throws nothing, which is exactly the silent failure to avoid.
+ * The copy is the wording those rail entries carried, moved verbatim.
+ */
+export interface KindCopy {
+    /** Page heading. */
+    title: string;
+    /** One sentence under the heading. */
+    description: string;
+    /** Singular noun, lowercase, for inline sentences. */
+    noun: string;
+    createLabel: string;
+    searchPlaceholder: string;
+    emptyTitle: string;
+    emptyBody: string;
+    /** Header for the type-specific list column. */
+    column: string;
+}
+export declare const KIND_COPY: Record<TriggerKind, KindCopy>;
+/**
+ * The unified Triggers screen's own copy — the page that replaced the two
+ * Schedules/Webhooks capability pages. A trigger is one thing with two ways
+ * to start it, so the page speaks about "triggers" in general and leans on
+ * each row's own type (via {@link KIND_COPY}) for anything kind-specific.
+ */
+export declare const TRIGGERS_COPY: {
+    readonly title: "Triggers";
+    readonly description: "Run agents on a schedule, an app event, or a webhook.";
+    readonly noun: "trigger";
+    readonly createLabel: "New trigger";
+    readonly searchPlaceholder: "Search triggers";
+    readonly emptyTitle: "No triggers yet";
+    readonly emptyBody: "Create a trigger and your agent runs on its own, no prompt needed.";
+};
+export declare function localizedKindCopy(tI18nComplete: UiTranslator): Record<TriggerKind, KindCopy>;
+export declare function localizedTriggersCopy(tI18nComplete: UiTranslator): typeof TRIGGERS_COPY;
+/** Matches what a person can see in the list, not the wire fields. */
+export declare function matchesQuery(trigger: ProjectTrigger, query: string, tI18nComplete: UiTranslator): boolean;
+/**
+ * The line under (or beside) a trigger's name: its schedule, unless that is
+ * the name itself (a trigger named after its schedule); then the first line
+ * of its prompt; null when there is neither, so the name stands alone.
+ */
+export declare function triggerSubtitle(name: string, when: string, prompt: string | null | undefined): string | null;