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

package/lib/types/client/TaskManagerPage.d.ts

@@ -0,0 +1,25 @@
+import type { HostObservable, InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ScheduleCatalogEntry } from '@deepseek-ai/dsh-schedule/client';
+import type { CatalogSnapshot } from './catalog-source.ts';
+import { type TaskDetailInjected } from './TaskDetail.tsx';
+/** Injected catalog and task actions for the management page. */
+export interface TaskManagerInjected extends TaskDetailInjected {
+    /** Host task catalog with its query and deletion state. */
+    readonly hooks: {
+        readonly catalog: HostObservable<CatalogSnapshot<ScheduleCatalogEntry>>;
+    };
+    /**
+     * Start a new Session, where a reminder is created by asking the model to
+     * schedule it. The page deliberately has no creation form of its own.
+     */
+    readonly onNewTask: () => void;
+}
+/** Root-scoped task catalog props derived from the framework and injected actions. */
+export type TaskManagerPageProps = PropsRuntime<'main'> & InjectFace<TaskManagerInjected> & PropsLocale<'schedule.manager'>;
+/**
+ * Render retained tasks with authoritative deletion and timing-only edits.
+ * @param props - framework catalog snapshot, localized copy, and action callbacks.
+ * @returns the searchable task list beside the selected task's detail.
+ */
+export declare function TaskManagerPage(props: TaskManagerPageProps): import("react").JSX.Element;
+//# sourceMappingURL=TaskManagerPage.d.ts.map

package/lib/types/client/TaskMenu.d.ts

@@ -0,0 +1,76 @@
+import type { ReactNode } from 'react';
+/** Selectable row of a {@link TaskMenu}. */
+export interface TaskMenuItem {
+    /** Identifier `onSelect` receives when the row is activated. */
+    id: string;
+    /** Visible row label. */
+    label: ReactNode;
+    /** Whether the row cannot be activated, and is not a step of the arrow walk. */
+    disabled?: boolean;
+    /** Leading icon. */
+    icon?: ReactNode;
+    /** Destructive row: error-colored text and icon, and the danger hover fill. */
+    danger?: boolean;
+}
+/** Hairline between item groups (not selectable). */
+export interface TaskMenuSeparator {
+    type: 'separator';
+    id: string;
+}
+/** Non-interactive heading row above a group of items. */
+export interface TaskMenuLabel {
+    type: 'label';
+    id: string;
+    text: string;
+}
+/** One TaskMenu entry: a row, a separator, or a heading label. */
+export type TaskMenuEntry = TaskMenuItem | TaskMenuSeparator | TaskMenuLabel;
+/** Inputs of {@link TaskMenu}. */
+export interface TaskMenuProps {
+    /** Whether the list is showing (owner-controlled). */
+    open: boolean;
+    /** The trigger element, rendered in place. */
+    anchor: ReactNode;
+    /** Selectable rows and optional separators or heading labels (default none). */
+    items?: readonly TaskMenuEntry[];
+    /** Row shown as selected, marked with a trailing check. */
+    selectedId?: string | undefined;
+    /** Row activation callback (not called for disabled rows). */
+    onSelect: (id: string) => void;
+    /** Invoked on an outside pointer press, Escape, or a window blur that moved focus into an iframe. */
+    onClose: () => void;
+    /** List alignment against the anchor (default 'start'). */
+    align?: 'start' | 'end';
+    /** Render the list into document.body, fixed-positioned from the anchor rect. */
+    portal?: boolean;
+    /** Owner content pinned above the scrolling rows. */
+    header?: ReactNode;
+    /** Extra class on the anchor wrapper span. */
+    className?: string | undefined;
+    /** Extra class on the dropdown card itself; the only style hook that reaches a portaled list. */
+    listClassName?: string | undefined;
+}
+/**
+ * Render an anchored dropdown menu. While the list is open, Tab settles the
+ * focused row — from the trigger, Tab enters the list instead — Escape and
+ * Shift+Tab close it and return focus to the anchor's first enabled button, and
+ * selecting a row does the same.
+ * @param props.open - whether the list is showing (owner-controlled).
+ * @param props.anchor - the trigger element, rendered in place.
+ * @param props.items - selectable rows and optional separators or heading labels.
+ * @param props.selectedId - row shown as selected.
+ * @param props.onSelect - row activation callback, not called for disabled rows.
+ * @param props.onClose - invoked on an outside pointer press, Escape, or a
+ * window blur that moved focus into a cross-origin iframe.
+ * @param props.align - list alignment against the anchor (default 'start').
+ * @param props.portal - render the list into document.body, fixed-positioned
+ * from the anchor rect (follows scroll and resize while open).
+ * @param props.header - owner content pinned above the scrolling rows; a control
+ * it marks `data-menu-field` takes the keyboard once the list is placed, which
+ * is the frame a portaled list becomes focusable in.
+ * @param props.className - extra class on the anchor wrapper span.
+ * @param props.listClassName - extra class on the dropdown card itself.
+ * @returns the anchor wrapper with the conditional list.
+ */
+export declare function TaskMenu({ open, anchor, items, selectedId, onSelect, onClose, align, portal, header, className, listClassName }: TaskMenuProps): import("react").JSX.Element;
+//# sourceMappingURL=TaskMenu.d.ts.map

