@deepseek-ai/dsh-client-ui-schedule 0.1.7-alpha.2 → 0.1.7-rc.2

package/lib/types/client/schedule-format.d.ts

@@ -0,0 +1,177 @@
+/** Browser-safe formatting shared by Session and Host reminder catalogs. */
+import type { Translate } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ScheduleRecord } from '@deepseek-ai/dsh-schedule/client';
+import type { CronDescriptionKey } from './task-cron.ts';
+type TimeUnit = 'day' | 'hour' | 'minute' | 'second';
+type UnitKey = `unit.${TimeUnit}.${'one' | 'other'}`;
+type WeekdayKey = `frequency.weekday.${1 | 2 | 3 | 4 | 5 | 6 | 7}`;
+/** Dictionary keys required to display exact reminder frequencies. */
+export type FrequencyKey = 'time.locale' | 'time.utcPrefix' | 'frequency.once' | 'frequency.every' | 'frequency.daily' | 'frequency.dailyLocal' | 'frequency.weekly' | 'frequency.weeklyLocal' | 'frequency.cron' | 'frequency.cronLocal' | 'frequency.cronRule' | 'frequency.weekday.join' | WeekdayKey | UnitKey | CronDescriptionKey;
+/** Namespace-independent translator for reminder frequencies and time units. */
+export type FrequencyTranslator = Translate<FrequencyKey>;
+/** Dictionary keys required to localize a zone and mark the host's zone. */
+export type ZoneLabelKey = 'time.locale' | 'time.utcPrefix' | 'rule.zone.system';
+type ZoneLocaleKey = Extract<ZoneLabelKey, 'time.locale' | 'time.utcPrefix'>;
+/** Universal fallback when a runtime cannot enumerate its ICU time-zone data. */
+export declare const FALLBACK_ZONES: readonly ["UTC"];
+/** Host-zone context a frequency line uses to omit or name a rule's stored zone. */
+export interface FrequencyZone {
+    /** Host's current IANA zone; a rule storing this zone shows no zone. */
+    readonly system: string;
+    /** ICU-localized name and offset of one zone. */
+    readonly label: (zone: string) => string;
+}
+/** Dictionary keys required to display relative reminder targets. */
+export type RelativeTimeKey = UnitKey | 'relative.now' | 'relative.future' | 'relative.overdue';
+/**
+ * Name one task from its stored title.
+ *
+ * Every decoded Host record and catalog entry carries a title that is non-empty
+ * after trimming, so no name is derived from the instruction here. The
+ * `schedule_create` card derives one only for a result read from a Session log
+ * written before the stored field existed.
+ * @param record - task being named.
+ * @returns the stored title.
+ */
+export declare function taskName(record: ScheduleRecord): string;
+/**
+ * Render the stored ISO weekday set with localized names joined in locale order.
+ * @param weekdays - Stored unique ascending ISO weekdays.
+ * @param t - frequency, join, and unit translations.
+ * @returns Localized weekday list, for example `Mon, Wed`.
+ */
+export declare function formatWeekdays(weekdays: readonly number[], t: FrequencyTranslator): string;
+/**
+ * Localize one IANA zone through the runtime's ICU/CLDR data, prefixed by its
+ * current UTC offset. The raw IANA id remains internal unless ICU cannot name
+ * a valid stored alias.
+ * @param zone - IANA zone to label.
+ * @param t - translate providing the active ICU locale.
+ * @param at - instant used to resolve the current UTC offset and zone name.
+ * @returns the UTC offset and localized zone name.
+ */
+export declare function zoneLabel(zone: string, t: Translate<ZoneLocaleKey>, at?: number): string;
+/**
+ * Name one zone and mark it when it is the host's own zone.
+ * @param zone - IANA zone to name.
+ * @param system - the host's current IANA zone.
+ * @param t - translate providing the active ICU locale and system suffix.
+ * @param at - instant used to resolve the current UTC offset and zone name.
+ * @returns UTC offset and localized zone name, with the system suffix when applicable.
+ */
+export declare function zoneName(zone: string, system: string, t: Translate<ZoneLabelKey>, at?: number): string;
+/**
+ * Zones the time-zone menu offers, in menu order: the host's current zone,
+ * followed by the runtime's IANA inventory ordered by current UTC offset and
+ * canonical id, including a stored alias the inventory omits.
+ *
+ * `Intl.supportedValuesOf('timeZone')` supplies the inventory, so an engine
+ * that can enumerate zones offers all of them. When enumeration is unavailable,
+ * the menu falls back to the host zone, UTC, and any stored zone, so it is never
+ * empty. A stored zone outside the inventory is appended,
+ * so an accepted alias never disappears from the menu.
+ * @param stored - zone the shown rule stores.
+ * @param system - the host's current IANA zone.
+ * @param at - instant used to order zones by their current UTC offset.
+ * @returns IANA zones in menu order, de-duplicated.
+ */
+export declare function zoneChoices(stored: string, system: string, at?: number): readonly string[];
+/**
+ * IANA zone a record's stored wall-clock rule interprets its time in.
+ *
+ * Daily, weekly, and cron records store an explicit zone. One-shot `at` and
+ * `after` records, and fixed-interval `every` records, store only the UTC
+ * instant, so they have no rule zone and their displayed time uses the browser zone.
+ * @param record - reminder whose kind determines whether a zone is stored.
+ * @returns the stored IANA zone, or undefined when the record stores none.
+ */
+export declare function recordTimeZone(record: ScheduleRecord): string | undefined;
+/**
+ * Format exact intervals or wall-clock rules without changing their precision or zone.
+ *
+ * A cron rule reads as the sentence `cronPreview` derives from its expression,
+ * for example `Every day at 09:00, 15:00`. An expression this parser cannot
+ * read keeps the raw `Cron {expression}` form, so the stored rule stays visible
+ * when the Host's dialect and this parser diverge.
+ * @param record - reminder whose kind and stored rule determine its frequency.
+ * @param t - frequency, weekday, and unit translations, independent of the catalog namespace.
+ * @param zone - host-zone context; when present, a stored zone equal to `zone.system` is omitted
+ * and another zone is named by `zone.label`. Without it ICU localizes the stored zone.
+ * @returns localized one-shot, fixed-interval, daily, weekly, or cron time-and-zone text.
+ */
+export declare function formatScheduleFrequency(record: ScheduleRecord, t: FrequencyTranslator, zone?: FrequencyZone): string;
+/**
+ * Format one target instant as a localized month-and-day date with its time, the
+ * form the mock's task list shows and the same `Intl` field pair the universal
+ * cards use.
+ *
+ * The month is a locale-owned name, not a zero-padded number: `en` renders
+ * `Dec 31, 9:00 AM` and `zh-CN` renders `12月31日 09:00`, so neither locale can
+ * produce a `12-31` string. The year appears only when the instant falls outside
+ * the current year in the displayed zone, so a same-year target or delivery
+ * stays compact while an older record still dates itself.
+ *
+ * `timeZone` carries the rule's own zone for a daily, weekly, or cron record, so
+ * its occurrence reads in the task's zone. A one-shot `at` or `after` record
+ * stores only the UTC instant, so callers pass no zone and it formats in the
+ * browser zone.
+ * @param scheduledAt - durable UTC target.
+ * @param locale - BCP-47 locale owning the month name, day order, and clock.
+ * @param timeZone - IANA zone of the task's own rule, or undefined for the browser zone.
+ * @returns the localized month, day, and time, with the year when it is not the
+ * current one, or the raw instant when the value cannot be parsed.
+ */
+export declare function formatScheduleNextRun(scheduledAt: string, locale: string, timeZone?: string): string;
+/**
+ * Format one target as an absolute time in this device's zone.
+ *
+ * A task whose stored rule names its own zone still shows its next run in the
+ * reader's zone: the instant is the same one, and the reader compares it with
+ * their own clock. The locale owns the month name, the field order, and the
+ * separators, so the stamp reads `Sep 19, 2026, 15:51` in English and
+ * `9月19日 15:51` in Chinese.
+ *
+ * Whether a bare date reads the year is a per-language typographic choice, and
+ * the languages the design pins are stated in {@link YEAR_LANGUAGES} and
+ * {@link NO_YEAR_LANGUAGES}. Every language not listed there states the year:
+ * dropping it silently would hide the year of a target that can sit months or a
+ * year away, which is worse than one field more than the reader needs.
+ * @param scheduledAt - durable UTC target.
+ * @param locale - BCP-47 locale owning the month name, field order, and clock.
+ * @returns the localized absolute next run in the device zone, or the raw instant when it cannot be parsed.
+ */
+export declare function formatScheduleAbsolute(scheduledAt: string, locale: string): string;
+/**
+ * One next-run line as its two texts: the device-zone stamp and the distance.
+ *
+ * The list rows, the detail, the Session-header catalog, and the Sidebar hover
+ * card all state this pair, so they take it from here instead of each composing
+ * it: the stamp follows the language through `formatScheduleAbsolute`, and the
+ * distance stays the reader's countdown.
+ * @param scheduledAt - durable UTC target.
+ * @param locale - BCP-47 locale owning the month name, field order, and clock.
+ * @param now - current epoch milliseconds.
+ * @param t - relative-time and unit translations.
+ * @returns the absolute stamp, and the same distance wrapped in parentheses.
+ */
+export declare function nextRunParts(scheduledAt: string, locale: string, now: number, t: Translate<RelativeTimeKey>): {
+    readonly absolute: string;
+    readonly relative: string;
+};
+/**
+ * Format a relative target using the largest natural clock unit.
+ * @param scheduledAt - durable UTC target.
+ * @param now - current epoch milliseconds.
+ * @param t - relative-time and unit translations.
+ * @returns localized future, overdue, or due-now label.
+ */
+export declare function formatScheduleRelative(scheduledAt: string, now: number, t: Translate<RelativeTimeKey>): string;
+/**
+ * Order overdue records first and future records by ascending target time.
+ * @param records - reminders to order without mutating the input.
+ * @param now - current epoch milliseconds used to identify overdue targets.
+ * @returns sorted copy preserving input order for equal targets.
+ */
+export declare function orderScheduleRecords(records: readonly ScheduleRecord[], now: number): ScheduleRecord[];
+export {};
+//# sourceMappingURL=schedule-format.d.ts.map

