@sentry/junior 0.128.1 → 0.129.0

package/dist/chunk-BDIEEZK7.js

@@ -0,0 +1,1470 @@
+import {
+  canRouteResourceEvents,
+  getPlugins
+} from "./chunk-QAOA4GUG.js";
+import {
+  getDb
+} from "./chunk-PQFNTLZI.js";
+import {
+  juniorEventTasks,
+  juniorSchedulerRuns,
+  juniorSchedulerTasks,
+  juniorStats
+} from "./chunk-KB2M27DL.js";
+import {
+  juniorDestinations
+} from "./chunk-VFUK3X5B.js";
+
+// src/chat/event-tasks/store.ts
+import { and, asc, desc, eq, inArray, or, sql } from "drizzle-orm";
+
+// src/chat/event-tasks/types.ts
+import {
+  destinationVisibilitySchema,
+  resourceEventTypeSchema,
+  slackActorSchema,
+  slackDestinationSchema
+} from "@sentry/junior-plugin-api";
+import { z } from "zod";
+var EVENT_TASK_IDENTIFIER_MAX_LENGTH = 300;
+var eventTaskPrincipalSchema = z.object({
+  slackUserId: slackActorSchema.shape.userId,
+  fullName: z.string().optional(),
+  userName: z.string().optional()
+}).strict();
+var eventTaskTriggerSchema = z.object({
+  events: z.array(resourceEventTypeSchema).min(1),
+  label: z.string().min(1),
+  namespace: z.string().min(1),
+  identifier: z.string().min(1).max(EVENT_TASK_IDENTIFIER_MAX_LENGTH),
+  resourceType: z.string().min(1)
+}).strict();
+var eventTaskSchema = z.object({
+  id: z.string().min(1),
+  createdAtMs: z.number().finite(),
+  createdBy: eventTaskPrincipalSchema,
+  credentialMode: z.enum(["system", "creator"]),
+  destination: slackDestinationSchema,
+  destinationVisibility: destinationVisibilitySchema,
+  task: z.object({ text: z.string().min(1) }).strict(),
+  trigger: eventTaskTriggerSchema
+}).strict();
+
+// src/chat/event-tasks/store.ts
+function parseTask(value) {
+  return eventTaskSchema.parse(value);
+}
+async function getEventTask(db, id) {
+  const rows = await db.select({ task: juniorEventTasks.task }).from(juniorEventTasks).where(eq(juniorEventTasks.id, id)).limit(1);
+  return rows[0] ? parseTask(rows[0].task) : void 0;
+}
+async function createEventTask(db, task) {
+  const parsed = eventTaskSchema.parse(task);
+  await db.insert(juniorEventTasks).values({
+    id: parsed.id,
+    teamId: parsed.destination.teamId,
+    namespace: parsed.trigger.namespace,
+    identifier: parsed.trigger.identifier,
+    createdAtMs: parsed.createdAtMs,
+    task: parsed
+  }).onConflictDoNothing();
+  return await getEventTask(db, parsed.id) ?? parsed;
+}
+async function saveEventTask(db, task) {
+  const parsed = eventTaskSchema.parse(task);
+  const rows = await db.update(juniorEventTasks).set({
+    namespace: parsed.trigger.namespace,
+    identifier: parsed.trigger.identifier,
+    task: parsed
+  }).where(eq(juniorEventTasks.id, parsed.id)).returning({ task: juniorEventTasks.task });
+  return rows[0] ? parseTask(rows[0].task) : void 0;
+}
+async function deleteEventTask(db, id) {
+  const rows = await db.delete(juniorEventTasks).where(eq(juniorEventTasks.id, id)).returning({ task: juniorEventTasks.task });
+  return rows[0] ? parseTask(rows[0].task) : void 0;
+}
+async function listEventTasksForTeam(db, teamId) {
+  const rows = await db.select({ task: juniorEventTasks.task }).from(juniorEventTasks).where(eq(juniorEventTasks.teamId, teamId)).orderBy(asc(juniorEventTasks.createdAtMs), asc(juniorEventTasks.id));
+  return rows.map((row) => parseTask(row.task));
+}
+function viewerSlackIdentities(user) {
+  return user.identities.filter(
+    (identity) => identity.provider === "slack" && Boolean(identity.providerTenantId) && Boolean(identity.providerSubjectId)
+  );
+}
+function eventTaskBelongsToUser(task, user) {
+  return viewerSlackIdentities(user).some(
+    (identity) => identity.providerTenantId === task.destination.teamId && identity.providerSubjectId === task.createdBy.slackUserId
+  );
+}
+async function listEventTasksCreatedBy(db, user, limit) {
+  const identities = viewerSlackIdentities(user);
+  const ownership = or(
+    ...identities.map(
+      (identity) => and(
+        eq(juniorEventTasks.teamId, identity.providerTenantId),
+        sql`${juniorEventTasks.task}->'createdBy'->>'slackUserId' = ${identity.providerSubjectId}`
+      )
+    )
+  );
+  if (!ownership) return [];
+  const rows = await db.select({ task: juniorEventTasks.task }).from(juniorEventTasks).where(ownership).orderBy(desc(juniorEventTasks.createdAtMs), desc(juniorEventTasks.id)).limit(limit);
+  return rows.map((row) => parseTask(row.task));
+}
+async function listPublicEventTasksForTeams(db, teamIds, limit) {
+  if (teamIds.length === 0) return [];
+  const rows = await db.select({ task: juniorEventTasks.task }).from(juniorEventTasks).innerJoin(
+    juniorDestinations,
+    and(
+      eq(juniorDestinations.provider, "slack"),
+      eq(juniorDestinations.providerTenantId, juniorEventTasks.teamId),
+      sql`${juniorDestinations.providerDestinationId} = ${juniorEventTasks.task}->'destination'->>'channelId'`
+    )
+  ).where(
+    and(
+      inArray(juniorEventTasks.teamId, teamIds),
+      eq(juniorDestinations.visibility, "public")
+    )
+  ).orderBy(desc(juniorEventTasks.createdAtMs), desc(juniorEventTasks.id)).limit(limit);
+  return rows.map((row) => parseTask(row.task));
+}
+async function findMatchingEventTasks(db, event, teamId) {
+  const rows = await db.select({ task: juniorEventTasks.task }).from(juniorEventTasks).where(
+    and(
+      eq(juniorEventTasks.teamId, teamId),
+      eq(juniorEventTasks.namespace, event.namespace),
+      eq(juniorEventTasks.identifier, event.identifier)
+    )
+  ).orderBy(asc(juniorEventTasks.createdAtMs), asc(juniorEventTasks.id));
+  return rows.map((row) => parseTask(row.task)).filter((task) => task.trigger.events.includes(event.eventType));
+}
+
+// src/stats.ts
+import { and as and2, asc as asc2, gte, lte, sql as sql2 } from "drizzle-orm";
+function utcDate(nowMs) {
+  return new Date(nowMs).toISOString().slice(0, 10);
+}
+async function incrementStat(key, options = {}) {
+  const date = utcDate(options.nowMs ?? Date.now());
+  await getDb().insert(juniorStats).values({ ...key, date, count: 1 }).onConflictDoUpdate({
+    target: [
+      juniorStats.date,
+      juniorStats.namespace,
+      juniorStats.metric,
+      juniorStats.name
+    ],
+    set: { count: sql2`${juniorStats.count} + 1` }
+  });
+}
+async function readStats(start, end) {
+  return await getDb().select().from(juniorStats).where(and2(gte(juniorStats.date, start), lte(juniorStats.date, end))).orderBy(
+    asc2(juniorStats.date),
+    asc2(juniorStats.namespace),
+    asc2(juniorStats.metric),
+    asc2(juniorStats.name)
+  );
+}
+
+// src/chat/tool-support/structured-result.ts
+import { z as z2 } from "zod";
+var juniorToolContinuationSchema = z2.object({
+  arguments: z2.record(z2.string(), z2.unknown()),
+  reason: z2.string().min(1).optional()
+}).strict();
+var juniorToolBoundContinuationSchema = juniorToolContinuationSchema.extend({
+  tool_name: z2.string().min(1)
+});
+var juniorToolOutputSchema = z2.object({
+  target: z2.string().min(1).optional(),
+  truncated: z2.boolean().optional(),
+  continuation: juniorToolContinuationSchema.optional()
+}).passthrough();
+function sortJsonValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortJsonValue);
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, sortJsonValue(item)])
+  );
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function injectContinuationToolName(details, toolName) {
+  if (!isRecord(details) || !isRecord(details.continuation)) {
+    return details;
+  }
+  return {
+    ...details,
+    continuation: juniorToolBoundContinuationSchema.parse({
+      ...details.continuation,
+      tool_name: toolName
+    })
+  };
+}
+function makeStructuredToolOutput(details, options = {}) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(sortJsonValue(details))
+      },
+      ...options.content ?? []
+    ],
+    details
+  };
+}
+
+// src/chat/tools/execution/tool-input-error.ts
+var ToolInputError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ToolInputError";
+  }
+};
+
+// src/chat/resource-events/runtime-catalog.ts
+function getResourceEventCatalog() {
+  return Object.fromEntries(
+    canRouteResourceEvents() ? getPlugins().flatMap((plugin) => {
+      const registration = plugin.resourceEvents;
+      if (!registration || registration.isEnabled?.() === false) {
+        return [];
+      }
+      return [[plugin.manifest.name, registration]];
+    }) : []
+  );
+}
+
+// src/chat/event-tasks/tool-support.ts
+import { z as z4 } from "zod";
+
+// src/chat/resource-events/catalog.ts
+import {
+  normalizeResourceEventIdentifier
+} from "@sentry/junior-plugin-api";
+import { z as z3 } from "zod";
+function enumSchema(values, unavailableMessage) {
+  if (values.length === 0) {
+    return z3.string().refine(() => false, unavailableMessage);
+  }
+  return z3.enum(values);
+}
+function eventNamespaceSchema(catalog) {
+  return enumSchema(
+    Object.keys(catalog).sort(),
+    "No resource event namespaces are enabled."
+  );
+}
+function registeredEventTypeSchema(catalog) {
+  return enumSchema(
+    [
+      ...new Set(
+        Object.values(catalog).flatMap(
+          (registration) => registration.resourceTypes.flatMap(
+            (resourceType) => resourceType.supportedEvents
+          )
+        )
+      )
+    ].sort(),
+    "No resource event types are enabled."
+  );
+}
+function registeredResourceTypeSchema(catalog) {
+  return enumSchema(
+    [
+      ...new Set(
+        Object.values(catalog).flatMap(
+          (registration) => registration.resourceTypes.map((resourceType) => resourceType.type)
+        )
+      )
+    ].sort(),
+    "No resource types are enabled."
+  );
+}
+function pluginSupportsEvent(catalog, namespace, resourceType, eventType) {
+  return catalog[namespace]?.resourceTypes.find((candidate) => candidate.type === resourceType)?.supportedEvents.includes(eventType) ?? false;
+}
+function normalizeEventIdentifier(catalog, namespace, identifier) {
+  return normalizeResourceEventIdentifier(catalog[namespace], identifier);
+}
+
+// src/chat/event-tasks/tool-support.ts
+var compactEventTaskResultSchema = z4.object({
+  id: z4.string().min(1),
+  task: z4.string().min(1),
+  namespace: z4.string().min(1),
+  identifier: z4.string().min(1),
+  resourceType: z4.string().min(1),
+  label: z4.string().min(1),
+  events: z4.array(z4.string().min(1)).min(1),
+  credentialMode: z4.enum(["system", "creator"]),
+  createdBy: eventTaskPrincipalSchema,
+  triggerAvailable: z4.boolean()
+}).strict();
+var eventTaskToolResultSchema = juniorToolOutputSchema.extend({
+  task: compactEventTaskResultSchema
+}).strict();
+var eventTaskListToolResultSchema = juniorToolOutputSchema.extend({
+  tasks: z4.array(compactEventTaskResultSchema),
+  truncated: z4.boolean()
+}).strict();
+function registeredEventTaskTriggerSchema(catalog) {
+  return z4.object({
+    namespace: eventNamespaceSchema(catalog),
+    identifier: z4.string().trim().min(1).max(EVENT_TASK_IDENTIFIER_MAX_LENGTH),
+    resourceType: registeredResourceTypeSchema(catalog),
+    label: z4.string().trim().min(1).max(500),
+    events: z4.array(registeredEventTypeSchema(catalog)).min(1)
+  }).strict();
+}
+function requireSupportedEventTaskTrigger(catalog, trigger) {
+  for (const eventType of trigger.events) {
+    if (!pluginSupportsEvent(
+      catalog,
+      trigger.namespace,
+      trigger.resourceType,
+      eventType
+    )) {
+      throw new ToolInputError(
+        `Resource type "${trigger.namespace}:${trigger.resourceType}" does not support event "${eventType}".`
+      );
+    }
+  }
+}
+function requireEventTaskSlackContext(context) {
+  if (context.source.platform !== "slack" || context.destination.platform !== "slack" || context.actor?.platform !== "slack" || context.actor.teamId !== context.source.teamId) {
+    throw new ToolInputError(
+      "Event tasks require an active Slack channel or DM and actor."
+    );
+  }
+  return {
+    actor: context.actor,
+    destination: {
+      platform: "slack",
+      teamId: context.source.teamId,
+      channelId: context.source.channelId
+    },
+    source: context.source
+  };
+}
+function eventTaskMatchesDestination(task, destination) {
+  return task.destination.teamId === destination.teamId && task.destination.channelId === destination.channelId;
+}
+async function writableEventTask(context, id) {
+  const { destination } = requireEventTaskSlackContext(context);
+  const task = await getEventTask(getDb(), id);
+  if (!task || !eventTaskMatchesDestination(task, destination)) {
+    throw new ToolInputError(
+      "Event task was not found in this Slack channel or DM."
+    );
+  }
+  return task;
+}
+function eventTaskTriggerAvailable(task, catalog) {
+  const registration = catalog[task.trigger.namespace];
+  return Boolean(
+    registration && task.trigger.events.every(
+      (eventType) => registration.resourceTypes.some(
+        (resourceType) => resourceType.supportedEvents.includes(eventType)
+      )
+    )
+  );
+}
+function compactEventTask(task, catalog) {
+  return compactEventTaskResultSchema.parse({
+    id: task.id,
+    task: task.task.text,
+    namespace: task.trigger.namespace,
+    identifier: task.trigger.identifier,
+    resourceType: task.trigger.resourceType,
+    label: task.trigger.label,
+    events: task.trigger.events,
+    credentialMode: task.credentialMode,
+    createdBy: task.createdBy,
+    triggerAvailable: eventTaskTriggerAvailable(task, catalog)
+  });
+}
+function eventTaskSuccess(task, catalog) {
+  return {
+    task: compactEventTask(task, catalog)
+  };
+}
+
+// src/chat/scheduled-tasks/store.ts
+import {
+  destinationSchema,
+  isSlackDestination,
+  slackActorSchema as slackActorSchema2
+} from "@sentry/junior-plugin-api";
+import {
+  and as and3,
+  asc as asc3,
+  desc as desc2,
+  eq as eq2,
+  inArray as inArray2,
+  isNotNull,
+  lt,
+  lte as lte2,
+  ne,
+  or as or2,
+  sql as sql3
+} from "drizzle-orm";
+import { z as z6 } from "zod";
+
+// src/chat/scheduled-tasks/cadence.ts
+var 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));
+}
+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"));
+  const hour = normalizeHour(Number(values.get("hour")));
+  const minute = Number(values.get("minute"));
+  const second = Number(values.get("second"));
+  return {
+    year,
+    month,
+    day,
+    hour,
+    minute,
+    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 [
+    -36 * 60 * 60 * 1e3,
+    -12 * 60 * 60 * 1e3,
+    0,
+    12 * 60 * 60 * 1e3,
+    36 * 60 * 60 * 1e3
+  ]) {
+    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 void 0;
+  }
+  return Math.min(...matches);
+}
+function resolveLocalScheduleAtMs(args) {
+  const date = parseLocalDate(args.date);
+  if (!date) {
+    return void 0;
+  }
+  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)) / (24 * 60 * 60 * 1e3)
+  );
+}
+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 void 0;
+  }
+  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 candidateCount2 = gregorianCycleDays / greatestCommonDivisor(gregorianCycleDays, interval);
+    for (let attempts = 0; attempts < candidateCount2; 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 void 0;
+  }
+  if (args.recurrence.frequency === "weekly") {
+    if (normalizeWeekdays(args.recurrence.weekdays).length === 0) {
+      return void 0;
+    }
+    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 void 0;
+  }
+  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 candidateCount2 = gregorianCycleMonths / greatestCommonDivisor(gregorianCycleMonths, interval);
+    for (let attempts = 0; attempts < candidateCount2; 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 void 0;
+  }
+  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;
+  }
+  return void 0;
+}
+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 void 0;
+  }
+  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 void 0;
+  }
+  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
+  });
+}
+function getNextRunAtMs(task, scheduledForMs, afterMs = scheduledForMs) {
+  if (task.schedule.kind !== "recurring") {
+    return void 0;
+  }
+  const recurrence = task.schedule.recurrence;
+  if (!recurrence || !Number.isFinite(recurrence.interval) || recurrence.interval <= 0) {
+    return void 0;
+  }
+  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
+  });
+}
+
+// src/chat/scheduled-tasks/types.ts
+import { z as z5 } from "zod";
+var scheduledTaskCredentialModeSchema = z5.enum(["system", "creator"]);
+var SCHEDULED_TASK_SYSTEM_ACTOR = Object.freeze({
+  platform: "system",
+  name: "scheduled-task"
+});
+
+// src/chat/scheduled-tasks/store.ts
+var SCHEDULER_KEY_PREFIX = "junior:scheduler";
+var SCHEDULER_RECORD_TTL_MS = 5 * 365 * 24 * 60 * 60 * 1e3;
+var SCHEDULED_RUN_TTL_MS = 90 * 24 * 60 * 60 * 1e3;
+var CLAIM_TTL_MS = 6 * 60 * 60 * 1e3;
+var PENDING_CLAIM_STALE_MS = 6e4;
+var MISSED_RUN_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var SQL_INCOMPLETE_RUN_STATUSES = ["pending", "running"];
+var slackDestinationSchema2 = destinationSchema.refine(isSlackDestination);
+var taskPrincipalSchema = z6.object({
+  slackUserId: slackActorSchema2.shape.userId,
+  fullName: z6.string().optional(),
+  userName: z6.string().optional()
+}).strict();
+var recurrenceSchema = z6.object({
+  dayOfMonth: z6.number().optional(),
+  frequency: z6.enum(["daily", "weekly", "monthly", "yearly"]),
+  interval: z6.number(),
+  month: z6.number().optional(),
+  startDate: z6.string(),
+  time: z6.object({
+    hour: z6.number(),
+    minute: z6.number()
+  }).strict(),
+  weekdays: z6.array(z6.number()).optional()
+}).strict();
+var taskScheduleSchema = z6.object({
+  description: z6.string(),
+  kind: z6.enum(["one_off", "recurring"]),
+  recurrence: recurrenceSchema.optional(),
+  timezone: z6.string()
+}).strict();
+var taskSpecSchema = z6.object({
+  text: z6.string()
+}).strict();
+var taskRecordFields = {
+  id: z6.string(),
+  conversationAccess: z6.object({
+    audience: z6.enum(["direct", "group", "channel"]),
+    visibility: z6.enum(["private", "public"])
+  }).strict(),
+  createdAtMs: z6.number(),
+  createdBy: taskPrincipalSchema,
+  creatorIdentityId: z6.string(),
+  destination: slackDestinationSchema2,
+  executionActor: z6.object({
+    platform: z6.literal("system"),
+    name: z6.string()
+  }).strict().optional(),
+  lastRunAtMs: z6.number().optional(),
+  nextRunAtMs: z6.number().optional(),
+  originalRequest: z6.string().optional(),
+  runNowAtMs: z6.number().optional(),
+  schedule: taskScheduleSchema,
+  status: z6.enum(["active", "paused", "blocked", "deleted"]),
+  statusReason: z6.string().optional(),
+  task: taskSpecSchema,
+  updatedAtMs: z6.number(),
+  version: z6.number().optional()
+};
+var taskRecordSchema = z6.object({
+  ...taskRecordFields,
+  credentialMode: scheduledTaskCredentialModeSchema
+}).strict();
+var runRecordSchema = z6.object({
+  id: z6.string(),
+  attempt: z6.number(),
+  claimedAtMs: z6.number(),
+  completedAtMs: z6.number().optional(),
+  dispatchId: z6.string().optional(),
+  errorMessage: z6.string().optional(),
+  idempotencyKey: z6.string().optional(),
+  resultMessageTs: z6.string().optional(),
+  scheduledForMs: z6.number(),
+  startedAtMs: z6.number().optional(),
+  status: z6.enum([
+    "pending",
+    "running",
+    "completed",
+    "failed",
+    "blocked",
+    "skipped"
+  ]),
+  taskId: z6.string(),
+  taskVersion: z6.number().optional()
+}).strict();
+function normalizedTaskQuery(query) {
+  return query?.trim().toLowerCase() || void 0;
+}
+function taskKey(taskId) {
+  return `${SCHEDULER_KEY_PREFIX}:task:${taskId}`;
+}
+function taskLockKey(taskId) {
+  return `${taskKey(taskId)}:lock`;
+}
+function runKey(runId) {
+  return `${SCHEDULER_KEY_PREFIX}:run:${runId}`;
+}
+function indexLockKey(indexKey) {
+  return `${indexKey}:lock`;
+}
+function buildRunId(taskId, scheduledForMs) {
+  return `${taskId}:${scheduledForMs}`;
+}
+var schedulerTaskIndexSchema = z6.array(z6.string().min(1));
+function isStalePendingRun(run, nowMs) {
+  return run?.status === "pending" && run.claimedAtMs + PENDING_CLAIM_STALE_MS <= nowMs;
+}
+function getDueRunAtMs(task, nowMs) {
+  if (typeof task.runNowAtMs === "number" && Number.isFinite(task.runNowAtMs) && task.runNowAtMs <= nowMs) {
+    return task.runNowAtMs;
+  }
+  if (typeof task.nextRunAtMs === "number" && Number.isFinite(task.nextRunAtMs) && task.nextRunAtMs <= nowMs) {
+    return task.nextRunAtMs;
+  }
+  return void 0;
+}
+function buildScheduledRun(args) {
+  return {
+    id: buildRunId(args.task.id, args.scheduledForMs),
+    attempt: 1,
+    claimedAtMs: args.claimedAtMs,
+    scheduledForMs: args.scheduledForMs,
+    status: "pending",
+    taskId: args.task.id
+  };
+}
+function buildSkippedScheduledRun(args) {
+  return {
+    ...buildScheduledRun({
+      claimedAtMs: args.completedAtMs,
+      scheduledForMs: args.scheduledForMs,
+      task: args.task
+    }),
+    completedAtMs: args.completedAtMs,
+    errorMessage: args.errorMessage,
+    status: "skipped"
+  };
+}
+function isMissedRunTooOld(args) {
+  return args.scheduledForMs + MISSED_RUN_MAX_AGE_MS < args.nowMs;
+}
+function normalizedText(value) {
+  return value?.trim().replace(/\s+/g, " ").toLowerCase() ?? "";
+}
+function taskDedupeFingerprint(task) {
+  return JSON.stringify({
+    credentialMode: task.credentialMode,
+    credentialUserId: task.credentialMode === "creator" ? task.createdBy.slackUserId : null,
+    destination: task.destination,
+    schedule: {
+      kind: task.schedule.kind,
+      oneOffAtMs: task.schedule.kind === "one_off" ? task.nextRunAtMs : null,
+      recurrence: task.schedule.recurrence ? {
+        dayOfMonth: task.schedule.recurrence.dayOfMonth ?? null,
+        frequency: task.schedule.recurrence.frequency,
+        interval: task.schedule.recurrence.interval,
+        month: task.schedule.recurrence.month ?? null,
+        startDate: task.schedule.recurrence.startDate,
+        time: task.schedule.recurrence.time,
+        weekdays: [...task.schedule.recurrence.weekdays ?? []].sort()
+      } : null,
+      timezone: task.schedule.timezone
+    },
+    task: normalizedText(task.task.text)
+  });
+}
+function isEarlierTask(left, right) {
+  return left.createdAtMs < right.createdAtMs || left.createdAtMs === right.createdAtMs && left.id < right.id;
+}
+function canFinishRun(run, startedAtMs) {
+  if (run.status === "pending") {
+    return startedAtMs === void 0;
+  }
+  return run.status === "running" && run.startedAtMs === startedAtMs;
+}
+function parseStoredTask(value) {
+  const parsed = taskRecordSchema.safeParse(parseJsonRecord(value));
+  return parsed.success ? stripLegacyTaskFields(parsed.data) : void 0;
+}
+function stripLegacyTaskFields(task) {
+  const { version: _version, ...current } = task;
+  return current;
+}
+function stripLegacyRunFields(run) {
+  const {
+    idempotencyKey: _idempotencyKey,
+    taskVersion: _taskVersion,
+    ...current
+  } = run;
+  return current;
+}
+function parseJsonRecord(value) {
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return void 0;
+    }
+  }
+  if (value && typeof value === "object") {
+    return value;
+  }
+  return void 0;
+}
+function present(value) {
+  return value !== void 0;
+}
+function requireStoredTask(task) {
+  const parsed = parseStoredTask(task);
+  if (!parsed) {
+    throw new Error("Scheduled task routing context is invalid.");
+  }
+  return parsed;
+}
+function parseSqlTaskRecord(value, creatorIdentityId) {
+  const record = parseJsonRecord(value);
+  const parsed = taskRecordSchema.safeParse(
+    record && creatorIdentityId ? { ...record, creatorIdentityId } : record
+  );
+  return parsed.success ? stripLegacyTaskFields(parsed.data) : void 0;
+}
+function parseSqlTaskRow(row) {
+  return parseSqlTaskRecord(row.record, row.creatorIdentityId);
+}
+function parseSqlRunRow(row) {
+  const parsed = runRecordSchema.safeParse(parseJsonRecord(row.record));
+  return parsed.success ? stripLegacyRunFields(parsed.data) : void 0;
+}
+async function withSqlLock(db, key, callback) {
+  return await db.transaction(async (tx) => {
+    await tx.execute(sql3`SELECT pg_advisory_xact_lock(hashtext(${key}))`);
+    return await callback(tx);
+  });
+}
+async function upsertSqlTask(db, task) {
+  await db.insert(juniorSchedulerTasks).values({
+    createdAtMs: task.createdAtMs,
+    creatorIdentityId: task.creatorIdentityId,
+    // TODO(v0.128.0): Remove after v0.127.x runtimes no longer read this column.
+    creatorSlackUserId: task.createdBy.slackUserId,
+    id: task.id,
+    nextRunAtMs: task.nextRunAtMs,
+    record: task,
+    runNowAtMs: task.runNowAtMs,
+    status: task.status,
+    teamId: task.destination.teamId
+  }).onConflictDoUpdate({
+    target: juniorSchedulerTasks.id,
+    set: {
+      createdAtMs: sql3`excluded.created_at_ms`,
+      creatorIdentityId: sql3`excluded.creator_identity_id`,
+      creatorSlackUserId: sql3`excluded.creator_slack_user_id`,
+      nextRunAtMs: sql3`excluded.next_run_at_ms`,
+      record: sql3`excluded.record`,
+      runNowAtMs: sql3`excluded.run_now_at_ms`,
+      status: sql3`excluded.status`,
+      teamId: sql3`excluded.team_id`
+    }
+  });
+}
+async function upsertSqlRun(db, run) {
+  await db.insert(juniorSchedulerRuns).values({
+    id: run.id,
+    record: run,
+    scheduledForMs: run.scheduledForMs,
+    status: run.status,
+    taskId: run.taskId
+  }).onConflictDoUpdate({
+    target: juniorSchedulerRuns.id,
+    set: {
+      record: sql3`excluded.record`,
+      scheduledForMs: sql3`excluded.scheduled_for_ms`,
+      status: sql3`excluded.status`,
+      taskId: sql3`excluded.task_id`
+    }
+  });
+}
+async function getTaskFromSql(db, taskId) {
+  const rows = await db.select({
+    creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
+    record: juniorSchedulerTasks.record
+  }).from(juniorSchedulerTasks).where(eq2(juniorSchedulerTasks.id, taskId)).limit(1);
+  return rows[0] ? parseSqlTaskRow(rows[0]) : void 0;
+}
+async function getRunFromSql(db, runId) {
+  const rows = await db.select({ record: juniorSchedulerRuns.record }).from(juniorSchedulerRuns).where(eq2(juniorSchedulerRuns.id, runId)).limit(1);
+  return rows[0] ? parseSqlRunRow(rows[0]) : void 0;
+}
+async function listTasksFromSql(db) {
+  const rows = await db.select({
+    creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
+    record: juniorSchedulerTasks.record
+  }).from(juniorSchedulerTasks).where(ne(juniorSchedulerTasks.status, "deleted")).orderBy(
+    asc3(juniorSchedulerTasks.createdAtMs),
+    asc3(juniorSchedulerTasks.id)
+  );
+  return rows.map(parseSqlTaskRow).filter(present);
+}
+async function listTasksCreatedByFromSql(db, input) {
+  if (input.identityIds.length === 0) return [];
+  const query = normalizedTaskQuery(input.query);
+  const tasks = [];
+  let before = input.before;
+  while (tasks.length < input.limit) {
+    const cursor = before ? or2(
+      lt(juniorSchedulerTasks.createdAtMs, before.createdAtMs),
+      and3(
+        eq2(juniorSchedulerTasks.createdAtMs, before.createdAtMs),
+        lt(juniorSchedulerTasks.id, before.id)
+      )
+    ) : void 0;
+    const search = query ? or2(
+      sql3`strpos(lower(${juniorSchedulerTasks.record}->'task'->>'text'), ${query}) > 0`,
+      sql3`strpos(lower(${juniorSchedulerTasks.record}->'schedule'->>'description'), ${query}) > 0`,
+      sql3`strpos(lower(${juniorSchedulerTasks.record}->'schedule'->>'timezone'), ${query}) > 0`,
+      sql3`strpos(lower(${juniorSchedulerTasks.status}), ${query}) > 0`
+    ) : void 0;
+    const rows = await db.select({
+      createdAtMs: juniorSchedulerTasks.createdAtMs,
+      creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
+      id: juniorSchedulerTasks.id,
+      record: juniorSchedulerTasks.record
+    }).from(juniorSchedulerTasks).where(
+      and3(
+        ne(juniorSchedulerTasks.status, "deleted"),
+        inArray2(juniorSchedulerTasks.creatorIdentityId, input.identityIds),
+        cursor,
+        search
+      )
+    ).orderBy(
+      desc2(juniorSchedulerTasks.createdAtMs),
+      desc2(juniorSchedulerTasks.id)
+    ).limit(input.limit);
+    tasks.push(...rows.map(parseSqlTaskRow).filter(present));
+    if (rows.length < input.limit) {
+      break;
+    }
+    const last = rows.at(-1);
+    before = {
+      createdAtMs: last.createdAtMs,
+      id: last.id
+    };
+  }
+  return tasks.slice(0, input.limit);
+}
+async function listTasksForTeamFromSql(db, teamId) {
+  const rows = await db.select({
+    creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
+    record: juniorSchedulerTasks.record
+  }).from(juniorSchedulerTasks).where(
+    and3(
+      eq2(juniorSchedulerTasks.teamId, teamId),
+      ne(juniorSchedulerTasks.status, "deleted")
+    )
+  ).orderBy(
+    asc3(juniorSchedulerTasks.createdAtMs),
+    asc3(juniorSchedulerTasks.id)
+  );
+  return rows.map(parseSqlTaskRow).filter(present);
+}
+async function listPublicScheduledTasksForTeams(db, teamIds, limit) {
+  if (teamIds.length === 0) return [];
+  const rows = await db.select({
+    creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
+    record: juniorSchedulerTasks.record
+  }).from(juniorSchedulerTasks).innerJoin(
+    juniorDestinations,
+    and3(
+      eq2(juniorDestinations.provider, "slack"),
+      eq2(juniorDestinations.providerTenantId, juniorSchedulerTasks.teamId),
+      sql3`${juniorDestinations.providerDestinationId} = ${juniorSchedulerTasks.record}->'destination'->>'channelId'`
+    )
+  ).where(
+    and3(
+      inArray2(juniorSchedulerTasks.teamId, teamIds),
+      ne(juniorSchedulerTasks.status, "deleted"),
+      eq2(juniorDestinations.visibility, "public")
+    )
+  ).orderBy(
+    desc2(juniorSchedulerTasks.createdAtMs),
+    desc2(juniorSchedulerTasks.id)
+  ).limit(limit);
+  return rows.map(parseSqlTaskRow).filter(present);
+}
+async function listIncompleteRunsForTasksFromSql(db, tasks) {
+  if (tasks.length === 0) {
+    return [];
+  }
+  const rows = await db.select({ record: juniorSchedulerRuns.record }).from(juniorSchedulerRuns).where(
+    and3(
+      inArray2(
+        juniorSchedulerRuns.taskId,
+        tasks.map((task) => task.id)
+      ),
+      inArray2(juniorSchedulerRuns.status, [...SQL_INCOMPLETE_RUN_STATUSES])
+    )
+  ).orderBy(
+    asc3(juniorSchedulerRuns.scheduledForMs),
+    asc3(juniorSchedulerRuns.id)
+  );
+  return rows.map(parseSqlRunRow).filter(present);
+}
+var SqlSchedulerStore = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  async createTask(task) {
+    const next = requireStoredTask(task);
+    return await withSqlLock(this.db, taskLockKey(task.id), async (db) => {
+      const current = await getTaskFromSql(db, task.id);
+      if (current) {
+        return current;
+      }
+      await this.saveTaskRecord(db, next, void 0);
+      return next;
+    });
+  }
+  async saveTask(task) {
+    const next = requireStoredTask(task);
+    await withSqlLock(this.db, taskLockKey(task.id), async (db) => {
+      const current = await getTaskFromSql(db, task.id);
+      await this.saveTaskRecord(db, next, current);
+    });
+  }
+  async saveTaskRecord(db, task, current) {
+    if (current?.status === "blocked" && task.status === "active" && typeof task.nextRunAtMs === "number" && Number.isFinite(task.nextRunAtMs)) {
+      await db.delete(juniorSchedulerRuns).where(
+        and3(
+          eq2(juniorSchedulerRuns.id, buildRunId(task.id, task.nextRunAtMs)),
+          eq2(juniorSchedulerRuns.status, "blocked")
+        )
+      );
+    }
+    await upsertSqlTask(db, task);
+  }
+  async getTask(taskId) {
+    return await getTaskFromSql(this.db, taskId);
+  }
+  async listTasks() {
+    return await listTasksFromSql(this.db);
+  }
+  async listTasksCreatedBy(input) {
+    return await listTasksCreatedByFromSql(this.db, input);
+  }
+  async listTasksForTeam(teamId) {
+    return await listTasksForTeamFromSql(this.db, teamId);
+  }
+  async claimDueRun(args) {
+    return await withSqlLock(this.db, "junior:scheduler:claim", async (db) => {
+      const rows = await db.select({
+        creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
+        record: juniorSchedulerTasks.record
+      }).from(juniorSchedulerTasks).where(
+        and3(
+          eq2(juniorSchedulerTasks.status, "active"),
+          or2(
+            and3(
+              isNotNull(juniorSchedulerTasks.runNowAtMs),
+              lte2(juniorSchedulerTasks.runNowAtMs, args.nowMs)
+            ),
+            and3(
+              isNotNull(juniorSchedulerTasks.nextRunAtMs),
+              lte2(juniorSchedulerTasks.nextRunAtMs, args.nowMs)
+            )
+          )
+        )
+      ).orderBy(
+        asc3(juniorSchedulerTasks.createdAtMs),
+        asc3(juniorSchedulerTasks.id)
+      );
+      for (const row of rows) {
+        const task = parseSqlTaskRow(row);
+        if (!task) {
+          continue;
+        }
+        const scheduledForMs = getDueRunAtMs(task, args.nowMs);
+        if (scheduledForMs === void 0) {
+          continue;
+        }
+        const runId = buildRunId(task.id, scheduledForMs);
+        const incompleteRuns = await listIncompleteRunsForTasksFromSql(db, [
+          task
+        ]);
+        const incompleteRun = incompleteRuns.find((run2) => run2.id === runId);
+        const blockingRun = incompleteRuns.find(
+          (run2) => run2.id !== runId && !isStalePendingRun(run2, args.nowMs)
+        );
+        if (blockingRun) {
+          continue;
+        }
+        if (incompleteRun) {
+          if (!isStalePendingRun(incompleteRun, args.nowMs)) {
+            continue;
+          }
+          const reclaimed = {
+            ...incompleteRun,
+            attempt: incompleteRun.attempt + 1,
+            claimedAtMs: args.nowMs
+          };
+          await upsertSqlRun(db, reclaimed);
+          return reclaimed;
+        }
+        const existingRun = await getRunFromSql(db, runId);
+        if (existingRun) {
+          continue;
+        }
+        if (isMissedRunTooOld({ nowMs: args.nowMs, scheduledForMs })) {
+          await this.skipMissedRun(db, {
+            nowMs: args.nowMs,
+            scheduledForMs,
+            task
+          });
+          continue;
+        }
+        const run = buildScheduledRun({
+          claimedAtMs: args.nowMs,
+          scheduledForMs,
+          task
+        });
+        await upsertSqlRun(db, run);
+        return run;
+      }
+      return void 0;
+    });
+  }
+  async skipMissedRun(db, args) {
+    const current = await getTaskFromSql(db, args.task.id);
+    if (!current || current.status !== "active" || getDueRunAtMs(current, args.nowMs) !== args.scheduledForMs) {
+      return;
+    }
+    const duplicateOf = await this.findStaleRecoveryCanonicalTask(db, current);
+    const errorMessage = duplicateOf ? `Duplicate stale scheduled task was skipped without dispatch. Canonical task: ${duplicateOf.id}.` : "Scheduled occurrence was more than 24 hours late and was skipped without dispatch.";
+    await upsertSqlRun(
+      db,
+      buildSkippedScheduledRun({
+        completedAtMs: args.nowMs,
+        errorMessage,
+        scheduledForMs: args.scheduledForMs,
+        task: current
+      })
+    );
+    const isRunNow = current.runNowAtMs === args.scheduledForMs;
+    let nextRunAtMs;
+    if (!duplicateOf) {
+      nextRunAtMs = isRunNow && current.nextRunAtMs !== args.scheduledForMs ? current.nextRunAtMs : current.schedule.kind === "recurring" ? getNextRunAtMs(current, args.scheduledForMs, args.nowMs) : void 0;
+    }
+    const nextStatus = nextRunAtMs ? "active" : "paused";
+    await this.saveTaskRecord(
+      db,
+      {
+        ...current,
+        nextRunAtMs,
+        runNowAtMs: isRunNow ? void 0 : current.runNowAtMs,
+        status: nextStatus,
+        statusReason: nextStatus === "paused" ? errorMessage : void 0,
+        updatedAtMs: args.nowMs
+      },
+      current
+    );
+  }
+  async findStaleRecoveryCanonicalTask(db, task) {
+    const fingerprint = taskDedupeFingerprint(task);
+    const tasks = await listTasksForTeamFromSql(db, task.destination.teamId);
+    return tasks.filter((candidate) => candidate.id !== task.id).filter(
+      (candidate) => candidate.status === "active" && isEarlierTask(candidate, task) && taskDedupeFingerprint(candidate) === fingerprint
+    ).sort((a, b) => a.createdAtMs - b.createdAtMs || a.id.localeCompare(b.id)).at(0);
+  }
+  async getRun(runId) {
+    return await getRunFromSql(this.db, runId);
+  }
+  async listIncompleteRuns() {
+    return await listIncompleteRunsForTasksFromSql(
+      this.db,
+      await this.listTasks()
+    );
+  }
+  async listIncompleteRunsForTasks(tasks) {
+    return await listIncompleteRunsForTasksFromSql(this.db, tasks);
+  }
+  async markRunDispatched(args) {
+    return await this.updateRun(
+      args.runId,
+      (run) => run.status === "pending" && run.claimedAtMs === args.claimedAtMs ? {
+        ...run,
+        dispatchId: args.dispatchId,
+        startedAtMs: args.nowMs,
+        status: "running"
+      } : void 0
+    );
+  }
+  async markRunCompleted(args) {
+    const next = await this.updateRun(
+      args.runId,
+      (run) => canFinishRun(run, args.startedAtMs) ? {
+        ...run,
+        completedAtMs: args.completedAtMs,
+        resultMessageTs: args.resultMessageTs,
+        status: "completed"
+      } : void 0
+    );
+    return next;
+  }
+  async markRunFailed(args) {
+    return await this.updateRun(
+      args.runId,
+      (run) => canFinishRun(run, args.startedAtMs) ? {
+        ...run,
+        completedAtMs: args.completedAtMs,
+        errorMessage: args.errorMessage,
+        status: "failed"
+      } : void 0
+    );
+  }
+  async markRunSkipped(args) {
+    return await this.updateRun(
+      args.runId,
+      (run) => run.status === "pending" ? {
+        ...run,
+        completedAtMs: args.completedAtMs,
+        errorMessage: args.errorMessage,
+        status: "skipped"
+      } : void 0
+    );
+  }
+  async markRunBlocked(args) {
+    return await this.updateRun(
+      args.runId,
+      (run) => canFinishRun(run, args.startedAtMs) ? {
+        ...run,
+        completedAtMs: args.completedAtMs,
+        errorMessage: args.errorMessage,
+        status: "blocked"
+      } : void 0
+    );
+  }
+  async updateTaskAfterRun(args) {
+    await withSqlLock(this.db, taskLockKey(args.run.taskId), async (db) => {
+      const current = await getTaskFromSql(db, args.run.taskId);
+      if (!current || current.status === "deleted") {
+        return;
+      }
+      const isRunNow = current.runNowAtMs === args.run.scheduledForMs;
+      if (isRunNow) {
+        let nextRunAtMs2 = current.nextRunAtMs;
+        if (args.status !== "blocked" && typeof current.nextRunAtMs === "number" && current.nextRunAtMs <= args.run.scheduledForMs) {
+          nextRunAtMs2 = getNextRunAtMs(
+            current,
+            current.nextRunAtMs,
+            args.nowMs
+          );
+        }
+        await this.saveTaskRecord(
+          db,
+          {
+            ...current,
+            lastRunAtMs: args.run.scheduledForMs,
+            nextRunAtMs: nextRunAtMs2,
+            runNowAtMs: void 0,
+            status: args.status === "blocked" ? "blocked" : nextRunAtMs2 ? current.status : "paused",
+            statusReason: args.status === "blocked" ? args.errorMessage : void 0,
+            updatedAtMs: args.nowMs
+          },
+          current
+        );
+        return;
+      }
+      if (current.status !== "active" || current.nextRunAtMs !== args.run.scheduledForMs) {
+        await this.saveTaskRecord(
+          db,
+          {
+            ...current,
+            lastRunAtMs: args.run.scheduledForMs,
+            updatedAtMs: args.nowMs
+          },
+          current
+        );
+        return;
+      }
+      const nextRunAtMs = args.status === "blocked" ? void 0 : getNextRunAtMs(current, args.run.scheduledForMs, args.nowMs);
+      await this.saveTaskRecord(
+        db,
+        {
+          ...current,
+          lastRunAtMs: args.run.scheduledForMs,
+          nextRunAtMs,
+          status: args.status === "blocked" ? "blocked" : nextRunAtMs ? "active" : "paused",
+          statusReason: args.status === "blocked" ? args.errorMessage : void 0,
+          updatedAtMs: args.nowMs
+        },
+        current
+      );
+    });
+  }
+  async updateRun(runId, update) {
+    return await withSqlLock(
+      this.db,
+      indexLockKey(runKey(runId)),
+      async (db) => {
+        const current = await getRunFromSql(db, runId);
+        if (!current) {
+          return void 0;
+        }
+        const next = update(current);
+        if (!next) {
+          return void 0;
+        }
+        await upsertSqlRun(db, next);
+        return next;
+      }
+    );
+  }
+};
+function createSchedulerSqlStore(db) {
+  return new SqlSchedulerStore(db);
+}
+
+export {
+  juniorToolOutputSchema,
+  injectContinuationToolName,
+  makeStructuredToolOutput,
+  ToolInputError,
+  eventNamespaceSchema,
+  registeredEventTypeSchema,
+  registeredResourceTypeSchema,
+  pluginSupportsEvent,
+  normalizeEventIdentifier,
+  getResourceEventCatalog,
+  getEventTask,
+  createEventTask,
+  saveEventTask,
+  deleteEventTask,
+  listEventTasksForTeam,
+  eventTaskBelongsToUser,
+  listEventTasksCreatedBy,
+  listPublicEventTasksForTeams,
+  findMatchingEventTasks,
+  eventTaskToolResultSchema,
+  eventTaskListToolResultSchema,
+  registeredEventTaskTriggerSchema,
+  requireSupportedEventTaskTrigger,
+  requireEventTaskSlackContext,
+  eventTaskMatchesDestination,
+  writableEventTask,
+  eventTaskTriggerAvailable,
+  compactEventTask,
+  eventTaskSuccess,
+  getZonedDateTimeParts,
+  resolveLocalScheduleAtMs,
+  getFirstRunAtMs,
+  SCHEDULED_TASK_SYSTEM_ACTOR,
+  listPublicScheduledTasksForTeams,
+  createSchedulerSqlStore,
+  incrementStat,
+  readStats
+};