package/lib/types/client/catalog-source.d.ts

@@ -0,0 +1,91 @@
+/** Authoritative Schedule queries and deletion for Session and Host catalogs. */
+import type { RemoteResult } from '@deepseek-ai/dsh-api-remotes/client';
+import type { HostObservable } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ScheduleDeleteResult, ScheduleId, ScheduleRecord } from '@deepseek-ai/dsh-schedule/client';
+/** How one deletion settled; the wiring reports it as a transient notice. */
+export type CatalogDeleteOutcome = 'deleted' | 'failed' | 'pending';
+/** Query and mutation state exposed to a catalog component. */
+export interface CatalogSnapshot<Item extends {
+    readonly id: ScheduleId;
+} = ScheduleRecord> {
+    readonly records: readonly Item[];
+    readonly status: 'loading' | 'ready' | 'error';
+    readonly deleting: readonly ScheduleId[];
+    /**
+     * Whether an authoritative list read has ever succeeded.
+     *
+     * A consumer may read `records` as the answer only once this holds: the first
+     * snapshot reports `loading` with no records, and a later refresh republishes
+     * `loading` over the records of the last successful read, so `status` alone
+     * cannot separate a first read from a refresh. A failed read leaves it alone.
+     */
+    readonly settled: boolean;
+    /**
+     * Count of reads this source has been asked for - by a consumer, and by its own
+     * `schedule/changed`, connection-reset, and post-deletion acknowledgement paths.
+     *
+     * A consumer that appears with a record of its own — a created-task card —
+     * records this at mount and asks for a read: an absence in the retained records
+     * states a deletion only once a read requested after that point has succeeded
+     * (see `readSettled`), because an earlier read may predate the record. A request
+     * shares the read in flight only when that read was requested after the ordinal
+     * the caller names, so this counts the requests rather than the `list()` calls.
+     * Counters rather than timestamps, so the answer never compares the browser's
+     * clock with the Host's.
+     */
+    readonly readRequest: number;
+    /**
+     * Ordinal of the read whose result the current records came from, and 0 before
+     * any read succeeded. A failed read leaves it alone.
+     */
+    readonly readSettled: number;
+}
+/** Remote operations and invalidations scoped by the registering entry. */
+export interface CatalogDependencies<Item extends {
+    readonly id: ScheduleId;
+} = ScheduleRecord> {
+    readonly list: () => Promise<RemoteResult<Item[]>>;
+    readonly remove: (id: ScheduleId) => Promise<RemoteResult<ScheduleDeleteResult>>;
+    readonly subscribeChanged: (listener: () => void) => () => void;
+    readonly subscribeReset: (listener: () => void) => () => void;
+}
+/** Props injected through a catalog slot. */
+export interface CatalogInjected<Item extends {
+    readonly id: ScheduleId;
+} = ScheduleRecord> {
+    readonly hooks: {
+        readonly catalog: HostObservable<CatalogSnapshot<Item>>;
+    };
+    /**
+     * Delete one reminder and refresh after the Remote acknowledgement.
+     * @param id - reminder shown in this catalog.
+     * @returns 'deleted' after the acknowledged deletion's refreshed query,
+     * 'failed' when the deletion was not confirmed, and 'pending' when a deletion
+     * of the same reminder was already in flight.
+     */
+    readonly onDelete: (id: ScheduleId) => Promise<CatalogDeleteOutcome>;
+    /**
+     * Reload the catalog: after a query failure or an acknowledged timing update,
+     * and from a created-task card that needs a read newer than its own result.
+     *
+     * Requests made in one commit share a single read, so several cards mounting
+     * together still send one. A caller that has already observed a request passes
+     * that ordinal as `since`, and only a read requested later than it is shared - so
+     * a read issued before the caller appeared cannot answer for it, and a caller
+     * that has seen the newest request gets a fresh read.
+     * @param since - request ordinal the caller last observed, 0 to share any read in flight.
+     * @returns Resolution after publishing the read result; failures remain in catalog state.
+     */
+    readonly onRetry: (since?: number) => Promise<void>;
+}
+/**
+ * Create a catalog whose Remote subscriptions follow its framework subscribers.
+ * Mutations retain visible rows until an authoritative list read succeeds, and
+ * each deletion resolves with its own outcome for the caller to report.
+ * @param deps - Remote calls and invalidation subscriptions.
+ * @returns observable catalog and component callbacks.
+ */
+export declare function createCatalogSource<Item extends {
+    readonly id: ScheduleId;
+} = ScheduleRecord>(deps: CatalogDependencies<Item>): CatalogInjected<Item>;
+//# sourceMappingURL=catalog-source.d.ts.map