package/lib/types/client/schedule-turn.d.ts

@@ -0,0 +1,63 @@
+import type { ConversationNodeDefinition, ToolResultNode, TurnLocation } from '@deepseek-ai/dsh-client-ui-conversation/client';
+/** Wire Tool name whose settled result carries one created task. */
+export declare const SCHEDULE_CREATE_TOOL = "schedule_create";
+/** One settled `schedule_create` result the card renders. */
+export type ScheduleCreatedTask = ToolResultNode;
+/** Immutable created-task facts published against one Turn. */
+export interface ScheduleTurnData {
+    readonly created: readonly ScheduleCreatedTask[];
+}
+declare module '@deepseek-ai/dsh-client-ui-conversation/client' {
+    interface ConversationTurnDataMap {
+        /** `schedule_create` results settled in this Turn, in settlement order. */
+        'schedule-created': ScheduleTurnData;
+    }
+}
+/**
+ * Turn-tail owner currency this row reads: the closing Turn with its sequence.
+ *
+ * Structurally equal to ui-chat's `TurnTailOwnerProps`; the fields are named
+ * locally so this package keeps its existing dependency set.
+ */
+export interface ScheduleTurnOwner {
+    readonly turn: TurnLocation;
+    readonly seq: number;
+    readonly openFile: (path: string) => void;
+}
+/** One in-window root call head, kept to build its result node. */
+interface ScheduleCall {
+    readonly name: string;
+    readonly argsRaw: string;
+    readonly time: number;
+}
+interface ScheduleTurnState {
+    readonly turn: number;
+    readonly calls: ReadonlyMap<string, ScheduleCall>;
+    readonly created: readonly ScheduleCreatedTask[];
+}
+/**
+ * Created tasks of one Turn up to a bound sequence.
+ *
+ * The Conversation Location index owns Turn membership before this runs, so
+ * tasks cannot spill across Turns.
+ * @param data - engine-published created-task data for one Turn.
+ * @param seq - bound sequence; settlements after it are excluded.
+ * @returns created result nodes in settlement order; empty when the Turn created none.
+ */
+export declare function scheduleTasksForClosing(data: Readonly<ScheduleTurnData> | undefined, seq?: number): readonly ScheduleCreatedTask[];
+/**
+ * Select the tasks one Turn created, for the Turn-tail list entry to render.
+ *
+ * The bounded sequence is the Turn's own end, not the closing Assistant text: a
+ * Turn whose last text response precedes a `schedule_create` settlement still
+ * owns that creation when it ends on a failed request or a user stop, and the
+ * turn-tail seat exists only for a completed Turn. A Turn without a recorded end
+ * falls back to the owner's own sequence.
+ * @param owner - Turn-tail owner currency for the closing Assistant.
+ * @returns created tasks, or null when the Turn created none.
+ */
+export declare function selectScheduleTasks(owner: ScheduleTurnOwner): ScheduleTurnData | null;
+/** Turn-local `schedule_create` accumulator; it publishes no view Node. */
+export declare const scheduleTurnDefinition: ConversationNodeDefinition<ScheduleTurnState>;
+export {};
+//# sourceMappingURL=schedule-turn.d.ts.map

