@sentry/junior 0.233.0 → 0.235.0

package/dist/types-Du-HbEun.js

@@ -0,0 +1,621 @@
+import { z } from "zod";
+import { actorUserIdSchema, destinationVisibilitySchema, eventMatchSchema, eventTypeSchema, slackDestinationSchema, taskOutcomeSchema } from "@sentry/junior-plugin-api";
+//#region src/chat/task-outcomes-schema.ts
+const taskMessageDestinationInputSchema = z.enum(["current_conversation", "task_creator"]).describe("Where to send the message. Use current_conversation for posts, digests, summaries, and channel reminders. Use task_creator only when the user asks for a direct reminder or notification.");
+/** Input accepted by task authoring tools before a user becomes a DM Destination. */
+const taskOutcomeInputSchema = z.object({
+	action: z.literal("send_message"),
+	destination: taskMessageDestinationInputSchema
+}).strict();
+/** Validate the persisted Slack creator identity for an event automation. */
+const eventAutomationPrincipalSchema = z.object({
+	slackUserId: actorUserIdSchema,
+	fullName: z.string().optional(),
+	userName: z.string().optional()
+}).strict();
+/** Validate one persisted event-automation selector and its presentation metadata. */
+const eventAutomationTriggerSchema = z.object({
+	events: z.array(eventTypeSchema).min(1),
+	label: z.string().min(1),
+	match: eventMatchSchema.optional(),
+	namespace: z.string().min(1),
+	identifier: z.string().min(1).max(300),
+	resourceType: z.string().min(1)
+}).strict();
+/** Event automations target a Slack channel or DM, never a message thread. */
+const eventAutomationDestinationSchema = slackDestinationSchema.omit({ threadTs: true });
+const eventAutomationOutcomeSchema = taskOutcomeSchema.extend({ destination: eventAutomationDestinationSchema });
+/** Validate one persisted event automation. */
+const eventAutomationSchema = z.object({
+	id: z.string().min(1),
+	createdAtMs: z.number().finite(),
+	createdBy: eventAutomationPrincipalSchema,
+	credentialMode: z.enum(["system", "creator"]),
+	destination: eventAutomationDestinationSchema,
+	destinationVisibility: destinationVisibilitySchema,
+	/** Explicit visible effects after successful work. An empty list is silent. */
+	outcomes: z.array(eventAutomationOutcomeSchema).max(5),
+	task: z.object({ text: z.string().min(1) }).strict(),
+	trigger: eventAutomationTriggerSchema
+}).strict();
+//#endregion
+//#region src/chat/scheduled-automations/cadence.ts
+const FORMATTERS = /* @__PURE__ */ new Map();
+function getFormatter(timezone) {
+	const existing = FORMATTERS.get(timezone);
+	if (existing) return existing;
+	const formatter = new Intl.DateTimeFormat("en-US", {
+		timeZone: timezone,
+		hour12: false,
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit"
+	});
+	FORMATTERS.set(timezone, formatter);
+	return formatter;
+}
+function normalizeHour(hour) {
+	return hour === 24 ? 0 : hour;
+}
+function getLocalDateWeekday(date) {
+	return new Date(Date.UTC(date.year, date.month - 1, date.day)).getUTCDay();
+}
+function getWeekStart(date) {
+	return addDays(date, -((getLocalDateWeekday(date) + 6) % 7));
+}
+/** Resolve a UTC timestamp into calendar parts for a named time zone. */
+function getZonedDateTimeParts(timestampMs, timezone) {
+	const parts = getFormatter(timezone).formatToParts(new Date(timestampMs));
+	const values = new Map(parts.map((part) => [part.type, part.value]));
+	const year = Number(values.get("year"));
+	const month = Number(values.get("month"));
+	const day = Number(values.get("day"));
+	return {
+		year,
+		month,
+		day,
+		hour: normalizeHour(Number(values.get("hour"))),
+		minute: Number(values.get("minute")),
+		second: Number(values.get("second")),
+		weekday: getLocalDateWeekday({
+			year,
+			month,
+			day
+		})
+	};
+}
+function getTimeZoneOffsetMs(timestampMs, timezone) {
+	const parts = getZonedDateTimeParts(timestampMs, timezone);
+	return Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second) - timestampMs;
+}
+function localDateTimeToTimestampMs(args) {
+	const localAsUtcMs = Date.UTC(args.date.year, args.date.month - 1, args.date.day, args.time.hour, args.time.minute, 0);
+	const offsets = /* @__PURE__ */ new Set();
+	for (const probeDeltaMs of [
+		-1296e5,
+		-432e5,
+		0,
+		432e5,
+		1296e5
+	]) offsets.add(getTimeZoneOffsetMs(localAsUtcMs + probeDeltaMs, args.timezone));
+	const matches = [...offsets].map((offsetMs) => localAsUtcMs - offsetMs).filter((timestampMs) => {
+		const parts = getZonedDateTimeParts(timestampMs, args.timezone);
+		return parts.year === args.date.year && parts.month === args.date.month && parts.day === args.date.day && parts.hour === args.time.hour && parts.minute === args.time.minute;
+	});
+	if (matches.length === 0) return;
+	return Math.min(...matches);
+}
+/** Resolve local time, rejecting DST gaps and choosing the earlier instant in a fold. */
+function resolveLocalScheduleAtMs(args) {
+	const date = parseLocalDate(args.date);
+	if (!date) return;
+	return localDateTimeToTimestampMs({
+		date,
+		time: args.time,
+		timezone: args.timezone
+	});
+}
+function daysBetween(left, right) {
+	return Math.floor((Date.UTC(right.year, right.month - 1, right.day) - Date.UTC(left.year, left.month - 1, left.day)) / 864e5);
+}
+function weeklyRecurrenceMatchesDate(date, start, recurrence) {
+	if (compareDate(date, start) < 0) return false;
+	return normalizeWeekdays(recurrence.weekdays).includes(getLocalDateWeekday(date)) && Math.floor(daysBetween(getWeekStart(start), getWeekStart(date)) / 7) % recurrence.interval === 0;
+}
+function greatestCommonDivisor(left, right) {
+	let a = Math.abs(left);
+	let b = Math.abs(right);
+	while (b !== 0) [a, b] = [b, a % b];
+	return a;
+}
+function findNextRunAtMs(args) {
+	const start = parseLocalDate(args.recurrence.startDate);
+	const interval = args.recurrence.interval;
+	if (!start || !Number.isInteger(interval) || interval <= 0) return;
+	const searchFrom = compareDate(args.searchFrom, start) < 0 ? start : args.searchFrom;
+	if (args.recurrence.frequency === "daily") {
+		const offsetDays = daysBetween(start, searchFrom);
+		let candidateDate = addDays(start, Math.ceil(offsetDays / interval) * interval);
+		const gregorianCycleDays = 146097;
+		const candidateCount = gregorianCycleDays / greatestCommonDivisor(gregorianCycleDays, interval);
+		for (let attempts = 0; attempts < candidateCount; attempts += 1) {
+			const candidate = buildCandidate({
+				date: candidateDate,
+				recurrence: args.recurrence,
+				timezone: args.timezone
+			});
+			if (candidate !== void 0 && candidate > args.afterMs) return candidate;
+			candidateDate = addDays(candidateDate, interval);
+		}
+		return;
+	}
+	if (args.recurrence.frequency === "weekly") {
+		if (normalizeWeekdays(args.recurrence.weekdays).length === 0) return;
+		let candidateDate = searchFrom;
+		const gregorianCycleDays = 146097;
+		const cadenceDays = interval * 7;
+		const searchDays = gregorianCycleDays * cadenceDays / greatestCommonDivisor(gregorianCycleDays, cadenceDays);
+		for (let attempts = 0; attempts < searchDays; attempts += 1) {
+			if (weeklyRecurrenceMatchesDate(candidateDate, start, args.recurrence)) {
+				const candidate = buildCandidate({
+					date: candidateDate,
+					recurrence: args.recurrence,
+					timezone: args.timezone
+				});
+				if (candidate !== void 0 && candidate > args.afterMs) return candidate;
+			}
+			candidateDate = addDays(candidateDate, 1);
+		}
+		return;
+	}
+	if (args.recurrence.frequency === "monthly") {
+		const startMonth = start.year * 12 + start.month - 1;
+		const searchMonth = searchFrom.year * 12 + searchFrom.month - 1;
+		let candidateMonth = startMonth + Math.ceil((searchMonth - startMonth) / interval) * interval;
+		const gregorianCycleMonths = 4800;
+		const candidateCount = gregorianCycleMonths / greatestCommonDivisor(gregorianCycleMonths, interval);
+		for (let attempts = 0; attempts < candidateCount; attempts += 1) {
+			const candidateDate = {
+				year: Math.floor(candidateMonth / 12),
+				month: candidateMonth % 12 + 1,
+				day: args.recurrence.dayOfMonth ?? 0
+			};
+			if (compareDate(candidateDate, searchFrom) >= 0) {
+				const candidate = buildCandidate({
+					date: candidateDate,
+					recurrence: args.recurrence,
+					timezone: args.timezone
+				});
+				if (candidate !== void 0 && candidate > args.afterMs) return candidate;
+			}
+			candidateMonth += interval;
+		}
+		return;
+	}
+	let candidateYear = start.year + Math.ceil((searchFrom.year - start.year) / interval) * interval;
+	const candidateCount = 400 / greatestCommonDivisor(400, interval);
+	for (let attempts = 0; attempts < candidateCount; attempts += 1) {
+		const candidateDate = {
+			year: candidateYear,
+			month: args.recurrence.month ?? 0,
+			day: args.recurrence.dayOfMonth ?? 0
+		};
+		if (compareDate(candidateDate, searchFrom) >= 0) {
+			const candidate = buildCandidate({
+				date: candidateDate,
+				recurrence: args.recurrence,
+				timezone: args.timezone
+			});
+			if (candidate !== void 0 && candidate > args.afterMs) return candidate;
+		}
+		candidateYear += interval;
+	}
+}
+/** Compute the first recurring calendar occurrence strictly after a timestamp. */
+function getFirstRunAtMs(args) {
+	return findNextRunAtMs({
+		...args,
+		searchFrom: getLocalDate(args.afterMs, args.timezone)
+	});
+}
+function compareDate(left, right) {
+	return Date.UTC(left.year, left.month - 1, left.day) - Date.UTC(right.year, right.month - 1, right.day);
+}
+function addDays(date, days) {
+	const next = new Date(Date.UTC(date.year, date.month - 1, date.day + days));
+	return {
+		year: next.getUTCFullYear(),
+		month: next.getUTCMonth() + 1,
+		day: next.getUTCDate()
+	};
+}
+function daysInMonth(year, month) {
+	return new Date(Date.UTC(year, month, 0)).getUTCDate();
+}
+function parseLocalDate(value) {
+	const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+	if (!match) return;
+	const year = Number(match[1]);
+	const month = Number(match[2]);
+	const day = Number(match[3]);
+	if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day) || month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month)) return;
+	return {
+		year,
+		month,
+		day
+	};
+}
+function getLocalDate(timestampMs, timezone) {
+	const parts = getZonedDateTimeParts(timestampMs, timezone);
+	return {
+		year: parts.year,
+		month: parts.month,
+		day: parts.day
+	};
+}
+function normalizeWeekdays(values) {
+	return [...new Set((values ?? []).filter((value) => value >= 0 && value <= 6))].sort((a, b) => a - b);
+}
+function buildCandidate(args) {
+	return localDateTimeToTimestampMs({
+		date: args.date,
+		time: args.recurrence.time,
+		timezone: args.timezone
+	});
+}
+/** Return the next fire time after a completed run, when the task recurs. */
+function getNextRunAtMs(task, scheduledForMs, afterMs = scheduledForMs) {
+	if (task.schedule.kind !== "recurring") return;
+	const recurrence = task.schedule.recurrence;
+	if (!recurrence || !Number.isFinite(recurrence.interval) || recurrence.interval <= 0) return;
+	const timezone = task.schedule.timezone;
+	const afterDate = getLocalDate(afterMs, timezone);
+	const nextScheduledDate = addDays(getLocalDate(scheduledForMs, timezone), 1);
+	return findNextRunAtMs({
+		afterMs,
+		recurrence,
+		searchFrom: compareDate(afterDate, nextScheduledDate) < 0 ? nextScheduledDate : afterDate,
+		timezone
+	});
+}
+//#endregion
+//#region src/chat/scheduled-automations/schedule-intent.ts
+/**
+* Owns model-facing schedule intent and materializes it against the trusted
+* server clock into the canonical schedule persisted by core.
+*/
+const localDateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Use a local date in YYYY-MM-DD format.");
+const localTimeSchema = z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "Use local time in HH:MM format.");
+const timezoneSchema = z.string().min(1).max(80).describe("IANA timezone, for example America/Los_Angeles. Omit or use null for the scheduler default.").nullable().optional();
+const weekdaySchema = z.enum([
+	"sunday",
+	"monday",
+	"tuesday",
+	"wednesday",
+	"thursday",
+	"friday",
+	"saturday"
+]);
+const oneOffScheduleIntentSchema = z.object({
+	kind: z.literal("one_off").describe("A schedule that runs once."),
+	timezone: timezoneSchema,
+	timing: z.discriminatedUnion("type", [z.object({
+		type: z.literal("after").describe("Run after a relative delay from the server clock."),
+		value: z.number().int().positive().max(1e5),
+		unit: z.enum([
+			"second",
+			"minute",
+			"hour",
+			"day",
+			"week"
+		])
+	}).strict(), z.object({
+		type: z.literal("at").describe("Run at an explicit local calendar date and time."),
+		date: localDateSchema.describe("Requested local calendar date in YYYY-MM-DD format."),
+		time: localTimeSchema.describe("Requested local wall-clock time in HH:MM format.")
+	}).strict()]).describe("Relative delay or explicit local time for the one-off run.")
+}).strict();
+const recurringScheduleIntentSchema = z.object({
+	kind: z.literal("recurring").describe("A repeating calendar schedule."),
+	frequency: z.enum([
+		"daily",
+		"weekly",
+		"monthly",
+		"yearly"
+	]).describe("Recurring tasks can run at most once per day."),
+	interval: z.number().int().positive().max(365).describe("Repeat every N frequency units. Defaults to 1.").nullable().optional(),
+	time: localTimeSchema.describe("Local wall-clock time for each occurrence in HH:MM format."),
+	weekdays: z.array(weekdaySchema).min(1).max(7).describe("Required for weekly schedules.").nullable().optional(),
+	dayOfMonth: z.number().int().min(1).max(31).describe("Required for monthly and yearly schedules.").nullable().optional(),
+	month: z.number().int().min(1).max(12).describe("Required for yearly schedules, where January is 1.").nullable().optional(),
+	startDate: localDateSchema.describe("Optional local calendar date that anchors the recurrence. Omit to start with the next matching occurrence.").nullable().optional(),
+	timezone: timezoneSchema
+}).strict().superRefine((schedule, context) => {
+	if (schedule.frequency === "weekly" && schedule.weekdays == null) context.addIssue({
+		code: "custom",
+		message: "Weekly schedules require weekdays.",
+		path: ["weekdays"]
+	});
+	if ((schedule.frequency === "monthly" || schedule.frequency === "yearly") && schedule.dayOfMonth == null) context.addIssue({
+		code: "custom",
+		message: `${schedule.frequency} schedules require dayOfMonth.`,
+		path: ["dayOfMonth"]
+	});
+	if (schedule.frequency === "yearly" && schedule.month == null) context.addIssue({
+		code: "custom",
+		message: "Yearly schedules require month.",
+		path: ["month"]
+	});
+	if (schedule.frequency !== "weekly" && schedule.weekdays != null) context.addIssue({
+		code: "custom",
+		message: "weekdays applies only to weekly schedules.",
+		path: ["weekdays"]
+	});
+	if (schedule.frequency !== "monthly" && schedule.frequency !== "yearly" && schedule.dayOfMonth != null) context.addIssue({
+		code: "custom",
+		message: "dayOfMonth applies only to monthly or yearly schedules.",
+		path: ["dayOfMonth"]
+	});
+	if (schedule.frequency !== "yearly" && schedule.month != null) context.addIssue({
+		code: "custom",
+		message: "month applies only to yearly schedules.",
+		path: ["month"]
+	});
+});
+const scheduleIntentSchema = z.union([oneOffScheduleIntentSchema, recurringScheduleIntentSchema]);
+const WEEKDAY_INDEX = {
+	sunday: 0,
+	monday: 1,
+	tuesday: 2,
+	wednesday: 3,
+	thursday: 4,
+	friday: 5,
+	saturday: 6
+};
+const DURATION_MS = {
+	second: 1e3,
+	minute: 6e4,
+	hour: 36e5,
+	day: 864e5,
+	week: 6048e5
+};
+function parseLocalTime(value) {
+	const [hour, minute] = value.split(":").map(Number);
+	return {
+		hour,
+		minute
+	};
+}
+function localDateAt(timestampMs, timezone) {
+	const parts = getZonedDateTimeParts(timestampMs, timezone);
+	return [
+		parts.year,
+		parts.month,
+		parts.day
+	].map((value, index) => index === 0 ? String(value).padStart(4, "0") : String(value).padStart(2, "0")).join("-");
+}
+function isValidTimeZone(timezone) {
+	try {
+		new Intl.DateTimeFormat("en-US", { timeZone: timezone }).format();
+		return true;
+	} catch {
+		return false;
+	}
+}
+function plural(value, unit) {
+	return value === 1 ? unit : `${unit}s`;
+}
+function formatWeekdays(weekdays) {
+	const labels = weekdays.map((weekday) => `${weekday[0].toUpperCase()}${weekday.slice(1)}`);
+	if (labels.length < 2) return labels[0] ?? "";
+	return `${labels.slice(0, -1).join(", ")} and ${labels.at(-1)}`;
+}
+function recurringDescription(schedule, timezone) {
+	const interval = schedule.interval ?? 1;
+	const cadenceUnit = {
+		daily: "day",
+		weekly: "week",
+		monthly: "month",
+		yearly: "year"
+	}[schedule.frequency];
+	const cadence = interval === 1 ? cadenceUnit : `${interval} ${cadenceUnit}s`;
+	let detail = "";
+	if (schedule.frequency === "weekly") detail = ` on ${formatWeekdays(schedule.weekdays)}`;
+	else if (schedule.frequency === "monthly") detail = ` on day ${schedule.dayOfMonth}`;
+	else if (schedule.frequency === "yearly") detail = ` on ${String(schedule.month).padStart(2, "0")}-${String(schedule.dayOfMonth).padStart(2, "0")}`;
+	return `Every ${cadence}${detail} at ${schedule.time} (${timezone})`;
+}
+var ScheduleIntentError = class extends Error {};
+/** Materialize model-interpreted schedule intent against the trusted server clock. */
+function compileScheduleIntent(args) {
+	const timezone = args.intent.timezone ?? args.defaultTimezone;
+	if (!isValidTimeZone(timezone)) throw new ScheduleIntentError("timezone must be a valid IANA time zone.");
+	if (args.intent.kind === "one_off") {
+		if (args.intent.timing.type === "after") return {
+			nextRunAtMs: args.nowMs + args.intent.timing.value * DURATION_MS[args.intent.timing.unit],
+			schedule: {
+				description: `In ${args.intent.timing.value} ${plural(args.intent.timing.value, args.intent.timing.unit)}`,
+				kind: "one_off",
+				timezone
+			}
+		};
+		const nextRunAtMs = resolveLocalScheduleAtMs({
+			date: args.intent.timing.date,
+			time: parseLocalTime(args.intent.timing.time),
+			timezone
+		});
+		if (nextRunAtMs === void 0) throw new ScheduleIntentError("The requested local date or time does not exist in that timezone.");
+		if (nextRunAtMs <= args.nowMs) throw new ScheduleIntentError("The requested one-off schedule must be in the future.");
+		return {
+			nextRunAtMs,
+			schedule: {
+				description: `Once on ${args.intent.timing.date} at ${args.intent.timing.time} (${timezone})`,
+				kind: "one_off",
+				timezone
+			}
+		};
+	}
+	const recurrence = {
+		frequency: args.intent.frequency,
+		interval: args.intent.interval ?? 1,
+		startDate: args.intent.startDate ?? localDateAt(args.nowMs, timezone),
+		time: parseLocalTime(args.intent.time),
+		...args.intent.frequency === "weekly" ? { weekdays: [...new Set(args.intent.weekdays.map((weekday) => WEEKDAY_INDEX[weekday]))].sort((left, right) => left - right) } : void 0,
+		...args.intent.frequency === "monthly" || args.intent.frequency === "yearly" ? { dayOfMonth: args.intent.dayOfMonth ?? void 0 } : void 0,
+		...args.intent.frequency === "yearly" ? { month: args.intent.month ?? void 0 } : void 0
+	};
+	const searchRecurrence = args.intent.startDate ? recurrence : {
+		...recurrence,
+		interval: 1
+	};
+	const nextRunAtMs = getFirstRunAtMs({
+		afterMs: args.nowMs,
+		recurrence: searchRecurrence,
+		timezone
+	});
+	if (nextRunAtMs === void 0) throw new ScheduleIntentError("The recurring schedule has no valid future occurrence.");
+	const materializedRecurrence = args.intent.startDate ? recurrence : {
+		...recurrence,
+		startDate: localDateAt(nextRunAtMs, timezone)
+	};
+	return {
+		nextRunAtMs,
+		schedule: {
+			description: recurringDescription(args.intent, timezone),
+			kind: "recurring",
+			recurrence: materializedRecurrence,
+			timezone
+		}
+	};
+}
+//#endregion
+//#region src/chat/automations/edit-schema.ts
+const automationTitleSchema = z.string().trim().min(1).max(60);
+const automationInstructionSchema = z.string().trim().min(1).max(4e3);
+const automationEditFieldsSchema = z.object({
+	title: automationTitleSchema.optional(),
+	instruction: automationInstructionSchema.optional(),
+	credentialMode: z.enum(["system", "creator"]).optional(),
+	outcomes: z.array(z.union([taskOutcomeInputSchema, taskOutcomeSchema])).max(5).optional()
+});
+const scheduledAutomationEditSchema = automationEditFieldsSchema.extend({
+	schedule: scheduleIntentSchema.optional(),
+	status: z.enum(["active", "blocked"]).optional()
+}).strict();
+const eventAutomationEditSchema = automationEditFieldsSchema.extend({ trigger: eventAutomationTriggerSchema.extend({
+	identifier: z.string().trim().min(1).max(300),
+	label: z.string().trim().min(1).max(500)
+}).optional() }).strict();
+//#endregion
+//#region src/chat/scheduled-automations/types.ts
+/** Durable scheduled-automation domain types owned by Junior core. */
+const scheduledAutomationStatusSchema = z.enum([
+	"active",
+	"blocked",
+	"paused",
+	"completed",
+	"deleted"
+]);
+const scheduledAutomationCredentialModeSchema = z.enum(["system", "creator"]);
+const scheduledRunStatusSchema = z.enum([
+	"pending",
+	"running",
+	"completed",
+	"failed",
+	"blocked",
+	"skipped"
+]);
+const scheduledAutomationPrincipalSchema = z.object({
+	slackUserId: actorUserIdSchema,
+	fullName: z.string().optional(),
+	userName: z.string().optional()
+}).strict();
+const scheduledAutomationRecurrenceSchema = z.object({
+	dayOfMonth: z.number().optional(),
+	frequency: z.enum([
+		"daily",
+		"weekly",
+		"monthly",
+		"yearly"
+	]),
+	interval: z.number(),
+	month: z.number().optional(),
+	startDate: z.string(),
+	time: z.object({
+		hour: z.number(),
+		minute: z.number()
+	}).strict(),
+	weekdays: z.array(z.number()).optional()
+}).strict();
+const scheduledAutomationScheduleSchema = z.object({
+	description: z.string(),
+	kind: z.enum(["one_off", "recurring"]),
+	recurrence: scheduledAutomationRecurrenceSchema.optional(),
+	timezone: z.string()
+}).strict();
+const scheduledAutomationExecutionActorSchema = z.object({
+	platform: z.literal("system"),
+	name: z.string()
+}).strict();
+/** Scheduled automations target a Slack conversation, never one message thread. */
+const scheduledAutomationDestinationSchema = slackDestinationSchema.omit({ threadTs: true });
+const scheduledAutomationOutcomeSchema = z.object({
+	action: z.literal("send_message"),
+	destination: scheduledAutomationDestinationSchema
+}).strict();
+/** Validate the current scheduled-automation domain shape. */
+const scheduledAutomationSchema = z.object({
+	id: z.string(),
+	conversationAccess: z.object({
+		audience: z.enum([
+			"direct",
+			"group",
+			"channel"
+		]),
+		visibility: z.enum(["private", "public"])
+	}).strict(),
+	createdAtMs: z.number(),
+	createdBy: scheduledAutomationPrincipalSchema,
+	/** Authoritative provider identity that created the task. */
+	creatorIdentityId: z.string(),
+	/** Selects system credentials or task-bound creator credential delegation. */
+	credentialMode: scheduledAutomationCredentialModeSchema,
+	destination: scheduledAutomationDestinationSchema,
+	executionActor: scheduledAutomationExecutionActorSchema.optional(),
+	lastRunAtMs: z.number().optional(),
+	nextRunAtMs: z.number().optional(),
+	originalRequest: z.string().optional(),
+	runNowAtMs: z.number().optional(),
+	schedule: scheduledAutomationScheduleSchema,
+	status: scheduledAutomationStatusSchema,
+	statusReason: z.string().optional(),
+	/** Explicit visible effects after successful work. An empty list is silent. */
+	outcomes: z.array(scheduledAutomationOutcomeSchema).max(5),
+	task: z.object({ text: z.string() }).strict(),
+	/** SQL-backed short display title generated from the task instruction. */
+	title: z.string().optional(),
+	updatedAtMs: z.number()
+}).strict();
+/** Validate the current scheduled-run domain shape. */
+const scheduledRunSchema = z.object({
+	id: z.string(),
+	attempt: z.number(),
+	claimedAtMs: z.number(),
+	completedAtMs: z.number().optional(),
+	dispatchId: z.string().optional(),
+	errorMessage: z.string().optional(),
+	resultMessageTs: z.string().optional(),
+	scheduledForMs: z.number(),
+	startedAtMs: z.number().optional(),
+	status: scheduledRunStatusSchema,
+	taskId: z.string()
+}).strict();
+const SCHEDULED_AUTOMATION_SYSTEM_ACTOR = Object.freeze({
+	platform: "system",
+	name: "scheduled-automation"
+});
+//#endregion
+export { automationTitleSchema as a, ScheduleIntentError as c, getFirstRunAtMs as d, getNextRunAtMs as f, taskOutcomeInputSchema as g, eventAutomationTriggerSchema as h, automationInstructionSchema as i, compileScheduleIntent as l, eventAutomationSchema as m, scheduledAutomationSchema as n, eventAutomationEditSchema as o, getZonedDateTimeParts as p, scheduledRunSchema as r, scheduledAutomationEditSchema as s, SCHEDULED_AUTOMATION_SYSTEM_ACTOR as t, scheduleIntentSchema as u };