package/lib/types/client/definition.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Stage one of the task tab type's registration: what it IS.
+ *
+ * A page type: it recognizes no resource address, because its content is one
+ * task named by navigation parameters rather than by an address, and is opened
+ * by kind. `builtin` is the ordinary band for a type shipped with the product.
+ */
+import type { TranslateNS } from '@deepseek-ai/dsh-client-locale/client';
+import type { SidebarRightTabDefinition, SidebarRightTabParamsMap, SidebarRightNavigationParams } from '@deepseek-ai/dsh-client-ui-sidebar-right/client';
+import type { ScheduleId } from '@deepseek-ai/dsh-schedule/client';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+/** This implementation's identity in the tab system: the key its body and title register under. */
+export declare const SCHEDULE_TASK_ID = "@deepseek-ai/dsh-client-ui-schedule/task";
+/** The tab kind this package owns. */
+export declare const SCHEDULE_TASK_KIND = "scheduleTask";
+declare module '@deepseek-ai/dsh-client-ui-sidebar-right/client' {
+    interface SidebarRightTabParamsMap {
+        /** One retained task, named by its original Session and its own identity. */
+        scheduleTask: {
+            sessionId: SessionId;
+            id: ScheduleId;
+        };
+    }
+}
+/**
+ * The task type's registry definition.
+ *
+ * The chip text captured here is a constant because an open names only a kind;
+ * `ScheduleTaskTabTitle` replaces it with the shown task's stored title.
+ * @param t - namespace-bound translate, read fresh on every title call.
+ * @returns the definition to register.
+ */
+export declare function scheduleTaskDefinition(t: TranslateNS<'schedule.manager'>): SidebarRightTabDefinition;
+/**
+ * Narrow one tab's navigation parameters to this type's task binding.
+ * @param params - the tab record's navigation parameters.
+ * @returns the Session and task the tab shows, or undefined for another type's parameters.
+ */
+export declare function scheduleTaskParams(params: SidebarRightNavigationParams): SidebarRightTabParamsMap['scheduleTask'] | undefined;
+//# sourceMappingURL=definition.d.ts.map