package/lib/types/client/session-link.d.ts

@@ -0,0 +1,41 @@
+/** Original-Session link label and availability from the current public Session and Workspace feeds. */
+import type { SessionListState } from '@deepseek-ai/dsh-api-session-controller/client';
+import type { WorkspaceSnapshot } from '@deepseek-ai/dsh-api-workspace-controller/client';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+/** Navigation state shown beside the retained task's original Session id. */
+export type SessionLinkState = 'available' | 'loading' | 'archived' | 'unavailable';
+/**
+ * Check Host-list membership and archive state without activating or restoring anything.
+ *
+ * `SessionListState.byId` also carries local fallback rows for live Client
+ * generations, so membership comes from `ids`, the Host-list projection: a
+ * Session the Host list dropped reports unavailable even while a local row for
+ * it survives.
+ * @param id - Original Session bound to the task.
+ * @param sessions - Current Session list projection.
+ * @param workspaces - Current Workspace and archive projection.
+ * @returns availability or the reason navigation is disabled.
+ */
+export declare function sessionLinkState(id: SessionId, sessions: SessionListState, workspaces: WorkspaceSnapshot): SessionLinkState;
+/** Label one linked Session shows, and whether a Session title produced it. */
+export interface SessionLabel {
+    /** Session title from the current catalog, otherwise the Session id. */
+    readonly text: string;
+    /** Whether a catalog title produced {@link SessionLabel.text}; false when the id is shown instead. */
+    readonly titled: boolean;
+}
+/**
+ * Resolve the label of one linked Session from the Session catalog the calling
+ * component already projects.
+ *
+ * A catalog title renders as-is; the Session id renders while the catalog holds
+ * no row for the Session (missing or not yet loaded) or its row carries a blank
+ * title, so the label is never empty. Every surface that names a linked Session
+ * resolves the label here, so the Automation tasks rows, the task detail, and the
+ * task tab all name the same Session the same way.
+ * @param id - Original Session bound to the task.
+ * @param sessions - Current Session list projection.
+ * @returns the resolved label and whether a catalog title produced it.
+ */
+export declare function sessionLabel(id: SessionId, sessions: SessionListState): SessionLabel;
+//# sourceMappingURL=session-link.d.ts.map