package/dist/{validation-BrLB5qbC.js → validation-DAkYeKDT.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
-import { n as pluginCatalogRuntime } from "./catalog-runtime-xFtmw3oA.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-B9u_3-GW.js";
 import { isDeepStrictEqual } from "node:util";
 //#region src/chat/plugins/validation.ts
 var validation_exports = /* @__PURE__ */ __exportAll({

package/dist/{version-B2rspCmP.js → version-9CB4Z-J4.js}

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "0.233.0";
+var version = "0.235.0";
 //#endregion
 //#region src/version.ts
 /** Installed Junior package version, or `unknown` when package metadata is unavailable. */

package/dist/version.js

@@ -1,2 +1,2 @@
-import { t as JUNIOR_VERSION } from "./version-B2rspCmP.js";
+import { t as JUNIOR_VERSION } from "./version-9CB4Z-J4.js";
 export { JUNIOR_VERSION };

package/dist/{web-authorization-CVSTvY_D.js → web-authorization-Cu33voNg.js}

@@ -1,9 +1,9 @@
-import { Ht as requestConversationWork, Mt as ensureConversationWake } from "./agent-runner-BKOtZjez.js";
-import { Zt as getConversationEventStore } from "./agent-hooks-DATy_Hnt.js";
-import { n as loadTurnCheckpoint, o as failTurnRecord, s as getTurnRecord } from "./checkpoint-zkEB448J.js";
-import { w as getStateAdapter } from "./profile-C4_njQYA.js";
-import { a as getVercelConversationWorkQueue } from "./job-queue-C5JaRRcE.js";
-import { n as resolveTurnSessionRouting } from "./turn-session-routing-B2hNxu_N.js";
+import { It as ensureConversationWake, Kt as requestConversationWork } from "./agent-runner-BlDI1zV2.js";
+import { Qt as getConversationEventStore } from "./agent-hooks-DS7k0ZWY.js";
+import { n as loadTurnCheckpoint, o as failTurnRecord, s as getTurnRecord } from "./checkpoint-DLcJ5mKL.js";
+import { w as getStateAdapter } from "./profile-DZ2DUdd1.js";
+import { a as getVercelConversationWorkQueue } from "./job-queue-CY1L2YRn.js";
+import { n as resolveTurnSessionRouting } from "./turn-session-routing-Dg8GDgyc.js";
 import { z } from "zod";
 import { randomUUID } from "node:crypto";
 //#region src/chat/task-execution/authorized-turn.ts