package/lib/types/client/frequency-locales.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Stored-rule and elapsed-duration copy shared by the `schedule.catalog` and
+ * `schedule.manager` namespaces.
+ *
+ * Both namespaces label the same stored rule kinds, describe cron rules with
+ * the same `cronPreview` sentence, and word the same relative durations, so
+ * their wording for those keys is one source here. The keys either namespace
+ * words differently — its one-shot label, its list states, and its own delete
+ * and timing copy — stay in that namespace's dictionary.
+ * @module
+ */
+/** Simplified Chinese rule and duration copy, key-set source of truth. */
+export declare const frequencyZh: {
+    readonly 'time.locale': "zh-CN";
+    readonly 'time.utcPrefix': "UTC";
+    readonly 'frequency.daily': "每天 {time}（{timeZone}）";
+    readonly 'frequency.dailyLocal': "每天 {time}";
+    readonly 'frequency.weekly': "每周{weekdays} {time}（{timeZone}）";
+    readonly 'frequency.weeklyLocal': "每周{weekdays} {time}";
+    readonly 'frequency.cron': "Cron {expression}（{timeZone}）";
+    readonly 'frequency.cronLocal': "Cron {expression}";
+    readonly 'frequency.cronRule': "{rule}（{timeZone}）";
+    readonly 'cron.list.join': "、";
+    readonly 'cron.part.join': " ";
+    readonly 'cron.weekday.name': "周{weekday}";
+    readonly 'cron.weekday.range': "{from}至{to}";
+    readonly 'cron.months': "（{months}）";
+    readonly 'cron.day.every': "每天{months}";
+    readonly 'cron.day.weekdays': "{weekdays}{months}";
+    readonly 'cron.day.monthDays': "每月 {days} 日{months}";
+    readonly 'cron.day.both': "每月 {days} 日或{weekdays}{months}";
+    readonly 'cron.day.bothStarred': "每月 {days} 日且{weekdays}{months}";
+    readonly 'cron.hours.range': "{from} 至 {to}";
+    readonly 'cron.hours.list': "{hours}";
+    readonly 'cron.time.everyMinute': "每分钟";
+    readonly 'cron.time.everyMinutes': "每 {step} 分钟";
+    readonly 'cron.time.joinedEveryMinute': "每分钟";
+    readonly 'cron.time.joinedEveryMinutes': "每 {step} 分钟";
+    readonly 'cron.time.everyHour': "每小时";
+    readonly 'cron.time.joinedEveryHour': "每小时";
+    readonly 'cron.time.everyNHours': "每 {count} 小时";
+    readonly 'cron.time.joinedEveryNHours': "每 {count} 小时";
+    readonly 'cron.time.hourlyAt': "每小时的第 {minutes} 分钟";
+    readonly 'cron.time.joinedHourlyAt': "每小时的第 {minutes} 分钟";
+    readonly 'cron.time.hoursEveryMinute': "{hours} 点的每分钟";
+    readonly 'cron.time.hoursEveryMinutes': "{hours} 点内每 {step} 分钟";
+    readonly 'cron.time.at': "{times}";
+    readonly 'cron.time.hoursAt': "{hours} 点的第 {minutes} 分钟";
+    readonly 'frequency.weekday.join': "、";
+    readonly 'frequency.weekday.1': "一";
+    readonly 'frequency.weekday.2': "二";
+    readonly 'frequency.weekday.3': "三";
+    readonly 'frequency.weekday.4': "四";
+    readonly 'frequency.weekday.5': "五";
+    readonly 'frequency.weekday.6': "六";
+    readonly 'frequency.weekday.7': "日";
+    readonly 'unit.day.one': "天";
+    readonly 'unit.day.other': "天";
+    readonly 'unit.hour.one': "小时";
+    readonly 'unit.hour.other': "小时";
+    readonly 'unit.minute.one': "分钟";
+    readonly 'unit.minute.other': "分钟";
+    readonly 'unit.second.one': "秒";
+    readonly 'unit.second.other': "秒";
+    readonly 'relative.now': "现在到期";
+    readonly 'relative.future': "{value}{unit}后";
+    readonly 'relative.overdue': "已逾期 {value}{unit}";
+};
+/** English rule and duration copy, key-identical to the Chinese source. */
+export declare const frequencyEn: Record<keyof typeof frequencyZh, string>;
+//# sourceMappingURL=frequency-locales.d.ts.map

package/lib/types/client/index.d.ts