package/lib/types/client/session-schedule-state.d.ts

@@ -0,0 +1,62 @@
+/**
+ * One Session's scheduled-task state for the ambient surfaces: the Sidebar
+ * row mark and the row hover-card task section.
+ *
+ * Both project the ONE Host catalog the page already owns — `schedule/catalog()`
+ * returns active and ended tasks with their originating `sessionId` — so N
+ * visible rows share one Remote read and follow one `schedule/changed`
+ * invalidation instead of issuing a query per row. The Session-header catalog
+ * keeps its own per-Session `schedule/list` source because it also lists the
+ * open Session's tasks.
+ */
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
+import type { HostObservable, SnapshotSelectorHook } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ScheduleCatalogEntry } from '@deepseek-ai/dsh-schedule/client';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import { type CatalogInjected, type CatalogSnapshot } from './catalog-source.ts';
+/** Per-Session source factory handed to the Session-header catalog occupant. */
+export type SessionScheduleSourceFactory = (sessionId: SessionId) => CatalogInjected;
+/**
+ * Create the durable reminder source for one Session.
+ *
+ * The stored read is `schedule/list`, which admits only tasks whose durable
+ * status is active; loading and error reads carry no authoritative answer.
+ * @param ctx - client context carrying the Remote schedule face.
+ * @param sessionId - Session whose tasks are read; reading never activates it.
+ * @returns observable catalog plus its mutation callbacks.
+ */
+export declare function createSessionScheduleSource(ctx: ClientContext, sessionId: SessionId): CatalogInjected;
+/** Selector hook the renderer binds from a slot's `hooks.catalog` observable. */
+export type SessionScheduleCatalogHook = SnapshotSelectorHook<CatalogSnapshot<ScheduleCatalogEntry>>;
+/** Shared Host catalog observable an ambient surface injects through its slot. */
+export type SessionScheduleCatalogObservable = HostObservable<CatalogSnapshot<ScheduleCatalogEntry>>;
+/** One Session's active scheduled tasks as projected from the shared Host catalog. */
+export interface SessionScheduleFacts {
+    /** Whether the settled catalog holds at least one active task for the Session. */
+    readonly hasActive: boolean;
+    /** Active tasks of the Session in catalog order; empty unless the read settled. */
+    readonly records: readonly ScheduleCatalogEntry[];
+}
+/**
+ * Project the shared Host catalog onto one Session's active tasks.
+ *
+ * `schedule/catalog()` returns active and ended tasks for every Session, so
+ * both facts come from this one snapshot filtered by `sessionId` and
+ * `status === 'active'`. A read that never settled answers no active task; a
+ * refresh republishes `loading` over the records of the last successful read, and
+ * the Host emits `schedule/changed` after every delivery, so following `status`
+ * here would blank a Session's mark for each roundtrip. An ended-only Session
+ * lists nothing.
+ * @param snapshot - shared Host catalog snapshot.
+ * @param sessionId - Session whose facts are selected.
+ * @returns this Session's active-task facts.
+ */
+export declare function selectSessionScheduleFacts(snapshot: CatalogSnapshot<ScheduleCatalogEntry>, sessionId: SessionId): SessionScheduleFacts;
+/**
+ * Select one Session's active-task facts from the shared Host catalog.
+ * @param useCatalog - selector hook bound to the shared Host catalog observable.
+ * @param sessionId - Session whose row is observed; reading activates nothing.
+ * @returns this Session's facts, stable across other Sessions' updates.
+ */
+export declare function useSessionScheduleFacts(useCatalog: SessionScheduleCatalogHook, sessionId: SessionId): SessionScheduleFacts;
+//# sourceMappingURL=session-schedule-state.d.ts.map

