@qilin-agent/schedule 0.0.0-stage → 3.1.4

package/lib/types/types.d.ts

@@ -0,0 +1,422 @@
+/**
+ * Durable and model-facing Schedule value types.
+ * @module @qilin-agent/schedule
+ */
+import type { SessionId } from '@qilin-agent/session/types';
+import type { MessageId } from '@qilin-agent/llm/brand';
+import type { Branded } from '@qilin-agent/brand';
+/** Stable globally unique reminder identity. */
+export type ScheduleId = Branded<'ScheduleId'>;
+/** Durable one-shot reminder created from a positive delay. */
+export interface AfterScheduleRecord {
+    /** Globally unique task identity. */
+    readonly id: ScheduleId;
+    /** Rule discriminator for a delayed one-shot reminder. */
+    readonly kind: 'after';
+    /** Required stored task name; already trimmed, non-empty, and at most 120 characters. */
+    readonly title: string;
+    /** Trimmed reminder content supplied at creation. */
+    readonly prompt: string;
+    /** Positive safe-integer delay accepted at creation. */
+    readonly afterSeconds: number;
+    /** Four-digit-year RFC 3339 UTC target. */
+    readonly scheduledAt: string;
+}
+/** Durable one-shot reminder created from an absolute instant. */
+export interface AtScheduleRecord {
+    /** Globally unique task identity. */
+    readonly id: ScheduleId;
+    /** Rule discriminator for an absolute one-shot reminder. */
+    readonly kind: 'at';
+    /** Required stored task name; already trimmed, non-empty, and at most 120 characters. */
+    readonly title: string;
+    /** Trimmed reminder content supplied at creation. */
+    readonly prompt: string;
+    /** Four-digit-year RFC 3339 UTC target. */
+    readonly scheduledAt: string;
+}
+/** Durable fixed-rate reminder aligned to creation or its most recent interval edit. */
+export interface EveryScheduleRecord {
+    /** Globally unique task identity. */
+    readonly id: ScheduleId;
+    /** Rule discriminator for a fixed-rate recurring reminder. */
+    readonly kind: 'every';
+    /** Required stored task name; already trimmed, non-empty, and at most 120 characters. */
+    readonly title: string;
+    /** Trimmed reminder content supplied at creation. */
+    readonly prompt: string;
+    /** Fixed safe-integer interval, never below one minute. */
+    readonly everySeconds: number;
+    /** Next anchor-aligned occurrence while active, or final occurrence when inactive. */
+    readonly scheduledAt: string;
+}
+/** Durable daily wall-clock reminder; gaps skip a date and overlaps use the earlier instant. */
+export interface DailyScheduleRecord {
+    /** Globally unique task identity. */
+    readonly id: ScheduleId;
+    /** Rule discriminator for a daily wall-clock reminder. */
+    readonly kind: 'daily';
+    /** Required stored task name; already trimmed, non-empty, and at most 120 characters. */
+    readonly title: string;
+    /** Trimmed reminder content supplied at creation. */
+    readonly prompt: string;
+    /** Local time normalized to HH:mm:ss.SSS. */
+    readonly time: string;
+    /** Explicit IANA zone; equivalent timing edits retain the stored spelling. */
+    readonly timeZone: string;
+    /** Committed next UTC instant while active, or final occurrence when inactive. */
+    readonly scheduledAt: string;
+}
+/** Durable weekly wall-clock reminder; gaps skip a date and overlaps use the earlier instant. */
+export interface WeeklyScheduleRecord {
+    /** Globally unique task identity. */
+    readonly id: ScheduleId;
+    /** Rule discriminator for a weekly wall-clock reminder. */
+    readonly kind: 'weekly';
+    /** Required stored task name; already trimmed, non-empty, and at most 120 characters. */
+    readonly title: string;
+    /** Trimmed reminder content supplied at creation. */
+    readonly prompt: string;
+    /** Local time normalized to HH:mm:ss.SSS. */
+    readonly time: string;
+    /** Explicit canonical IANA zone; equivalent timing edits retain the stored spelling. */
+    readonly timeZone: string;
+    /** Unique ascending ISO weekdays, Monday 1 through Sunday 7. */
+    readonly weekdays: number[];
+    /** Committed next UTC instant while active, or final occurrence when inactive. */
+    readonly scheduledAt: string;
+}
+/** Durable cron wall-clock reminder; gaps skip a date and overlaps use the earlier instant. */
+export interface CronScheduleRecord {
+    /** Globally unique task identity. */
+    readonly id: ScheduleId;
+    /** Rule discriminator for a five-field cron wall-clock reminder. */
+    readonly kind: 'cron';
+    /** Required stored task name; already trimmed, non-empty, and at most 120 characters. */
+    readonly title: string;
+    /** Trimmed reminder content supplied at creation. */
+    readonly prompt: string;
+    /** Canonical five-field cron expression: minute hour day-of-month month day-of-week. */
+    readonly expression: string;
+    /** Explicit IANA zone; equivalent timing edits retain the stored spelling. */
+    readonly timeZone: string;
+    /** Committed next UTC instant while active, or final occurrence when inactive. */
+    readonly scheduledAt: string;
+}
+/** Daily local-time selector accepted by creation and timing edits. */
+export interface DailyInput {
+    /** Local HH:mm:ss time with optional one-to-three fractional digits. */
+    readonly time: string;
+    /** Explicit UTC or IANA Area/Location zone. */
+    readonly time_zone: string;
+}
+/** Weekly local-time and weekday selector accepted by creation and timing edits. */
+export interface WeeklyInput {
+    /** Local HH:mm:ss time with optional one-to-three fractional digits. */
+    readonly time: string;
+    /** Explicit UTC or IANA Area/Location zone. */
+    readonly time_zone: string;
+    /** Non-empty ISO weekday set, Monday 1 through Sunday 7, without repetitions. */
+    readonly weekdays: number[];
+}
+/** Five-field cron selector accepted by creation and timing edits. */
+export interface CronInput {
+    /** Five-field Vixie cron expression: minute hour day-of-month month day-of-week. */
+    readonly expression: string;
+    /** Explicit UTC or IANA Area/Location zone. */
+    readonly time_zone: string;
+}
+/** Structured local-calendar input accepted by creation and timing edits. */
+export interface LocalAtInput {
+    /** Four-digit ISO calendar date. */
+    readonly date: string;
+    /** Local wall-clock time with optional one-to-three digit milliseconds. */
+    readonly time: string;
+    /** Explicit UTC or IANA Area/Location zone. */
+    readonly time_zone: string;
+}
+/** Absolute selector accepted by creation and timing edits. */
+export type AtInput = string | LocalAtInput;
+/** One-shot task variants. */
+export type OneShotScheduleRecord = AfterScheduleRecord | AtScheduleRecord;
+/** One-shot delay persisted by a version-1 Session event, without the later `title`. */
+export interface LegacyAfterScheduleRecord extends Omit<AfterScheduleRecord, 'title'> {
+    /** Stored task name; absent in an event written before titles existed. */
+    readonly title?: string;
+}
+/** Absolute one-shot persisted by a version-1 Session event, without the later `title`. */
+export interface LegacyAtScheduleRecord extends Omit<AtScheduleRecord, 'title'> {
+    /** Stored task name; absent in an event written before titles existed. */
+    readonly title?: string;
+}
+/** Fixed-rate reminder persisted by a version-1 Session event, without the later `title`. */
+export interface LegacyEveryScheduleRecord extends Omit<EveryScheduleRecord, 'title'> {
+    /** Stored task name; absent in an event written before titles existed. */
+    readonly title?: string;
+}
+/**
+ * Frozen Session event and fold vocabulary; daily rules belong only to Host storage.
+ *
+ * A version-1 event written before titles existed persists no `title` member, so
+ * `after`, `at`, and `every` decode without one and stay readable. The Host task
+ * record requires the member and never persists a record without it.
+ */
+export type LegacyScheduleRecord = LegacyAfterScheduleRecord | LegacyAtScheduleRecord | LegacyEveryScheduleRecord;
+/** Recurring Host task variants. */
+export type RecurringScheduleRecord = EveryScheduleRecord | DailyScheduleRecord | WeeklyScheduleRecord | CronScheduleRecord;
+/** Reminder rule and target, stored with its original Session binding. */
+export type ScheduleRecord = OneShotScheduleRecord | RecurringScheduleRecord;
+/** Durable Session inbox delivery acknowledgment, not model execution completion. */
+export interface ScheduleDeliveryReceipt {
+    /** Canonical UTC target of the delivered occurrence. */
+    readonly scheduledAt: string;
+    /** Canonical UTC time sampled after Session persistence acknowledged delivery. */
+    readonly deliveredAt: string;
+    /** Identity of the delivered message, shared by tasks in one recurring batch. */
+    readonly messageId: MessageId;
+}
+/** Saved inbox delivery with its immutable sent prompt when recorded by this Host. */
+export interface ScheduleDeliveryRecord extends ScheduleDeliveryReceipt {
+    /** Prompt sent for this occurrence; unavailable for legacy receipts. */
+    readonly prompt?: string;
+}
+/** Browser-safe retained reminder with its original Session binding. */
+export type ScheduleCatalogEntry = ScheduleRecord & {
+    /** Session receiving this reminder when it becomes due. */
+    readonly sessionId: SessionId;
+    /** Inactive reminders remain visible but never schedule another delivery. */
+    readonly status: 'active' | 'inactive';
+    /** Most recent durably acknowledged inbox delivery, when available. */
+    readonly lastDelivery?: ScheduleDeliveryReceipt;
+};
+/** Creates one durable reminder record. */
+export interface ScheduleCreateChange {
+    readonly version: 1;
+    readonly operation: 'create';
+    readonly schedule: LegacyScheduleRecord;
+}
+/** Deletes one currently active reminder. */
+export interface ScheduleDeleteChange {
+    readonly version: 1;
+    readonly operation: 'delete';
+    readonly id: ScheduleId;
+}
+/** Records that one active one-shot reminder entered the durable dispatch history. */
+export interface OneShotScheduleDispatchChange {
+    readonly version: 1;
+    readonly operation: 'dispatch';
+    readonly id: ScheduleId;
+}
+/** Records one fixed-rate decision and advances directly past missed occurrences. */
+export interface EveryScheduleDispatchChange {
+    readonly version: 1;
+    readonly operation: 'dispatch';
+    readonly id: ScheduleId;
+    /** Wall-clock decision time used to select the latest due occurrence. */
+    readonly acceptedAt: string;
+}
+/** Durable dispatch shapes supported by the current rule set. */
+export type ScheduleDispatchChange = OneShotScheduleDispatchChange | EveryScheduleDispatchChange;
+/** Strict version-1 durable Schedule mutation union. */
+export type ScheduleChange = ScheduleCreateChange | ScheduleDeleteChange | ScheduleDispatchChange;
+/** Current delivery timing derived from the durable record and wall clock. */
+export type ScheduleState = 'scheduled' | 'overdue';
+/** Host-driven delivery resumes the original Session when needed. */
+export type ScheduleDeliveryMode = 'host';
+/** Complete model-facing view of one active reminder. */
+export type ScheduleView = ScheduleRecord & {
+    /** Whether the target remains in the future. */
+    readonly state: ScheduleState;
+    /** Reminder delivery never leaves the owning session. */
+    readonly deliveryMode: ScheduleDeliveryMode;
+};
+/** Stable error returned for an empty, over-long, or untrimmed reminder prompt or title. */
+export interface InvalidPromptError {
+    readonly code: 'invalid_prompt';
+    readonly message: string;
+}
+/** Stable error returned for a missing, conflicting, or unsupported rule selector. */
+export interface InvalidSelectorError {
+    readonly code: 'invalid_selector';
+    readonly message: string;
+}
+/** Stable error returned for an invalid rule or management argument. */
+export interface InvalidRuleError {
+    readonly code: 'invalid_rule';
+    readonly message: string;
+}
+/** Stable error returned for an invalid or unsupported IANA time zone. */
+export interface InvalidTimeZoneError {
+    readonly code: 'invalid_time_zone';
+    readonly message: string;
+}
+/** Stable error returned when an absolute target is not strictly future. */
+export interface NotFutureError {
+    readonly code: 'not_future';
+    readonly message: string;
+}
+/** Stable error returned when the computed instant cannot use a four-digit UTC year. */
+export interface TimeOutOfRangeError {
+    readonly code: 'time_out_of_range';
+    readonly message: string;
+}
+/** Stable error returned when a fixed-rate rule runs more often than supported. */
+export interface FrequencyTooHighError {
+    readonly code: 'frequency_too_high';
+    readonly message: string;
+}
+/** Stable fallback that does not disclose an internal exception. */
+export interface InternalScheduleError {
+    readonly code: 'internal_error';
+    readonly message: string;
+}
+/** Stable error returned when the target Session belongs to subagent routing, which never receives reminder delivery. */
+export interface SubagentSessionError {
+    readonly code: 'subagent_session';
+    readonly message: string;
+}
+/** v1 Schedule management error union; new codes join as additional members. */
+export type ScheduleToolError = InvalidPromptError | InvalidSelectorError | InvalidRuleError | InvalidTimeZoneError | NotFutureError | TimeOutOfRangeError | FrequencyTooHighError | SubagentSessionError | InternalScheduleError;
+/** Canonical `schedule_create` value. */
+export type ScheduleCreateValue = ScheduleView | ScheduleToolError;
+/** Canonical `schedule_list` value. */
+export type ScheduleListValue = ScheduleView[] | ScheduleToolError;
+/** Successful `schedule_delete` value, including the non-mutating not-found result. */
+export type ScheduleDeleteResult = {
+    readonly id: ScheduleId;
+    readonly deleted: true;
+} | {
+    readonly id: ScheduleId;
+    readonly deleted: false;
+    readonly code: 'schedule_not_found';
+};
+/** Canonical `schedule_delete` value. */
+export type ScheduleDeleteValue = ScheduleDeleteResult | ScheduleToolError;
+declare module '@qilin-agent/workspace/types' {
+    interface SessionActivityKindMap {
+        /** A scheduled follow-up for this session is still active. */
+        schedule: true;
+    }
+}
+declare module '@qilin-agent/session/types' {
+    interface SessionEventMap {
+        /**
+         * Versioned Schedule mutation. The owning package validates the complete
+         * session-local transition stream before accepting a candidate event.
+         */
+        'schedule/change': ScheduleChange;
+    }
+}
+/** Reminder creation selector, shared by the model consumer and Host service. */
+export interface ScheduleCreateRequest {
+    /** Non-empty reminder text. */
+    prompt: string;
+    /** Required task name of at most 120 characters, non-empty after trimming; names the card, detail heading, and task lists. */
+    title: string;
+    /** Relative one-shot delay in seconds. */
+    after_seconds?: number;
+    /** Absolute one-shot target. */
+    at?: AtInput;
+    /** Fixed recurrence interval in seconds. */
+    every_seconds?: number;
+    /** Daily wall-clock time in an explicit IANA zone. */
+    daily?: DailyInput;
+    /** Weekly wall-clock time and explicit ISO weekday set in an IANA zone. */
+    weekly?: WeeklyInput;
+    /** Five-field cron expression evaluated in an explicit IANA zone. */
+    cron?: CronInput;
+}
+/** Session-scoped task list, without Agent activation. */
+export interface ScheduleListRequest {
+    /** Original Session binding. */
+    sessionId: SessionId;
+}
+/** Delete request identifying a task within its original Session binding. */
+export interface ScheduleDeleteRequest extends ScheduleListRequest {
+    /** Task to remove. */
+    id: ScheduleId;
+}
+/** Timing-only edit; it may select a different recurrence kind than the stored record, and one-shot targets use an absolute `at`. */
+export type ScheduleTimingChange = {
+    readonly kind: 'at';
+    readonly at: AtInput;
+} | {
+    readonly kind: 'every';
+    readonly every_seconds: number;
+} | {
+    readonly kind: 'daily';
+    readonly daily: DailyInput;
+} | {
+    readonly kind: 'weekly';
+    readonly weekly: WeeklyInput;
+} | {
+    readonly kind: 'cron';
+    readonly cron: CronInput;
+};
+/** Replacement task name and instruction carried by one compare-and-update request. */
+export interface ScheduleUpdateContent {
+    /** Task name of at most 120 characters, non-empty after trimming; omitted keeps the stored name. */
+    readonly title?: string;
+    /** Reminder instruction, non-empty after trimming; omitted keeps the stored instruction. */
+    readonly prompt?: string;
+}
+/** Compare-and-update request within the original Session binding. */
+export interface ScheduleUpdateRequest extends ScheduleDeleteRequest, ScheduleUpdateContent {
+    /** Complete record observed when editing began, including the committed target. */
+    readonly expected: ScheduleRecord;
+    /** New timing; its kind may differ from the stored record's kind, and an omitted value keeps the committed target. */
+    readonly change?: ScheduleTimingChange;
+}
+/** Non-mutating compare-and-update outcome: unknown, inactive, or changed since the read. */
+export interface ScheduleUpdateMiss {
+    readonly id: ScheduleId;
+    readonly updated: false;
+    readonly code: 'schedule_not_found' | 'schedule_ended' | 'schedule_conflict';
+}
+/** Successful current record, non-mutating lookup/conflict failure, or invalid name/instruction/timing. */
+export type ScheduleUpdateResult = {
+    readonly id: ScheduleId;
+    readonly updated: boolean;
+    readonly record: ScheduleRecord;
+} | ScheduleUpdateMiss | ScheduleToolError;
+/** Canonical `schedule_update` value: the committed record as a view, or the non-mutating lookup/conflict result. */
+export type ScheduleUpdateValue = ScheduleView | ScheduleUpdateMiss | ScheduleToolError;
+/** Explicitly bounded saved-delivery query within one Session binding. */
+export interface ScheduleDeliveryHistoryRequest extends ScheduleDeleteRequest {
+    /** Required safe-integer page size from 1 through 100. */
+    limit: number;
+    /** Message identity of the oldest entry in the previous page; excluded from this page. */
+    before?: MessageId;
+}
+/** Configured limits applied when appending one task's delivery receipt. */
+export interface DeliveryRetentionBounds {
+    /** Retained window in days, measured back from the acknowledgment being appended. */
+    readonly days: number;
+    /** Maximum retained records per task; the newest survive. */
+    readonly records: number;
+}
+/** Newest-first saved deliveries, or a non-mutating task/cursor lookup failure. */
+export type ScheduleDeliveryHistoryResult = {
+    readonly id: ScheduleId;
+    readonly records: ScheduleDeliveryRecord[];
+    /** Whether earlier delivery records may be unavailable; missing receipts are never reconstructed. */
+    readonly earlierRecordsUnavailable: boolean;
+    /** True only after an append removed saved records; absent legacy evidence is false. */
+    readonly earlierRecordsPruned: boolean;
+    /** Current Host retention configuration, also used by the delivery writer. */
+    readonly retention: DeliveryRetentionBounds;
+    /** Oldest returned message identity, present only when older saved records remain. */
+    readonly nextBefore?: MessageId;
+} | {
+    readonly id: ScheduleId;
+    readonly code: 'schedule_not_found' | 'delivery_cursor_not_found';
+};
+declare module '@qilin-agent/kylin' {
+    interface Events {
+        /** Durable task set changed; clients refetch global task and Session-active catalogs.
+         * @mode emit
+         */
+        'schedule/changed'(): void;
+    }
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.js

@@ -0,0 +1,6 @@
+/**
+ * Durable and model-facing Schedule value types.
+ * @module @qilin-agent/schedule
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/lib/types/update.d.ts

@@ -0,0 +1,26 @@
+import type { ScheduleRecord, ScheduleTimingChange, ScheduleUpdateContent, ScheduleUpdateResult } from './types.ts';
+/**
+ * Title one update must either keep or replace.
+ *
+ * A decoded record always carries a stored title. A record value without a
+ * valid one is refused with the durable decode error instead of deriving a name.
+ * @param record - Current active Host record.
+ * @returns The stored title; a missing, blank, untrimmed, or over-long title throws ScheduleLogError.
+ */
+export declare function retainedTitle(record: ScheduleRecord): string;
+/**
+ * Compare the complete observed record and resolve one name, instruction, and timing update
+ * using a single queue-time sample.
+ *
+ * An omitted change, name, or instruction keeps the stored value. A supplied name or
+ * instruction never re-anchors the schedule on its own; an equivalent normalized timing
+ * change keeps the committed target too.
+ * @param current - Current active Host record.
+ * @param expected - Untrusted complete record observed by the caller.
+ * @param change - Strict timing selector, whose kind may differ from the current record's kind, or undefined to keep timing.
+ * @param now - Single wall-clock sample from the accepted FIFO slot.
+ * @param content - Untrusted replacement name and instruction; each omitted field keeps its stored value.
+ * @returns Current/new record or a bounded input/conflict result; unrelated failures throw.
+ */
+export declare function resolveScheduleUpdate(current: ScheduleRecord, expected: ScheduleRecord, change: ScheduleTimingChange | undefined, now: number, content?: ScheduleUpdateContent): ScheduleUpdateResult;
+//# sourceMappingURL=update.d.ts.map

package/lib/types/update.js

@@ -0,0 +1,164 @@
+/** Optimistic name, instruction, and timing updates of retained Host tasks, without Session mutations. */
+import { isDeepStrictEqual } from 'node:util';
+import { canonicalizeCronExpression, canonicalizeTimeZone, createAtScheduleRecord, createCronScheduleRecord, createDailyScheduleRecord, createEveryScheduleRecord, createWeeklyScheduleRecord, decodeScheduleRecord, decodeStoredTitle, parseAtInput, parseCronInput, parseDailyInput, parseWeeklyInput, ScheduleInputError, ScheduleLogError, scheduleTitle, } from "./domain.js";
+/** Name the exact selector property each timing kind must carry, or undefined for an unknown discriminant. */
+function timingSelector(kind) {
+    switch (kind) {
+        case 'at': return 'at';
+        case 'every': return 'every_seconds';
+        case 'daily': return 'daily';
+        case 'weekly': return 'weekly';
+        case 'cron': return 'cron';
+        default: return undefined;
+    }
+}
+/**
+ * Validate the exact timing selector keys received over RPC.
+ * @param value - Untrusted timing change; the wire can carry a null, array, or foreign discriminant.
+ * @returns The same value narrowed to the closed timing-change union.
+ */
+function validateChange(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new ScheduleInputError('invalid_rule', 'Timing change must be an object with exactly one supported timing selector.');
+    }
+    const change = value;
+    const selector = timingSelector(change.kind);
+    const keys = Object.keys(change);
+    if (selector === undefined || keys.length !== 2 || !keys.includes('kind') || !keys.includes(selector)) {
+        throw new ScheduleInputError('invalid_rule', 'Timing change must contain exactly kind and its matching timing selector.');
+    }
+    return change;
+}
+/**
+ * Validate a replacement instruction received over RPC.
+ * @param prompt - Untrusted instruction value; the wire can carry a non-string.
+ * @returns The trimmed instruction; an invalid instruction throws ScheduleInputError.
+ */
+function schedulePrompt(prompt) {
+    if (typeof prompt !== 'string' || prompt.trim().length === 0) {
+        throw new ScheduleInputError('invalid_prompt', 'prompt must be non-empty after trimming.');
+    }
+    return prompt.trim();
+}
+/**
+ * Title one update must either keep or replace.
+ *
+ * A decoded record always carries a stored title. A record value without a
+ * valid one is refused with the durable decode error instead of deriving a name.
+ * @param record - Current active Host record.
+ * @returns The stored title; a missing, blank, untrimmed, or over-long title throws ScheduleLogError.
+ */
+export function retainedTitle(record) {
+    return decodeStoredTitle(record.title);
+}
+/**
+ * Apply a replacement name and instruction to a stored record without touching its rule.
+ * @param current - Current active record holding the committed target.
+ * @param title - Validated replacement or retained name.
+ * @param prompt - Validated replacement or retained instruction.
+ * @returns The same record when both are unchanged, otherwise a frozen copy with the new content.
+ */
+function withContent(current, title, prompt) {
+    return title === current.title && prompt === current.prompt
+        ? current
+        : Object.freeze({ ...current, title, prompt });
+}
+/**
+ * Resolve the requested rule against the current record after the complete expected record has matched.
+ *
+ * The change kind may differ from the current record's kind; a change whose normalized
+ * timing equals the current rule keeps the committed target and only applies the supplied
+ * name and instruction, while any other change recomputes the target exactly as creation
+ * computes it from the same now.
+ */
+function changedRecord(current, title, prompt, value, now) {
+    if (value === undefined)
+        return withContent(current, title, prompt);
+    const change = validateChange(value);
+    switch (change.kind) {
+        case 'at':
+            if ((current.kind === 'after' || current.kind === 'at')
+                && parseAtInput(change.at) === Date.parse(current.scheduledAt))
+                return withContent(current, title, prompt);
+            return createAtScheduleRecord(current.id, prompt, change.at, now, title);
+        case 'every':
+            if (current.kind === 'every' && change.every_seconds === current.everySeconds) {
+                return withContent(current, title, prompt);
+            }
+            return createEveryScheduleRecord(current.id, prompt, change.every_seconds, now, title);
+        case 'daily': {
+            if (current.kind === 'daily') {
+                const normalized = parseDailyInput(change.daily);
+                if (normalized.time === current.time
+                    && normalized.timeZone === canonicalizeTimeZone(current.timeZone))
+                    return withContent(current, title, prompt);
+            }
+            return createDailyScheduleRecord(current.id, prompt, change.daily, now, title);
+        }
+        case 'weekly': {
+            if (current.kind === 'weekly') {
+                const normalized = parseWeeklyInput(change.weekly);
+                if (normalized.time === current.time
+                    && normalized.timeZone === canonicalizeTimeZone(current.timeZone)
+                    && isDeepStrictEqual(normalized.weekdays, current.weekdays))
+                    return withContent(current, title, prompt);
+            }
+            return createWeeklyScheduleRecord(current.id, prompt, change.weekly, now, title);
+        }
+        case 'cron': {
+            if (current.kind === 'cron') {
+                const normalized = parseCronInput(change.cron);
+                if (normalized.expression === canonicalizeCronExpression(current.expression)
+                    && normalized.timeZone === canonicalizeTimeZone(current.timeZone))
+                    return withContent(current, title, prompt);
+            }
+            return createCronScheduleRecord(current.id, prompt, change.cron, now, title);
+        }
+        /* v8 ignore next 4 -- validateChange rejects unknown discriminants before this closed union switch. */
+        default: {
+            const unreachable = change;
+            throw new Error(`Unknown validated timing change: ${String(unreachable)}`);
+        }
+    }
+}
+/**
+ * Compare the complete observed record and resolve one name, instruction, and timing update
+ * using a single queue-time sample.
+ *
+ * An omitted change, name, or instruction keeps the stored value. A supplied name or
+ * instruction never re-anchors the schedule on its own; an equivalent normalized timing
+ * change keeps the committed target too.
+ * @param current - Current active Host record.
+ * @param expected - Untrusted complete record observed by the caller.
+ * @param change - Strict timing selector, whose kind may differ from the current record's kind, or undefined to keep timing.
+ * @param now - Single wall-clock sample from the accepted FIFO slot.
+ * @param content - Untrusted replacement name and instruction; each omitted field keeps its stored value.
+ * @returns Current/new record or a bounded input/conflict result; unrelated failures throw.
+ */
+export function resolveScheduleUpdate(current, expected, change, now, content = {}) {
+    let decoded;
+    try {
+        decoded = decodeScheduleRecord(expected);
+    }
+    catch (error) {
+        if (!(error instanceof ScheduleLogError))
+            throw error;
+        return { code: 'invalid_rule', message: 'expected must be a complete valid Schedule record.' };
+    }
+    if (!isDeepStrictEqual(current, decoded)) {
+        return { id: current.id, updated: false, code: 'schedule_conflict' };
+    }
+    try {
+        const retained = retainedTitle(current);
+        const title = content.title === undefined ? retained : scheduleTitle(content.title);
+        const prompt = content.prompt === undefined ? current.prompt : schedulePrompt(content.prompt);
+        const record = changedRecord(current, title, prompt, change, now);
+        return { id: current.id, updated: record !== current, record };
+    }
+    catch (error) {
+        if (!(error instanceof ScheduleInputError))
+            throw error;
+        return { code: error.code, message: error.message };
+    }
+}
+//# sourceMappingURL=update.js.map