@@ -1,14 +1,50 @@
-/** Browser half of the read-only Schedule catalog. */
+/**
+ * Browser catalogs for retained Host tasks and the selected Session's active
+ * reminders, plus the right-Sidebar page that shows one task's detail.
+ *
+ * The page type reaches the Sidebar through its public path only: the
+ * definition into `ctx.sidebarRightTabs`, the body into the keyed
+ * `sidebar.right.pane.tab` seat, and the chip title into
+ * `sidebar.right.pane.tab.title`, both under the definition's `id`. Because the
+ * Sidebar persists a tab's layout record and not the parameters its opener
+ * passed, the page also owns a binding from each tab page to the task it last
+ * showed, which its body and chip read back after a reload. The Session
+ * header entry and the task tab share one Host catalog source, so opening or
+ * deleting from either view reads and refreshes the same records.
+ *
+ * The created task of a `schedule_create` call renders at Turn level: a Turn
+ * Definition publishes the settled result against its Turn, and ui-chat's
+ * `conversation.chat.turnTail` list seat renders the card beneath
+ * the closing prose, outside the collapsible Tool group, opening the same
+ * right-Sidebar detail the header entry opens. The call's Tool-group cell
+ * stays with ui-tool's generic keyed tool view, so this package registers no
+ * `tool.call.toolview` entry for the wire name.
+ *
+ * Two ambient surfaces read the ONE Host catalog the page owns: ui-workspace's
+ * `sidebar.session.row.leading` seat marks an idle row whose Session has an
+ * active task, and its `sidebar.session.row.hover` seat lists those tasks
+ * inside the row's hover card. Both project the same source, so N visible rows
+ * issue one query rather than one per row. The header entry keeps its own
+ * per-Session source.
+ */
 import type { Context as ClientContext } from '@deepseek-ai/cordis';
 import { type ScheduleCatalogKey } from './locales.ts';
+import { type TaskManagerKey } from './task-manager-locales.ts';
 declare module '@deepseek-ai/dsh-client-ui-slots' {
     interface LocaleNamespaceMap {
-        /** Read-only active Schedule catalog copy. */
+        /** Active Schedule catalog copy. */
         'schedule.catalog': ScheduleCatalogKey;
+        /** Host task management page and task tab copy. */
+        'schedule.manager': TaskManagerKey;
     }
 }
-/** Required services for locale registration and header-slot contribution. */
+/** Required services for catalogs, ambient Session marks, the right Sidebar, Remote queries, and original-Session navigation. */
 export declare const inject: string[];
-/** Register the dictionaries and Session-header catalog action. */
+/**
+ * Register the Host task page, the Session-header reminder catalog, the
+ * right-Sidebar page that shows one task's detail, and the transcript card of
+ * one created task.
+ * @param ctx - browser services used by these contributions.
+ */
 export declare function apply(ctx: ClientContext): void;
 //# sourceMappingURL=index.d.ts.map

package/lib/types/client/locales.d.ts