package/lib/types/client/task-cron.d.ts

@@ -0,0 +1,116 @@
+import type { Translate } from '@deepseek-ai/dsh-client-ui-slots';
+/** ISO weekday dictionary key naming one cron day-of-week value. */
+type CronWeekdayKey = `frequency.weekday.${1 | 2 | 3 | 4 | 5 | 6 | 7}`;
+/** Dictionary keys the cron description renders. */
+export type CronDescriptionKey = CronWeekdayKey | 'cron.list.join' | 'cron.part.join' | 'cron.weekday.name' | 'cron.weekday.range' | 'cron.months' | 'cron.day.every' | 'cron.day.weekdays' | 'cron.day.monthDays' | 'cron.day.both' | 'cron.day.bothStarred' | 'cron.hours.range' | 'cron.hours.list' | 'cron.time.everyMinute' | 'cron.time.everyMinutes' | 'cron.time.joinedEveryMinute' | 'cron.time.joinedEveryMinutes' | 'cron.time.everyHour' | 'cron.time.joinedEveryHour' | 'cron.time.everyNHours' | 'cron.time.joinedEveryNHours' | 'cron.time.hourlyAt' | 'cron.time.joinedHourlyAt' | 'cron.time.hoursEveryMinute' | 'cron.time.hoursEveryMinutes' | 'cron.time.at' | 'cron.time.hoursAt';
+/** Namespace-independent translator for the cron description. */
+export type CronDescriptionTranslator = Translate<CronDescriptionKey>;
+/** One parsed cron field: its matched values, its Vixie star flag, and its coverage. */
+export interface CronField {
+    /** Unique ascending matched values; Sunday 7 is folded onto 0. */
+    readonly values: readonly number[];
+    /**
+     * Whether the field text starts with `*`, which is Vixie's `DOM_STAR`/`DOW_STAR`
+     * test the Host applies: a stepped star such as `*​/2` counts, while a full range
+     * written out (`1-31`) does not.
+     */
+    readonly starred: boolean;
+    /** Whether the matched set is every value the field can take. */
+    readonly full: boolean;
+    /** Whether the field is a star field that matches every value. */
+    readonly unrestricted: boolean;
+}
+/** One parsed five-field cron expression in evaluation order. */
+export interface ParsedCron {
+    /** Unique ascending matched minutes. */
+    readonly minutes: CronField;
+    /** Unique ascending matched hours. */
+    readonly hours: CronField;
+    /** Unique ascending matched days of the month. */
+    readonly daysOfMonth: CronField;
+    /** Unique ascending matched months. */
+    readonly months: CronField;
+    /** Unique ascending matched cron weekdays, Sunday 0 through Saturday 6. */
+    readonly daysOfWeek: CronField;
+}
+/**
+ * Parse one five-field cron expression in the dialect the Host accepts.
+ * @param expression - candidate `minute hour day-of-month month day-of-week` text.
+ * @returns parsed fields, or undefined when the Host would reject the expression.
+ */
+export declare function parseCronExpression(expression: string): ParsedCron | undefined;
+/**
+ * Describe one parsed cron expression as one localized sentence.
+ * @param parsed - parsed cron expression.
+ * @param t - cron translations.
+ * @param locale - active UI locale naming restricted months.
+ * @returns localized sentence, for example `Mon–Fri at 09:00` or `Every 15 minutes`.
+ */
+export declare function cronPreview(parsed: ParsedCron, t: CronDescriptionTranslator, locale: string): string;
+/** One structured cron shape the Run time card's builder edits as rows. */
+export type CronBuilderState = {
+    /** Runs every `step` minutes of every hour and day. */
+    readonly kind: 'minutely';
+    /** Whole minutes between runs, 1 through 59. */
+    readonly step: number;
+} | {
+    /** Runs at one minute of every `step` hours, every day. */
+    readonly kind: 'hourly';
+    /** Whole hours between runs, 1 through 23. */
+    readonly step: number;
+    /** Minute of each matched hour, 0 through 59. */
+    readonly minute: number;
+} | {
+    /** Runs once a day at one wall-clock time. */
+    readonly kind: 'daily';
+    /** Hour of that time, 0 through 23. */
+    readonly hour: number;
+    /** Minute of that hour, 0 through 59. */
+    readonly minute: number;
+} | {
+    /** Runs on chosen weekdays at one wall-clock time. */
+    readonly kind: 'weekly';
+    /** ISO weekdays, Monday 1 through Sunday 7; never empty. */
+    readonly weekdays: readonly number[];
+    /** Hour of that time, 0 through 23. */
+    readonly hour: number;
+    /** Minute of that hour, 0 through 59. */
+    readonly minute: number;
+} | {
+    /** Runs on chosen days of every month at one wall-clock time. */
+    readonly kind: 'monthly';
+    /** Days of the month, 1 through 31, ascending; never empty. */
+    readonly days: readonly number[];
+    /** Hour of that time, 0 through 23. */
+    readonly hour: number;
+    /** Minute of that hour, 0 through 59. */
+    readonly minute: number;
+};
+/**
+ * Recognize the structured shape one parsed expression states, when one does.
+ *
+ * Every shape requires an unrestricted month. Exactly one of the two day fields
+ * may restrict: a restricted weekday beside a star day-of-month is a weekly
+ * rule, a restricted day-of-month beside a star weekday is a monthly rule, and
+ * both restricting is unrecognized because each restriction matches
+ * independently under the Host's Vixie union rule. Only a literal star states a
+ * day field with no restriction: a written-out full set such as `0-6` or `1-31`
+ * stays a weekly or monthly rule with every value selected, so toggling the
+ * last pill on never collapses its row. Stepped shapes accept any uniform
+ * full-range step on the clock, spelled with a star or written out, since both
+ * match the same minutes or hours.
+ * @param parsed - parsed cron expression.
+ * @returns the shape the builder can edit, or undefined for the raw-expression fallback.
+ */
+export declare function recognizeCronShape(parsed: ParsedCron): CronBuilderState | undefined;
+/**
+ * Spell one builder shape as the five-field expression a save submits.
+ *
+ * `recognizeCronShape` recognizes every expression this returns as the same
+ * shape, so a builder edit never falls back to the raw-expression row.
+ * @param state - builder shape to spell.
+ * @returns the expression stating that shape.
+ */
+export declare function cronShapeExpression(state: CronBuilderState): string;
+export {};
+//# sourceMappingURL=task-cron.d.ts.map

