@sentry/junior 0.177.0 → 0.179.0

package/dist/chunk-4TRHPYTL.js

@@ -1,1944 +0,0 @@
-import {
-  ToolInputError,
-  canRouteResourceEvents,
-  getPlugins
-} from "./chunk-PA7QDS7P.js";
-import {
-  getDb
-} from "./chunk-LPMLAJYR.js";
-import {
-  juniorAttachments,
-  juniorConversations,
-  juniorEventTasks,
-  juniorSchedulerRuns,
-  juniorSchedulerTasks,
-  juniorStats
-} from "./chunk-WCQUKX74.js";
-import {
-  juniorDestinations
-} from "./chunk-VFUK3X5B.js";
-import {
-  logInfo
-} from "./chunk-7CVYXUOJ.js";
-
-// src/chat/resource-events/catalog.ts
-import {
-  normalizeResourceEventIdentifier
-} from "@sentry/junior-plugin-api";
-import { z } from "zod";
-function enumSchema(values, unavailableMessage) {
-  if (values.length === 0) {
-    return z.string().refine(() => false, unavailableMessage);
-  }
-  return z.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 resourceEventGuidance(catalog, namespace, resourceType, eventType) {
-  return catalog[namespace]?.resourceTypes.find(
-    (candidate) => candidate.type === resourceType
-  )?.guidance?.[eventType];
-}
-function normalizeEventIdentifier(catalog, namespace, identifier) {
-  return normalizeResourceEventIdentifier(catalog[namespace], identifier);
-}
-
-// 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/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 as z2 } from "zod";
-var EVENT_TASK_IDENTIFIER_MAX_LENGTH = 300;
-var eventTaskPrincipalSchema = z2.object({
-  slackUserId: slackActorSchema.shape.userId,
-  fullName: z2.string().optional(),
-  userName: z2.string().optional()
-}).strict();
-var eventTaskTriggerSchema = z2.object({
-  events: z2.array(resourceEventTypeSchema).min(1),
-  label: z2.string().min(1),
-  namespace: z2.string().min(1),
-  identifier: z2.string().min(1).max(EVENT_TASK_IDENTIFIER_MAX_LENGTH),
-  resourceType: z2.string().min(1)
-}).strict();
-var eventTaskSchema = z2.object({
-  id: z2.string().min(1),
-  createdAtMs: z2.number().finite(),
-  createdBy: eventTaskPrincipalSchema,
-  credentialMode: z2.enum(["system", "creator"]),
-  destination: slackDestinationSchema,
-  destinationVisibility: destinationVisibilitySchema,
-  task: z2.object({ text: z2.string().min(1) }).strict(),
-  trigger: eventTaskTriggerSchema
-}).strict();
-
-// src/chat/event-tasks/store.ts
-function eventTaskJsonPayload(task) {
-  const { title: _title, ...payload } = task;
-  return payload;
-}
-function parseTask(row) {
-  const raw = row.task && typeof row.task === "object" ? { ...row.task } : row.task;
-  if (raw && typeof raw === "object" && "title" in raw) {
-    delete raw.title;
-  }
-  const payload = eventTaskSchema.parse(raw);
-  const title = row.title?.trim();
-  return title ? { ...payload, title } : payload;
-}
-async function getEventTask(db, id) {
-  const rows = await db.select({ task: juniorEventTasks.task, title: juniorEventTasks.title }).from(juniorEventTasks).where(eq(juniorEventTasks.id, id)).limit(1);
-  return rows[0] ? parseTask(rows[0]) : void 0;
-}
-async function createEventTask(db, task) {
-  const parsed = eventTaskSchema.parse(eventTaskJsonPayload(task));
-  const title = task.title?.trim() || null;
-  await db.insert(juniorEventTasks).values({
-    id: parsed.id,
-    teamId: parsed.destination.teamId,
-    namespace: parsed.trigger.namespace,
-    identifier: parsed.trigger.identifier,
-    createdAtMs: parsed.createdAtMs,
-    title,
-    task: parsed
-  }).onConflictDoNothing();
-  return await getEventTask(db, parsed.id) ?? { ...parsed, ...title ? { title } : {} };
-}
-async function saveEventTask(db, task) {
-  const parsed = eventTaskSchema.parse(eventTaskJsonPayload(task));
-  const title = task.title?.trim() || null;
-  const rows = await db.update(juniorEventTasks).set({
-    namespace: parsed.trigger.namespace,
-    identifier: parsed.trigger.identifier,
-    title,
-    task: parsed
-  }).where(eq(juniorEventTasks.id, parsed.id)).returning({ task: juniorEventTasks.task, title: juniorEventTasks.title });
-  return rows[0] ? parseTask(rows[0]) : void 0;
-}
-async function deleteEventTask(db, id) {
-  const rows = await db.delete(juniorEventTasks).where(eq(juniorEventTasks.id, id)).returning({ task: juniorEventTasks.task, title: juniorEventTasks.title });
-  return rows[0] ? parseTask(rows[0]) : void 0;
-}
-async function listEventTasksForTeam(db, teamId) {
-  const rows = await db.select({ task: juniorEventTasks.task, title: juniorEventTasks.title }).from(juniorEventTasks).where(eq(juniorEventTasks.teamId, teamId)).orderBy(asc(juniorEventTasks.createdAtMs), asc(juniorEventTasks.id));
-  return rows.map(parseTask);
-}
-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, title: juniorEventTasks.title }).from(juniorEventTasks).where(ownership).orderBy(desc(juniorEventTasks.createdAtMs), desc(juniorEventTasks.id)).limit(limit);
-  return rows.map(parseTask);
-}
-async function listPublicEventTasksForTeams(db, teamIds, limit) {
-  if (teamIds.length === 0) return [];
-  const rows = await db.select({ task: juniorEventTasks.task, title: juniorEventTasks.title }).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(parseTask);
-}
-async function findMatchingEventTasks(db, event, teamId) {
-  const rows = await db.select({ task: juniorEventTasks.task, title: juniorEventTasks.title }).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(parseTask).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 z3 } from "zod";
-var juniorToolContinuationSchema = z3.object({
-  arguments: z3.record(z3.string(), z3.unknown()),
-  reason: z3.string().min(1).optional()
-}).strict();
-var juniorToolBoundContinuationSchema = juniorToolContinuationSchema.extend({
-  tool_name: z3.string().min(1)
-});
-var juniorToolOutputSchema = z3.object({
-  target: z3.string().min(1).optional(),
-  truncated: z3.boolean().optional(),
-  /** True when this attempt did not finish before its time budget. */
-  timed_out: z3.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/event-tasks/tool-support.ts
-import { z as z4 } from "zod";
-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,
-  notInArray,
-  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/telemetry.ts
-function scheduledTaskAttributes(task, extras = {}) {
-  return {
-    "app.task.id": task.id,
-    "app.task.type": "scheduled",
-    "app.task.status": task.status,
-    "app.task.schedule.kind": task.schedule.kind,
-    "app.task.schedule.timezone": task.schedule.timezone,
-    "app.task.credential_mode": task.credentialMode,
-    "app.task.destination.channel_id": task.destination.channelId,
-    "app.task.destination.team_id": task.destination.teamId,
-    "app.task.destination.visibility": task.conversationAccess.visibility,
-    "app.task.destination.audience": task.conversationAccess.audience,
-    "messaging.destination.name": task.destination.channelId,
-    ...typeof task.nextRunAtMs === "number" ? { "app.task.next_run_at": new Date(task.nextRunAtMs).toISOString() } : {},
-    ...extras
-  };
-}
-function scheduledTaskRunAttributes(task, run, extras = {}) {
-  return scheduledTaskAttributes(task, {
-    "app.task.run.id": run.id,
-    "app.task.run.status": run.status,
-    "app.task.run.scheduled_for": new Date(run.scheduledForMs).toISOString(),
-    ...run.dispatchId ? { "app.dispatch.id": run.dispatchId } : {},
-    ...run.resultMessageTs ? { "app.task.result_message_ts": run.resultMessageTs } : {},
-    ...extras
-  });
-}
-function logScheduledTaskRunSkipped(task, run, extras = {}) {
-  logInfo(
-    "scheduled_task.run.skipped",
-    scheduledTaskRunAttributes(task, run, extras)
-  );
-}
-
-// 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,
-  // TODO(v0.131.0): Remove paused decoding and SQL list filtering after
-  // v0.129.x workers can no longer overlap upgrades.
-  status: z6.enum(["active", "blocked", "completed", "deleted", "paused"]),
-  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 statusAfterTerminalOccurrence(args) {
-  if (args.blocked || args.outcome === "blocked") {
-    return "blocked";
-  }
-  if (args.nextRunAtMs) {
-    return args.previousStatus ?? "active";
-  }
-  if (args.outcome === "completed") {
-    return "completed";
-  }
-  return "deleted";
-}
-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, title) {
-  const record = parseJsonRecord(value);
-  if (!record) return void 0;
-  const { title: recordTitle, ...rest } = record;
-  const parsed = taskRecordSchema.safeParse(rest);
-  if (!parsed.success) return void 0;
-  const storedTitle = title ?? (typeof recordTitle === "string" ? recordTitle : null);
-  return stripLegacyTaskFields(parsed.data, storedTitle);
-}
-function stripLegacyTaskFields(task, title) {
-  const { version: _version, status, ...current } = task;
-  const storedTitle = title?.trim() || void 0;
-  if (status === "paused") {
-    const {
-      nextRunAtMs: _nextRunAtMs,
-      runNowAtMs: _runNowAtMs,
-      ...rest
-    } = current;
-    return {
-      ...rest,
-      status: "deleted",
-      ...storedTitle ? { title: storedTitle } : {}
-    };
-  }
-  return {
-    ...current,
-    status,
-    ...storedTitle ? { title: storedTitle } : {}
-  };
-}
-function scheduledTaskJsonRecord(task) {
-  const { title: _title, ...record } = task;
-  return record;
-}
-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 listedScheduledTask(task) {
-  return task !== void 0 && task.status !== "deleted";
-}
-function requireStoredTask(task) {
-  const parsed = parseStoredTask(task, task.title);
-  if (!parsed) {
-    throw new Error("Scheduled task routing context is invalid.");
-  }
-  return parsed;
-}
-function parseSqlTaskRecord(value, creatorIdentityId, title) {
-  const record = parseJsonRecord(value);
-  const withIdentity = record && creatorIdentityId ? { ...record, creatorIdentityId } : record;
-  return parseStoredTask(withIdentity, title);
-}
-function parseSqlTaskRow(row) {
-  return parseSqlTaskRecord(row.record, row.creatorIdentityId, row.title);
-}
-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) {
-  const title = task.title?.trim() || null;
-  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: scheduledTaskJsonRecord(task),
-    runNowAtMs: task.runNowAtMs,
-    status: task.status,
-    teamId: task.destination.teamId,
-    title
-  }).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`,
-      title: sql3`excluded.title`
-    }
-  });
-}
-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,
-    title: juniorSchedulerTasks.title
-  }).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,
-    title: juniorSchedulerTasks.title
-  }).from(juniorSchedulerTasks).where(notInArray(juniorSchedulerTasks.status, ["deleted", "paused"])).orderBy(
-    asc3(juniorSchedulerTasks.createdAtMs),
-    asc3(juniorSchedulerTasks.id)
-  );
-  return rows.map(parseSqlTaskRow).filter(listedScheduledTask);
-}
-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.title}), ${query}) > 0`,
-      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,
-      title: juniorSchedulerTasks.title
-    }).from(juniorSchedulerTasks).where(
-      and3(
-        notInArray(juniorSchedulerTasks.status, ["deleted", "paused"]),
-        inArray2(juniorSchedulerTasks.creatorIdentityId, input.identityIds),
-        cursor,
-        search
-      )
-    ).orderBy(
-      desc2(juniorSchedulerTasks.createdAtMs),
-      desc2(juniorSchedulerTasks.id)
-    ).limit(input.limit);
-    tasks.push(...rows.map(parseSqlTaskRow).filter(listedScheduledTask));
-    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,
-    title: juniorSchedulerTasks.title
-  }).from(juniorSchedulerTasks).where(
-    and3(
-      eq2(juniorSchedulerTasks.teamId, teamId),
-      notInArray(juniorSchedulerTasks.status, ["deleted", "paused"])
-    )
-  ).orderBy(
-    asc3(juniorSchedulerTasks.createdAtMs),
-    asc3(juniorSchedulerTasks.id)
-  );
-  return rows.map(parseSqlTaskRow).filter(listedScheduledTask);
-}
-async function listPublicScheduledTasksForTeams(db, teamIds, limit) {
-  if (teamIds.length === 0) return [];
-  const rows = await db.select({
-    creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
-    record: juniorSchedulerTasks.record,
-    title: juniorSchedulerTasks.title
-  }).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),
-      notInArray(juniorSchedulerTasks.status, [
-        "completed",
-        "deleted",
-        "paused"
-      ]),
-      eq2(juniorDestinations.visibility, "public")
-    )
-  ).orderBy(
-    desc2(juniorSchedulerTasks.createdAtMs),
-    desc2(juniorSchedulerTasks.id)
-  ).limit(limit);
-  return rows.map(parseSqlTaskRow).filter(listedScheduledTask);
-}
-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) {
-    const skippedRuns = [];
-    const claimed = await withSqlLock(
-      this.db,
-      "junior:scheduler:claim",
-      async (db) => {
-        const rows = await db.select({
-          creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
-          record: juniorSchedulerTasks.record,
-          title: juniorSchedulerTasks.title
-        }).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 })) {
-            const skipped = await this.skipMissedRun(db, {
-              nowMs: args.nowMs,
-              scheduledForMs,
-              task
-            });
-            if (skipped) {
-              skippedRuns.push(skipped);
-            }
-            continue;
-          }
-          const run = buildScheduledRun({
-            claimedAtMs: args.nowMs,
-            scheduledForMs,
-            task
-          });
-          await upsertSqlRun(db, run);
-          return run;
-        }
-        return void 0;
-      }
-    );
-    for (const skipped of skippedRuns) {
-      logScheduledTaskRunSkipped(skipped.task, skipped.run, {
-        "app.task.run.error": skipped.errorMessage
-      });
-    }
-    return claimed;
-  }
-  async skipMissedRun(db, args) {
-    const current = await getTaskFromSql(db, args.task.id);
-    if (!current || current.status !== "active" || getDueRunAtMs(current, args.nowMs) !== args.scheduledForMs) {
-      return void 0;
-    }
-    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.";
-    const skipped = buildSkippedScheduledRun({
-      completedAtMs: args.nowMs,
-      errorMessage,
-      scheduledForMs: args.scheduledForMs,
-      task: current
-    });
-    await upsertSqlRun(db, skipped);
-    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 = statusAfterTerminalOccurrence({ nextRunAtMs });
-    await this.saveTaskRecord(
-      db,
-      {
-        ...current,
-        nextRunAtMs,
-        runNowAtMs: isRunNow ? void 0 : current.runNowAtMs,
-        status: nextStatus,
-        statusReason: nextStatus === "deleted" ? errorMessage : void 0,
-        updatedAtMs: args.nowMs
-      },
-      current
-    );
-    return { errorMessage, run: skipped, task: 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" || current.status === "completed") {
-        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: statusAfterTerminalOccurrence({
-              nextRunAtMs: nextRunAtMs2,
-              outcome: args.status,
-              previousStatus: current.status
-            }),
-            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: statusAfterTerminalOccurrence({
-            nextRunAtMs,
-            outcome: args.status
-          }),
-          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);
-}
-
-// src/chat/attachments/store.ts
-import { createHash, randomUUID } from "crypto";
-import { and as and4, asc as asc4, eq as eq3, inArray as inArray3, isNotNull as isNotNull2, isNull, or as or3 } from "drizzle-orm";
-var ATTACHMENT_GC_BATCH_LIMIT = 200;
-function attachmentDigest(file) {
-  return createHash("sha256").update(file.data).digest("hex");
-}
-function attachmentId(args) {
-  return createHash("sha256").update(
-    [
-      args.conversationId,
-      args.provider,
-      args.sha256,
-      args.filename,
-      args.contentType
-    ].join("\0")
-  ).digest("hex");
-}
-function attachmentKey(args) {
-  return `conversations/${args.conversationId}/attachments/${args.attachmentId}/${args.writeId}/${args.filename}`;
-}
-async function bestEffortDelete(storage, key) {
-  try {
-    await storage.delete([key]);
-  } catch {
-  }
-}
-async function isConversationPurged(db, conversationId) {
-  const [row] = await db.db().select({
-    transcriptPurgedAt: juniorConversations.transcriptPurgedAt
-  }).from(juniorConversations).where(eq3(juniorConversations.conversationId, conversationId));
-  return row?.transcriptPurgedAt != null;
-}
-function purgedConversationError(conversationId) {
-  return new Error(
-    `Cannot store attachment for purged conversation ${conversationId}`
-  );
-}
-async function assertConversationNotPurged(db, conversationId) {
-  if (await isConversationPurged(db, conversationId)) {
-    throw purgedConversationError(conversationId);
-  }
-}
-async function rejectPurgedAttachmentWrite(args) {
-  await args.db.db().update(juniorAttachments).set({ deleteRequestedAt: args.now }).where(eq3(juniorAttachments.id, args.id));
-  await bestEffortDelete(args.storage, args.storageKey);
-  throw purgedConversationError(args.conversationId);
-}
-async function reuseLiveAttachment(args) {
-  await bestEffortDelete(args.storage, args.storageKey);
-  await assertConversationNotPurged(args.db, args.conversationId);
-  return { id: args.id };
-}
-async function storeAttachment(args) {
-  const now = new Date(args.nowMs ?? Date.now());
-  const sha256 = attachmentDigest(args.file);
-  const id = attachmentId({
-    conversationId: args.conversationId,
-    contentType: args.file.mimeType,
-    filename: args.file.filename,
-    provider: args.storage.provider,
-    sha256
-  });
-  const [existing] = await args.db.db().select({
-    contentType: juniorAttachments.contentType,
-    conversationId: juniorAttachments.conversationId,
-    deleteRequestedAt: juniorAttachments.deleteRequestedAt,
-    filename: juniorAttachments.filename,
-    id: juniorAttachments.id,
-    provider: juniorAttachments.provider,
-    sha256: juniorAttachments.sha256,
-    storageKey: juniorAttachments.storageKey
-  }).from(juniorAttachments).where(eq3(juniorAttachments.id, id));
-  if (existing) {
-    if (existing.contentType !== args.file.mimeType || existing.conversationId !== args.conversationId || existing.filename !== args.file.filename || existing.provider !== args.storage.provider || existing.sha256 !== sha256) {
-      throw new Error(`Attachment write conflicts with ${existing.id}`);
-    }
-    if (existing.deleteRequestedAt === null) {
-      await assertConversationNotPurged(args.db, args.conversationId);
-      return { id: existing.id };
-    }
-  }
-  await assertConversationNotPurged(args.db, args.conversationId);
-  const storageKey = attachmentKey({
-    attachmentId: id,
-    conversationId: args.conversationId,
-    filename: args.file.filename,
-    writeId: randomUUID()
-  });
-  await args.storage.put({
-    body: args.file.data,
-    contentType: args.file.mimeType,
-    key: storageKey
-  });
-  if (existing?.deleteRequestedAt != null) {
-    if (await isConversationPurged(args.db, args.conversationId)) {
-      await bestEffortDelete(args.storage, storageKey);
-      throw purgedConversationError(args.conversationId);
-    }
-    const oldStorageKey = existing.storageKey;
-    const revived2 = await args.db.db().update(juniorAttachments).set({
-      deleteRequestedAt: null,
-      storageKey
-    }).where(
-      and4(
-        eq3(juniorAttachments.id, id),
-        isNotNull2(juniorAttachments.deleteRequestedAt)
-      )
-    ).returning({ id: juniorAttachments.id });
-    if (revived2.length > 0) {
-      if (await isConversationPurged(args.db, args.conversationId)) {
-        await rejectPurgedAttachmentWrite({
-          conversationId: args.conversationId,
-          db: args.db,
-          id,
-          now,
-          storage: args.storage,
-          storageKey
-        });
-      }
-      if (oldStorageKey !== storageKey) {
-        await bestEffortDelete(args.storage, oldStorageKey);
-      }
-      return { id };
-    }
-    const [afterRace2] = await args.db.db().select({
-      deleteRequestedAt: juniorAttachments.deleteRequestedAt,
-      id: juniorAttachments.id,
-      storageKey: juniorAttachments.storageKey
-    }).from(juniorAttachments).where(eq3(juniorAttachments.id, id));
-    if (afterRace2?.deleteRequestedAt === null) {
-      return reuseLiveAttachment({
-        conversationId: args.conversationId,
-        db: args.db,
-        id: afterRace2.id,
-        storage: args.storage,
-        storageKey
-      });
-    }
-  }
-  let inserted = [];
-  try {
-    inserted = await args.db.db().insert(juniorAttachments).values({
-      id,
-      conversationId: args.conversationId,
-      provider: args.storage.provider,
-      storageKey,
-      filename: args.file.filename,
-      contentType: args.file.mimeType,
-      bytes: args.file.bytes,
-      sha256,
-      createdAt: now
-    }).onConflictDoNothing({ target: juniorAttachments.id }).returning({ id: juniorAttachments.id });
-  } catch (error) {
-    await bestEffortDelete(args.storage, storageKey);
-    throw error;
-  }
-  if (inserted.length > 0) {
-    if (await isConversationPurged(args.db, args.conversationId)) {
-      await rejectPurgedAttachmentWrite({
-        conversationId: args.conversationId,
-        db: args.db,
-        id,
-        now,
-        storage: args.storage,
-        storageKey
-      });
-    }
-    return { id };
-  }
-  const [row] = await args.db.db().select({
-    deleteRequestedAt: juniorAttachments.deleteRequestedAt,
-    id: juniorAttachments.id,
-    storageKey: juniorAttachments.storageKey
-  }).from(juniorAttachments).where(eq3(juniorAttachments.id, id));
-  if (!row) {
-    await bestEffortDelete(args.storage, storageKey);
-    throw new Error(`Attachment row missing after write for ${id}`);
-  }
-  if (row.deleteRequestedAt === null) {
-    return reuseLiveAttachment({
-      conversationId: args.conversationId,
-      db: args.db,
-      id: row.id,
-      storage: args.storage,
-      storageKey
-    });
-  }
-  if (await isConversationPurged(args.db, args.conversationId)) {
-    await bestEffortDelete(args.storage, storageKey);
-    throw purgedConversationError(args.conversationId);
-  }
-  const revived = await args.db.db().update(juniorAttachments).set({
-    deleteRequestedAt: null,
-    storageKey
-  }).where(
-    and4(
-      eq3(juniorAttachments.id, id),
-      isNotNull2(juniorAttachments.deleteRequestedAt)
-    )
-  ).returning({ id: juniorAttachments.id });
-  if (revived.length > 0) {
-    if (await isConversationPurged(args.db, args.conversationId)) {
-      await rejectPurgedAttachmentWrite({
-        conversationId: args.conversationId,
-        db: args.db,
-        id,
-        now,
-        storage: args.storage,
-        storageKey
-      });
-    }
-    if (row.storageKey !== storageKey) {
-      await bestEffortDelete(args.storage, row.storageKey);
-    }
-    return { id };
-  }
-  const [afterRace] = await args.db.db().select({
-    deleteRequestedAt: juniorAttachments.deleteRequestedAt,
-    id: juniorAttachments.id
-  }).from(juniorAttachments).where(eq3(juniorAttachments.id, id));
-  if (afterRace?.deleteRequestedAt === null) {
-    return reuseLiveAttachment({
-      conversationId: args.conversationId,
-      db: args.db,
-      id: afterRace.id,
-      storage: args.storage,
-      storageKey
-    });
-  }
-  await bestEffortDelete(args.storage, storageKey);
-  throw new Error(`Attachment ${id} disappeared while reviving`);
-}
-async function readLiveAttachment(args) {
-  const [row] = await args.db.db().select({
-    bytes: juniorAttachments.bytes,
-    contentType: juniorAttachments.contentType,
-    conversationId: juniorAttachments.conversationId,
-    deleteRequestedAt: juniorAttachments.deleteRequestedAt,
-    filename: juniorAttachments.filename,
-    id: juniorAttachments.id,
-    provider: juniorAttachments.provider,
-    storageKey: juniorAttachments.storageKey
-  }).from(juniorAttachments).where(
-    and4(
-      eq3(juniorAttachments.id, args.attachmentId),
-      eq3(juniorAttachments.conversationId, args.conversationId),
-      isNull(juniorAttachments.deleteRequestedAt)
-    )
-  );
-  if (!row) return null;
-  if (await isConversationPurged(args.db, args.conversationId)) {
-    return null;
-  }
-  return {
-    bytes: row.bytes,
-    contentType: row.contentType,
-    conversationId: row.conversationId,
-    filename: row.filename,
-    id: row.id,
-    provider: row.provider,
-    storageKey: row.storageKey
-  };
-}
-async function storeAttachments(args) {
-  const stored = [];
-  for (const file of args.files) {
-    stored.push(
-      await storeAttachment({
-        conversationId: args.conversationId,
-        db: args.db,
-        file,
-        ...args.nowMs !== void 0 ? { nowMs: args.nowMs } : {},
-        storage: args.storage
-      })
-    );
-  }
-  return stored;
-}
-async function requestAttachmentDeletion(db, conversationIds, nowMs) {
-  if (conversationIds.length === 0) return;
-  await db.db().update(juniorAttachments).set({ deleteRequestedAt: new Date(nowMs) }).where(
-    and4(
-      inArray3(juniorAttachments.conversationId, conversationIds),
-      isNull(juniorAttachments.deleteRequestedAt)
-    )
-  );
-}
-async function collectAttachmentGarbage(args) {
-  void args.nowMs;
-  const rows = await args.db.db().select({
-    id: juniorAttachments.id,
-    storageKey: juniorAttachments.storageKey
-  }).from(juniorAttachments).innerJoin(
-    juniorConversations,
-    eq3(
-      juniorAttachments.conversationId,
-      juniorConversations.conversationId
-    )
-  ).where(
-    and4(
-      eq3(juniorAttachments.provider, args.storage.provider),
-      or3(
-        isNotNull2(juniorAttachments.deleteRequestedAt),
-        isNotNull2(juniorConversations.transcriptPurgedAt)
-      )
-    )
-  ).orderBy(asc4(juniorAttachments.createdAt), asc4(juniorAttachments.id)).limit(args.limit ?? ATTACHMENT_GC_BATCH_LIMIT);
-  if (rows.length === 0) return { deleted: 0 };
-  await args.storage.delete(rows.map((row) => row.storageKey));
-  const stillEligible = await args.db.db().select({ id: juniorAttachments.id }).from(juniorAttachments).innerJoin(
-    juniorConversations,
-    eq3(
-      juniorAttachments.conversationId,
-      juniorConversations.conversationId
-    )
-  ).where(
-    and4(
-      inArray3(
-        juniorAttachments.id,
-        rows.map((row) => row.id)
-      ),
-      or3(
-        isNotNull2(juniorAttachments.deleteRequestedAt),
-        isNotNull2(juniorConversations.transcriptPurgedAt)
-      )
-    )
-  );
-  if (stillEligible.length === 0) return { deleted: 0 };
-  const removed = await args.db.db().delete(juniorAttachments).where(
-    inArray3(
-      juniorAttachments.id,
-      stillEligible.map((row) => row.id)
-    )
-  ).returning({
-    id: juniorAttachments.id
-  });
-  return { deleted: removed.length };
-}
-
-export {
-  juniorToolOutputSchema,
-  injectContinuationToolName,
-  makeStructuredToolOutput,
-  eventNamespaceSchema,
-  registeredEventTypeSchema,
-  registeredResourceTypeSchema,
-  pluginSupportsEvent,
-  resourceEventGuidance,
-  normalizeEventIdentifier,
-  getResourceEventCatalog,
-  getEventTask,
-  createEventTask,
-  saveEventTask,
-  deleteEventTask,
-  listEventTasksForTeam,
-  eventTaskBelongsToUser,
-  listEventTasksCreatedBy,
-  listPublicEventTasksForTeams,
-  findMatchingEventTasks,
-  eventTaskToolResultSchema,
-  eventTaskListToolResultSchema,
-  registeredEventTaskTriggerSchema,
-  requireSupportedEventTaskTrigger,
-  requireEventTaskSlackContext,
-  eventTaskMatchesDestination,
-  writableEventTask,
-  eventTaskTriggerAvailable,
-  compactEventTask,
-  eventTaskSuccess,
-  getZonedDateTimeParts,
-  resolveLocalScheduleAtMs,
-  getFirstRunAtMs,
-  scheduledTaskAttributes,
-  scheduledTaskRunAttributes,
-  logScheduledTaskRunSkipped,
-  SCHEDULED_TASK_SYSTEM_ACTOR,
-  listPublicScheduledTasksForTeams,
-  createSchedulerSqlStore,
-  readLiveAttachment,
-  storeAttachments,
-  requestAttachmentDeletion,
-  collectAttachmentGarbage,
-  incrementStat,
-  readStats
-};