@@ -1,15 +1,52 @@
-/** `schedule.catalog` namespace dictionaries. */
 /** Dictionary namespace owned by this plugin. */
 export declare const NS = "schedule.catalog";
 /** Simplified Chinese dictionary (the key-set source of truth). */
 export declare const zh: {
-    readonly 'trigger.one': "{count} 个提醒";
-    readonly 'trigger.other': "{count} 个提醒";
-    readonly 'list.aria': "活动提醒";
-    readonly 'status.scheduled': "等待中";
-    readonly 'status.overdue': "已逾期";
-    readonly 'frequency.once': "单次";
-    readonly 'frequency.every': "{value}{unit}一次";
+    readonly 'mark.aria': "{count} 个自动化任务";
+    readonly 'hover.more': "另有 {count} 个任务";
+    readonly 'time.locale': "zh-CN";
+    readonly 'time.utcPrefix': "UTC";
+    readonly 'frequency.daily': "每天 {time}（{timeZone}）";
+    readonly 'frequency.dailyLocal': "每天 {time}";
+    readonly 'frequency.weekly': "每周{weekdays} {time}（{timeZone}）";
+    readonly 'frequency.weeklyLocal': "每周{weekdays} {time}";
+    readonly 'frequency.cron': "Cron {expression}（{timeZone}）";
+    readonly 'frequency.cronLocal': "Cron {expression}";
+    readonly 'frequency.cronRule': "{rule}（{timeZone}）";
+    readonly 'cron.list.join': "、";
+    readonly 'cron.part.join': " ";
+    readonly 'cron.weekday.name': "周{weekday}";
+    readonly 'cron.weekday.range': "{from}至{to}";
+    readonly 'cron.months': "（{months}）";
+    readonly 'cron.day.every': "每天{months}";
+    readonly 'cron.day.weekdays': "{weekdays}{months}";
+    readonly 'cron.day.monthDays': "每月 {days} 日{months}";
+    readonly 'cron.day.both': "每月 {days} 日或{weekdays}{months}";
+    readonly 'cron.day.bothStarred': "每月 {days} 日且{weekdays}{months}";
+    readonly 'cron.hours.range': "{from} 至 {to}";
+    readonly 'cron.hours.list': "{hours}";
+    readonly 'cron.time.everyMinute': "每分钟";
+    readonly 'cron.time.everyMinutes': "每 {step} 分钟";
+    readonly 'cron.time.joinedEveryMinute': "每分钟";
+    readonly 'cron.time.joinedEveryMinutes': "每 {step} 分钟";
+    readonly 'cron.time.everyHour': "每小时";
+    readonly 'cron.time.joinedEveryHour': "每小时";
+    readonly 'cron.time.everyNHours': "每 {count} 小时";
+    readonly 'cron.time.joinedEveryNHours': "每 {count} 小时";
+    readonly 'cron.time.hourlyAt': "每小时的第 {minutes} 分钟";
+    readonly 'cron.time.joinedHourlyAt': "每小时的第 {minutes} 分钟";
+    readonly 'cron.time.hoursEveryMinute': "{hours} 点的每分钟";
+    readonly 'cron.time.hoursEveryMinutes': "{hours} 点内每 {step} 分钟";
+    readonly 'cron.time.at': "{times}";
+    readonly 'cron.time.hoursAt': "{hours} 点的第 {minutes} 分钟";
+    readonly 'frequency.weekday.join': "、";
+    readonly 'frequency.weekday.1': "一";
+    readonly 'frequency.weekday.2': "二";
+    readonly 'frequency.weekday.3': "三";
+    readonly 'frequency.weekday.4': "四";
+    readonly 'frequency.weekday.5': "五";
+    readonly 'frequency.weekday.6': "六";
+    readonly 'frequency.weekday.7': "日";
     readonly 'unit.day.one': "天";
     readonly 'unit.day.other': "天";
     readonly 'unit.hour.one': "小时";
@@ -21,6 +58,20 @@ export declare const zh: {
     readonly 'relative.now': "现在到期";
     readonly 'relative.future': "{value}{unit}后";
     readonly 'relative.overdue': "已逾期 {value}{unit}";
+    readonly 'trigger.label': "提醒";
+    readonly 'list.loading': "正在加载提醒…";
+    readonly 'list.error': "无法加载提醒。";
+    readonly 'list.retry': "重试";
+    readonly 'delete.action': "删除";
+    readonly 'delete.pending': "正在删除…";
+    readonly 'delete.label': "删除提醒：{title}";
+    readonly 'list.open': "打开提醒详情：{title}";
+    readonly 'trigger.one': "{count} 个提醒";
+    readonly 'trigger.other': "{count} 个提醒";
+    readonly 'list.aria': "活动提醒";
+    readonly 'list.nextRun': "下次运行";
+    readonly 'frequency.once': "单次";
+    readonly 'frequency.every': "{value}{unit}一次";
 };
 /** English dictionary, key-identical to the Chinese source of truth. */
 export declare const en: Record<ScheduleCatalogKey, string>;

package/lib/types/client/recent-time-zones.d.ts

@@ -0,0 +1,15 @@
+/** Browser-local recently selected IANA time zones. */
+/**
+ * Load up to five recent zones, or the system-zone/UTC first-run seed.
+ * @param system - the host's current IANA zone.
+ * @returns recent IANA zones in most-recent-first order.
+ */
+export declare function loadRecentTimeZones(system: string): readonly string[];
+/**
+ * Promote one exact IANA id and persist the bounded list when storage is available.
+ * @param recent - current most-recent-first IANA zones.
+ * @param zone - exact IANA zone to promote.
+ * @returns the updated bounded most-recent-first list.
+ */
+export declare function rememberTimeZone(recent: readonly string[], zone: string): readonly string[];
+//# sourceMappingURL=recent-time-zones.d.ts.map

package/lib/types/client/relative-clock.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Refresh period for relative-time text.
+ *
+ * The text names whole seconds, minutes, hours, or days, so a half-minute
+ * period keeps it correct to its own granularity without re-rendering a mounted
+ * page on every frame.
+ */
+export declare const RELATIVE_CLOCK_PERIOD_MS = 30000;
+/**
+ * Current epoch milliseconds, re-sampled on a fixed period.
+ *
+ * A relative duration is read against the moment it renders, not against the
+ * moment its component mounted: a page left open across a delivery would keep
+ * showing the time until the previous target.
+ *
+ * This is the shared clock of the mounted task page and its detail, the two
+ * surfaces that sit side by side and must not disagree about how long remains.
+ * Two other surfaces keep their own beat: the Session-header catalog reads
+ * `Date.now()` and then a one-second interval while its popover is open, and the
+ * Sidebar Session-row hover card samples `Date.now()` once per mount, because
+ * that preview must not drift while the pointer rests on it.
+ * @param periodMs - refresh period; defaults to {@link RELATIVE_CLOCK_PERIOD_MS}.
+ * @returns epoch milliseconds, updated once per period.
+ */
+export declare function useRelativeClock(periodMs?: number): number;
+//# sourceMappingURL=relative-clock.d.ts.map

package/lib/types/client/schedule-create-card.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Pure card model for one `schedule_create` call in the Session transcript.
+ *
+ * The tool's model-facing result is its canonical task value serialized as
+ * JSON (`renderValue`), so the created task's identity and rule are read from
+ * that text. Presentation runs while a call streams and again on Session-log
+ * replay of arbitrary logged arguments, so every step narrows wire JSON and
+ * returns empty rather than throwing.
+ */
+import type { ScheduleRecord } from '@deepseek-ai/dsh-schedule/client';
+import type { ToolCallViewProps } from '@deepseek-ai/dsh-client-ui-tool/client';
+/** One Tool call block as the card receives it: a running call or a settled result. */
+type ToolBlock = ToolCallViewProps['block'];
+/** Derived presentation of one `schedule_create` call. */
+export interface ScheduleCreateCardModel {
+    /** Created task narrowed from the settled result, or undefined when the result carries none. */
+    readonly task: ScheduleRecord | undefined;
+    /** Single-line task title from the result, the call arguments, or the wire tool name. */
+    readonly title: string;
+    /** Raw model-facing result text of a settled call, when it is one text block. */
+    readonly output: string | null;
+}
+/**
+ * Narrow one opaque value to a complete Schedule rule.
+ *
+ * The value arrives from replayed wire JSON, so each rule kind is checked for
+ * the fields `formatScheduleFrequency` reads. A missing identity or an
+ * incomplete rule returns undefined and the card renders without a task.
+ *
+ * The result JSON normally carries the stored title. A result recorded before
+ * that field existed carries none, so this narrowing derives the display title
+ * from the instruction's first line; when the instruction has no such line it
+ * returns undefined.
+ * @param value - opaque value parsed from logged JSON.
+ * @returns the narrowed rule, or undefined when it is not a complete task.
+ */
+export declare function narrowScheduleRecord(value: unknown): ScheduleRecord | undefined;
+/**
+ * Derive the transcript card of one `schedule_create` call.
+ * @param block - raw call or result block carried by the Session journal.
+ * @param toolName - wire Tool name, used when no task title is available.
+ * @returns the created task, its title, and the settled result text.
+ */
+export declare function scheduleCreateCardModel(block: ToolBlock, toolName: string): ScheduleCreateCardModel;
+export {};
+//# sourceMappingURL=schedule-create-card.d.ts.map