package/lib/types/client/task-manager-locales.d.ts

@@ -0,0 +1,195 @@
+/** English task-manager dictionary and key domain. */
+export declare const en: {
+    readonly 'timing.date': "Date";
+    readonly 'timing.time': "Time";
+    readonly 'timing.hour': "Hour";
+    readonly 'timing.minute': "Minute";
+    readonly 'timing.second': "Second";
+    readonly 'timing.prevMonth': "Previous month";
+    readonly 'timing.nextMonth': "Next month";
+    readonly 'timing.zone': "Time zone";
+    readonly 'timing.zoneSearch': "Search by UTC offset, IANA ID, or city";
+    readonly 'timing.zoneNoResults': "No matching time zones";
+    readonly 'timing.interval': "Repeat every";
+    readonly 'timing.intervalIncrease': "Increase interval";
+    readonly 'timing.intervalDecrease': "Decrease interval";
+    readonly 'timing.unit.hour': "hours";
+    readonly 'timing.unit.minute': "minutes";
+    readonly 'timing.unit.second': "seconds";
+    readonly 'timing.intervalHint.hour': "At least 1 hour. The interval counts from task creation or the last rule change and is independent of time zones.";
+    readonly 'timing.intervalHint.minute': "At least 1 minute. The interval counts from task creation or the last rule change and is independent of time zones.";
+    readonly 'timing.intervalHint.second': "At least 60 seconds. The interval counts from task creation or the last rule change and is independent of time zones.";
+    readonly 'timing.zoneNoStored': "A one-time task stores only its target moment, not a time zone. The date and time are interpreted in the selected time zone.";
+    readonly 'timing.inactive': "Inactive tasks are read-only. Their timing cannot be edited.";
+    readonly 'timing.conflict': string;
+    readonly 'timing.notFound': "This task is no longer available. Your draft is retained; cancel to close the editor.";
+    readonly 'timing.invalid': "Enter a valid date and time, or check the timing fields.";
+    readonly 'timing.invalidZone': "Enter a valid IANA time zone, for example Asia/Shanghai.";
+    readonly 'timing.notFuture': "Choose a date and time in the future.";
+    readonly 'timing.invalidInterval': "Enter an interval of at least 1 minute.";
+    readonly 'timing.invalidInterval.hour': "Enter an interval of at least 1 hour.";
+    readonly 'timing.invalidInterval.minute': "Enter an interval of at least 1 minute.";
+    readonly 'timing.invalidInterval.second': "Enter an interval of at least 60 seconds.";
+    readonly 'timing.error': "Could not confirm the timing update. Your draft is retained. Check the task before retrying.";
+    readonly 'rule.title': "Run time";
+    readonly 'rule.repeat': "Repeat";
+    readonly 'rule.weekday': "Weekday";
+    readonly 'rule.weekdayOption': "Weekday {weekday}";
+    readonly 'rule.unsaved': "Unsaved changes";
+    readonly 'rule.save': "Save changes";
+    readonly 'rule.saving': "Saving…";
+    readonly 'rule.cancel': "Cancel";
+    readonly 'rule.invalidTitle': "Enter a task name of at most 120 characters.";
+    readonly 'rule.invalidPrompt': "Enter a task instruction.";
+    readonly 'rule.once': "Once";
+    readonly 'rule.everyMinutes': "Every N minutes";
+    readonly 'rule.everyHours': "Every N hours";
+    readonly 'rule.everySeconds': "Every N seconds";
+    readonly 'rule.daily': "Every day";
+    readonly 'rule.weekdays': "Monday to Friday";
+    readonly 'rule.weekly': "Weekly";
+    readonly 'rule.cron': "Custom";
+    readonly 'rule.cronLabel': "Cron expression";
+    readonly 'rule.cronInvalid': "Enter a five-field cron expression, for example 0 9 * * 1-5.";
+    readonly 'cronForm.frequency': "Frequency";
+    readonly 'cronForm.monthly': "Monthly";
+    readonly 'cronForm.weekly': "Weekly";
+    readonly 'cronForm.daily': "Every day";
+    readonly 'cronForm.dates': "On dates";
+    readonly 'cronForm.dateOption': "Day {day}";
+    readonly 'cronForm.atMinute': "At minute";
+    readonly 'cronForm.minuteIncrease': "Increase minute";
+    readonly 'cronForm.minuteDecrease': "Decrease minute";
+    readonly 'rule.zone.system': " (system)";
+    readonly 'rule.error.conflict': "This task changed before the update was saved. The row shows the saved rule; try again.";
+    readonly 'rule.error.notFound': "This task is no longer available.";
+    readonly 'rule.error.unknown': "Could not confirm the rule update. The row shows the saved rule.";
+    readonly 'delete.action': "Delete task";
+    readonly 'delete.title': "Delete this task?";
+    readonly 'delete.description': string;
+    readonly 'delete.confirm': "Confirm deletion";
+    readonly 'delete.cancel': "Cancel";
+    readonly 'delete.close': "Close deletion confirmation";
+    readonly 'delete.pending': "Deleting…";
+    readonly 'toast.deleted': "Task deleted.";
+    readonly 'toast.deleteFailed': "Could not delete the task.";
+    readonly 'card.open': "Open";
+    readonly 'card.openLabel': "Open task details: {title}";
+    readonly 'card.deleted': "Deleted";
+    readonly 'tool.invoked': "Invoked {name}";
+    readonly "time.locale": string;
+    readonly "time.utcPrefix": string;
+    readonly "frequency.daily": string;
+    readonly "frequency.dailyLocal": string;
+    readonly "frequency.weekly": string;
+    readonly "frequency.weeklyLocal": string;
+    readonly "frequency.cron": string;
+    readonly "frequency.cronLocal": string;
+    readonly "frequency.cronRule": string;
+    readonly "cron.list.join": string;
+    readonly "cron.part.join": string;
+    readonly "cron.weekday.name": string;
+    readonly "cron.weekday.range": string;
+    readonly "cron.months": string;
+    readonly "cron.day.every": string;
+    readonly "cron.day.weekdays": string;
+    readonly "cron.day.monthDays": string;
+    readonly "cron.day.both": string;
+    readonly "cron.day.bothStarred": string;
+    readonly "cron.hours.range": string;
+    readonly "cron.hours.list": string;
+    readonly "cron.time.everyMinute": string;
+    readonly "cron.time.everyMinutes": string;
+    readonly "cron.time.joinedEveryMinute": string;
+    readonly "cron.time.joinedEveryMinutes": string;
+    readonly "cron.time.everyHour": string;
+    readonly "cron.time.joinedEveryHour": string;
+    readonly "cron.time.everyNHours": string;
+    readonly "cron.time.joinedEveryNHours": string;
+    readonly "cron.time.hourlyAt": string;
+    readonly "cron.time.joinedHourlyAt": string;
+    readonly "cron.time.hoursEveryMinute": string;
+    readonly "cron.time.hoursEveryMinutes": string;
+    readonly "cron.time.at": string;
+    readonly "cron.time.hoursAt": string;
+    readonly "frequency.weekday.join": string;
+    readonly "frequency.weekday.1": string;
+    readonly "frequency.weekday.2": string;
+    readonly "frequency.weekday.3": string;
+    readonly "frequency.weekday.4": string;
+    readonly "frequency.weekday.5": string;
+    readonly "frequency.weekday.6": string;
+    readonly "frequency.weekday.7": string;
+    readonly "unit.day.one": string;
+    readonly "unit.day.other": string;
+    readonly "unit.hour.one": string;
+    readonly "unit.hour.other": string;
+    readonly "unit.minute.one": string;
+    readonly "unit.minute.other": string;
+    readonly "unit.second.one": string;
+    readonly "unit.second.other": string;
+    readonly "relative.now": string;
+    readonly "relative.future": string;
+    readonly "relative.overdue": string;
+    readonly panel: "Automation tasks";
+    readonly title: "Automation tasks";
+    readonly 'new.action': "New";
+    readonly 'list.label': "Task catalog";
+    readonly 'list.nextPrefix': "Next scheduled time: ";
+    readonly 'list.loading': "Loading tasks…";
+    readonly 'list.error': "Could not load tasks.";
+    readonly 'list.retry': "Retry";
+    readonly 'list.empty': "No tasks yet. Tasks created in your sessions appear here.";
+    readonly 'list.emptyInactive': "No inactive automation tasks";
+    readonly 'list.noMatches': "No matching tasks";
+    readonly 'search.label': "Search tasks";
+    readonly 'search.placeholder': "Search automation tasks";
+    readonly 'search.clear': "Clear search";
+    readonly 'empty.action': "New automation task";
+    readonly 'statusFilter.label': "Task status";
+    readonly 'statusFilter.all': "All";
+    readonly 'status.active': "Enabled";
+    readonly 'status.inactive': "Inactive";
+    readonly 'detail.label': "Task details";
+    readonly 'detail.close': "Close details";
+    readonly 'detail.more': "Automation task actions";
+    readonly 'detail.nextRun': "Next run";
+    readonly 'detail.tabs': "Task detail views";
+    readonly 'detail.rule': "Rules";
+    readonly 'detail.records': "Delivery records";
+    readonly 'delivery.empty': "No delivery record available";
+    readonly 'delivery.loading': "Loading delivery records…";
+    readonly 'delivery.error': "Could not load delivery records.";
+    readonly 'delivery.notFound': "This task is no longer available.";
+    readonly 'delivery.cursorError': "Records were updated.";
+    readonly 'delivery.retry': "Retry";
+    readonly 'delivery.refresh': "Refresh";
+    readonly 'delivery.loadMore': "Load more";
+    readonly 'delivery.expand': "Expand";
+    readonly 'delivery.collapse': "Collapse";
+    readonly 'delivery.pruned': "Earlier delivery records have been cleared";
+    readonly 'delivery.retention': "Retention rules";
+    readonly 'delivery.retentionBounds': "Each task keeps up to {records} delivery records from the last {days} days.";
+    readonly 'delivery.retentionExplanation': "When a new record is saved, older records outside these limits are cleared automatically. Clearing records does not stop the task.";
+    readonly 'detail.name': "Automation task name";
+    readonly 'detail.instruction': "Automation task instruction";
+    readonly 'detail.status': "Status";
+    readonly 'detail.next': "Next scheduled time";
+    readonly 'detail.frequency': "Frequency";
+    readonly 'detail.id': "Task ID";
+    readonly 'detail.session': "Linked session";
+    readonly 'detail.openSession': "Linked session: open original session";
+    readonly 'detail.openSessionTitle': "Linked session {title}: open original session";
+    readonly 'detail.sessionLoading': "Loading original session information.";
+    readonly 'detail.sessionArchived': "The original session is archived.";
+    readonly 'detail.sessionUnavailable': "The original session is unavailable.";
+    readonly 'detail.missing': "Task unavailable. It may have been deleted.";
+    readonly 'delivery.label': "Saved delivery record";
+    readonly 'frequency.once': "Once";
+    readonly 'frequency.every': "Every {value} {unit}";
+};
+/** Keys registered under `schedule.manager`. */
+export type TaskManagerKey = keyof typeof en;
+/** Simplified Chinese dictionary with the same keys as English. */
+export declare const zh: Record<TaskManagerKey, string>;
+//# sourceMappingURL=task-manager-locales.d.ts.map