@agent-native/core 0.141.3 → 0.141.4

package/corpus/templates/analytics/server/plugins/db.ts

@@ -12,6 +12,7 @@ import { isInBackgroundFunctionRuntime } from "@agent-native/core/server";
 // startup so the dashboard / analysis share actions know where to dispatch.
 import "../db/index.js";
 import * as schema from "../db/schema.js";
+import { FIRST_PARTY_ANALYTICS_ROLLUP_LOCK_KEY } from "../lib/first-party-analytics-rollups.js";
 import { repairPersistedFirstPartyDashboardQueries } from "../lib/first-party-dashboard-repair.js";
 
 /**
@@ -169,10 +170,11 @@ async function runHistoricalAnalyticsRollupBackfill() {
       // connections while waiting for the winner. A lock loser defers without
       // recording the migration so a failed winner can be retried safely.
       // The monotonic rollup upsert below keeps a live increment from being
-      // overwritten if ingest commits during the historical snapshot.
+      // overwritten if ingest commits during the historical snapshot. Live
+      // ingest takes this same lock before inserting its raw event.
       const lockResult = await tx.execute({
         sql: "SELECT pg_try_advisory_xact_lock(hashtextextended(?, 0::bigint)) AS acquired",
-        args: ["agent-native:analytics-rollup-backfill"],
+        args: [FIRST_PARTY_ANALYTICS_ROLLUP_LOCK_KEY],
       });
       const acquired = lockResult.rows[0]?.acquired;
       if (acquired !== true && acquired !== "t") {
@@ -1570,10 +1572,16 @@ const runAnalyticsMigrations = runMigrations(
  * swallowed so it can never fail boot.
  */
 export default async (nitroApp: any): Promise<void> => {
-  await runAnalyticsMigrations(nitroApp);
   if (isInBackgroundFunctionRuntime()) {
+    // Durable workers execute signed internal routes against a schema owned by
+    // the regular server. A second migration runner only adds a Neon pool
+    // probe to every worker cold start.
+    console.info(
+      "[db] Skipping Analytics migrations in durable background runtime",
+    );
     return;
   }
+  await runAnalyticsMigrations(nitroApp);
   try {
     if (await repairPersistedFirstPartyDashboardQueries()) {
       console.info(

package/corpus/templates/analytics/server/plugins/transactional-emails.ts

@@ -0,0 +1,5 @@
+import { registerAnalyticsEmails } from "../lib/emails";
+
+export default function registerTransactionalEmails(): void {
+  registerAnalyticsEmails();
+}

package/corpus/templates/calendar/app/components/calendar/InlineEventPickers.tsx

@@ -36,7 +36,7 @@ function formatTimeValue(value: string) {
   const period = hourValue >= 12 ? "PM" : "AM";
   const hour = hourValue % 12 || 12;
   return minuteValue === 0
-    ? `${hour} ${period}`
+    ? `${hour}:00 ${period}`
     : `${hour}:${String(minuteValue).padStart(2, "0")} ${period}`;
 }
 
@@ -118,12 +118,17 @@ export function TimePickerPopover({
                 }}
               >
                 <span>{formatTimeValue(option)}</span>
-                {getOptionMeta?.(option) && (
-                  <span className="text-muted-foreground">
-                    {getOptionMeta(option)}
+                <span className="ml-3 flex min-w-0 items-center gap-2 text-muted-foreground">
+                  {getOptionMeta?.(option) && (
+                    <span className="truncate">{getOptionMeta(option)}</span>
+                  )}
+                  <span
+                    aria-hidden="true"
+                    className="flex size-3.5 shrink-0 items-center justify-center"
+                  >
+                    {selected && <IconCheck className="size-3.5" />}
                   </span>
-                )}
-                {selected && <IconCheck className="ml-2 size-3.5 shrink-0" />}
+                </span>
               </button>
             );
           })}
@@ -338,7 +343,12 @@ export function RepeatPicker({
               <span>{option.label}</span>
               <span className="ml-3 flex items-center gap-2 text-muted-foreground">
                 {option.meta}
-                {selected && <IconCheck className="size-3.5 shrink-0" />}
+                <span
+                  aria-hidden="true"
+                  className="flex size-3.5 shrink-0 items-center justify-center"
+                >
+                  {selected && <IconCheck className="size-3.5" />}
+                </span>
               </span>
             </button>
           );

package/corpus/templates/calendar/server/lib/booking-emails.ts

@@ -11,6 +11,12 @@ import {
   DEFAULT_BOOKING_TIMEZONE,
   safeBookingTimeZone,
 } from "./booking-timezone.js";
+import {
+  CALENDAR_BOOKING_CANCELLED_EMAIL_ID,
+  CALENDAR_BOOKING_CANCELLED_HOST_EMAIL_ID,
+  CALENDAR_BOOKING_CONFIRMED_EMAIL_ID,
+  CALENDAR_BOOKING_RECEIVED_EMAIL_ID,
+} from "./emails.js";
 
 function stripCrlf(value: string | undefined): string {
   return (value ?? "").replace(/[\r\n]+/g, " ").trim();
@@ -57,6 +63,128 @@ async function sendBestEffort(
   }
 }
 
+export function renderBookingConfirmedEmail({
+  title,
+  when,
+  host,
+  manageUrl,
+  meetingLink,
+}: {
+  title: string;
+  when: string;
+  host: string;
+  manageUrl: string;
+  meetingLink?: string | null;
+}) {
+  const paragraphs = [
+    `You're booked for ${emailStrong(title)} with ${emailStrong(host)}.`,
+    `Time: ${emailStrong(when)}.`,
+  ];
+  if (meetingLink) {
+    paragraphs.push(`Meeting link: ${emailLink("Join meeting", meetingLink)}.`);
+  }
+
+  return {
+    subject: `Confirmed: ${title}`,
+    ...renderEmail({
+      preheader: `You're booked for ${title} on ${when}.`,
+      heading: "Your meeting is booked",
+      paragraphs,
+      cta: { label: "Manage booking", url: manageUrl },
+      footer:
+        "Use the manage link if you need to cancel or reschedule this meeting.",
+    }),
+  };
+}
+
+export function renderBookingReceivedEmail({
+  title,
+  when,
+  attendeeName,
+  attendee,
+  manageUrl,
+  meetingLink,
+}: {
+  title: string;
+  when: string;
+  attendeeName: string;
+  attendee: string;
+  manageUrl: string;
+  meetingLink?: string | null;
+}) {
+  return {
+    subject: `New booking: ${title}`,
+    ...renderEmail({
+      preheader: `${attendeeName} booked ${title} on ${when}.`,
+      heading: "New booking",
+      paragraphs: [
+        `${emailStrong(attendeeName)} booked ${emailStrong(title)}.`,
+        `Time: ${emailStrong(when)}.`,
+        `Guest: ${emailStrong(attendee)}.`,
+        ...(meetingLink
+          ? [`Meeting link: ${emailLink("Join meeting", meetingLink)}.`]
+          : []),
+      ],
+      cta: { label: "View booking", url: manageUrl },
+      footer: "This booking was created from your calendar booking link.",
+    }),
+  };
+}
+
+export function renderBookingCancelledEmail({
+  title,
+  when,
+  host,
+  bookAgainUrl,
+}: {
+  title: string;
+  when: string;
+  host: string;
+  bookAgainUrl?: string;
+}) {
+  return {
+    subject: `Cancelled: ${title}`,
+    ...renderEmail({
+      preheader: `${title} on ${when} was cancelled.`,
+      heading: "Your meeting was cancelled",
+      paragraphs: [
+        `${emailStrong(title)} with ${emailStrong(host || "the host")} has been cancelled.`,
+        `Original time: ${emailStrong(when)}.`,
+      ],
+      cta: bookAgainUrl
+        ? { label: "Book another time", url: bookAgainUrl }
+        : undefined,
+      footer: "If this was unexpected, contact the meeting host.",
+    }),
+  };
+}
+
+export function renderBookingCancelledHostEmail({
+  title,
+  when,
+  attendeeName,
+  attendee,
+}: {
+  title: string;
+  when: string;
+  attendeeName: string;
+  attendee: string;
+}) {
+  return {
+    subject: `Cancelled booking: ${title}`,
+    ...renderEmail({
+      preheader: `${attendeeName}'s booking for ${title} was cancelled.`,
+      heading: "Booking cancelled",
+      paragraphs: [
+        `${emailStrong(attendeeName)}'s booking for ${emailStrong(title)} was cancelled.`,
+        `Original time: ${emailStrong(when)}.`,
+        `Guest: ${emailStrong(attendee)}.`,
+      ],
+      footer: "No further action is needed.",
+    }),
+  };
+}
+
 export async function sendBookingConfirmationEmails({
   booking,
   hostEmail,
@@ -74,54 +202,31 @@ export async function sendBookingConfirmationEmails({
   const attendee = stripCrlf(booking.email);
   const attendeeName = stripCrlf(booking.name) || "there";
 
-  const attendeeParagraphs = [
-    `You're booked for ${emailStrong(title)} with ${emailStrong(host)}.`,
-    `Time: ${emailStrong(when)}.`,
-  ];
-  if (booking.meetingLink) {
-    attendeeParagraphs.push(
-      `Meeting link: ${emailLink("Join meeting", booking.meetingLink)}.`,
-    );
-  }
-
-  const attendeeEmail = renderEmail({
-    preheader: `You're booked for ${title} on ${when}.`,
-    heading: "Your meeting is booked",
-    paragraphs: attendeeParagraphs,
-    cta: { label: "Manage booking", url: manageUrl },
-    footer:
-      "Use the manage link if you need to cancel or reschedule this meeting.",
-  });
-
   await sendBestEffort("attendee confirmation", {
     to: attendee,
-    subject: `Confirmed: ${title}`,
-    html: attendeeEmail.html,
-    text: attendeeEmail.text,
+    ...renderBookingConfirmedEmail({
+      title,
+      when,
+      host,
+      manageUrl,
+      meetingLink: booking.meetingLink,
+    }),
     replyTo: host,
-  });
-
-  const hostEmailMessage = renderEmail({
-    preheader: `${attendeeName} booked ${title} on ${when}.`,
-    heading: "New booking",
-    paragraphs: [
-      `${emailStrong(attendeeName)} booked ${emailStrong(title)}.`,
-      `Time: ${emailStrong(when)}.`,
-      `Guest: ${emailStrong(attendee)}.`,
-      ...(booking.meetingLink
-        ? [`Meeting link: ${emailLink("Join meeting", booking.meetingLink)}.`]
-        : []),
-    ],
-    cta: { label: "View booking", url: manageUrl },
-    footer: "This booking was created from your calendar booking link.",
+    templateId: CALENDAR_BOOKING_CONFIRMED_EMAIL_ID,
   });
 
   await sendBestEffort("host notification", {
     to: host,
-    subject: `New booking: ${title}`,
-    html: hostEmailMessage.html,
-    text: hostEmailMessage.text,
+    ...renderBookingReceivedEmail({
+      title,
+      when,
+      attendeeName,
+      attendee,
+      manageUrl,
+      meetingLink: booking.meetingLink,
+    }),
     replyTo: attendee,
+    templateId: CALENDAR_BOOKING_RECEIVED_EMAIL_ID,
   });
 }
 
@@ -142,45 +247,24 @@ export async function sendBookingCancellationEmails({
   const attendee = stripCrlf(booking.email);
   const attendeeName = stripCrlf(booking.name) || "The guest";
 
-  const attendeeEmail = renderEmail({
-    preheader: `${title} on ${when} was cancelled.`,
-    heading: "Your meeting was cancelled",
-    paragraphs: [
-      `${emailStrong(title)} with ${emailStrong(host || "the host")} has been cancelled.`,
-      `Original time: ${emailStrong(when)}.`,
-    ],
-    cta: bookAgainUrl
-      ? { label: "Book another time", url: bookAgainUrl }
-      : undefined,
-    footer: "If this was unexpected, contact the meeting host.",
-  });
-
   await sendBestEffort("attendee cancellation", {
     to: attendee,
-    subject: `Cancelled: ${title}`,
-    html: attendeeEmail.html,
-    text: attendeeEmail.text,
+    ...renderBookingCancelledEmail({ title, when, host, bookAgainUrl }),
     replyTo: host || undefined,
+    templateId: CALENDAR_BOOKING_CANCELLED_EMAIL_ID,
   });
 
   if (!host) return;
 
-  const hostEmailMessage = renderEmail({
-    preheader: `${attendeeName}'s booking for ${title} was cancelled.`,
-    heading: "Booking cancelled",
-    paragraphs: [
-      `${emailStrong(attendeeName)}'s booking for ${emailStrong(title)} was cancelled.`,
-      `Original time: ${emailStrong(when)}.`,
-      `Guest: ${emailStrong(attendee)}.`,
-    ],
-    footer: "No further action is needed.",
-  });
-
   await sendBestEffort("host cancellation notification", {
     to: host,
-    subject: `Cancelled booking: ${title}`,
-    html: hostEmailMessage.html,
-    text: hostEmailMessage.text,
+    ...renderBookingCancelledHostEmail({
+      title,
+      when,
+      attendeeName,
+      attendee,
+    }),
     replyTo: attendee,
+    templateId: CALENDAR_BOOKING_CANCELLED_HOST_EMAIL_ID,
   });
 }

package/corpus/templates/calendar/server/lib/emails.ts

@@ -0,0 +1,167 @@
+/**
+ * Catalog entries for the transactional emails Calendar sends.
+ *
+ * Registered from `server/plugins/transactional-emails.ts` so Dispatch can list
+ * and preview them without the app having sent anything yet.
+ */
+
+import { defineTransactionalEmail } from "@agent-native/core/email-catalog";
+
+import {
+  renderBookingCancelledEmail,
+  renderBookingCancelledHostEmail,
+  renderBookingConfirmedEmail,
+  renderBookingReceivedEmail,
+} from "./booking-emails.js";
+import { renderEventGuestNote } from "./event-guest-notifications.js";
+
+/** Obviously-fake sample data — these render in a preview pane, never send. */
+const SAMPLE_TITLE = "Intro call";
+const SAMPLE_WHEN = "Tuesday, March 4, 2025, 10:00 AM - 10:30 AM PST";
+const SAMPLE_HOST = "dana.hill@example.com";
+const SAMPLE_GUEST = "sam.rivera@example.com";
+const SAMPLE_GUEST_NAME = "Sam Rivera";
+const SAMPLE_MANAGE_URL = "https://example.com/book/dana/manage/sample-token";
+const SAMPLE_BOOK_AGAIN_URL = "https://example.com/book/dana/intro-call";
+const SAMPLE_MEETING_LINK = "https://meet.example.com/sample-intro-call";
+
+export const CALENDAR_BOOKING_CONFIRMED_EMAIL_ID = "calendar.booking-confirmed";
+export const CALENDAR_BOOKING_RECEIVED_EMAIL_ID = "calendar.booking-received";
+export const CALENDAR_BOOKING_CANCELLED_EMAIL_ID = "calendar.booking-cancelled";
+export const CALENDAR_BOOKING_CANCELLED_HOST_EMAIL_ID =
+  "calendar.booking-cancelled-host";
+export const CALENDAR_EVENT_UPDATE_NOTE_EMAIL_ID = "calendar.event-update-note";
+export const CALENDAR_EVENT_CANCELLATION_NOTE_EMAIL_ID =
+  "calendar.event-cancellation-note";
+
+let registered = false;
+
+export function registerCalendarEmails(): void {
+  if (registered) return;
+  registered = true;
+
+  defineTransactionalEmail({
+    id: CALENDAR_BOOKING_CONFIRMED_EMAIL_ID,
+    name: "Booking confirmed (guest)",
+    trigger:
+      "A guest completes a booking on a public `/book/{username}/{slug}` page and the booking row is created.",
+    recipientLabel: "Booking guest",
+    recipient:
+      "The email address the guest typed into the booking form (`booking.email`).",
+    senderLabel: "Default, reply-to host",
+    sender:
+      "The configured EMAIL_FROM, with reply-to set to the booking link owner's address.",
+    preview: () =>
+      renderBookingConfirmedEmail({
+        title: SAMPLE_TITLE,
+        when: SAMPLE_WHEN,
+        host: SAMPLE_HOST,
+        manageUrl: SAMPLE_MANAGE_URL,
+        meetingLink: SAMPLE_MEETING_LINK,
+      }),
+  });
+
+  defineTransactionalEmail({
+    id: CALENDAR_BOOKING_RECEIVED_EMAIL_ID,
+    name: "New booking (host)",
+    trigger:
+      "Sent alongside the guest confirmation, immediately after a public booking is created.",
+    recipientLabel: "Booking link owner",
+    recipient:
+      "The owner of the booking link, looked up from the link's slug at send time.",
+    senderLabel: "Default, reply-to guest",
+    sender:
+      "The configured EMAIL_FROM, with reply-to set to the guest so the host can reply directly.",
+    preview: () =>
+      renderBookingReceivedEmail({
+        title: SAMPLE_TITLE,
+        when: SAMPLE_WHEN,
+        attendeeName: SAMPLE_GUEST_NAME,
+        attendee: SAMPLE_GUEST,
+        manageUrl: SAMPLE_MANAGE_URL,
+        meetingLink: SAMPLE_MEETING_LINK,
+      }),
+  });
+
+  defineTransactionalEmail({
+    id: CALENDAR_BOOKING_CANCELLED_EMAIL_ID,
+    name: "Booking cancelled (guest)",
+    trigger:
+      "A booking that was not already cancelled is cancelled, either by the guest through the manage/cancel token link or by someone with access to the booking link.",
+    recipientLabel: "Booking guest",
+    recipient: "The guest address stored on the booking row.",
+    senderLabel: "Default, reply-to host",
+    sender:
+      "The configured EMAIL_FROM, with reply-to set to the host when a host address could be resolved from the link slug.",
+    preview: () =>
+      renderBookingCancelledEmail({
+        title: SAMPLE_TITLE,
+        when: SAMPLE_WHEN,
+        host: SAMPLE_HOST,
+        bookAgainUrl: SAMPLE_BOOK_AGAIN_URL,
+      }),
+  });
+
+  defineTransactionalEmail({
+    id: CALENDAR_BOOKING_CANCELLED_HOST_EMAIL_ID,
+    name: "Booking cancelled (host)",
+    trigger:
+      "Sent after the guest cancellation notice, and only when a host address could be resolved from the booking link slug.",
+    recipientLabel: "Booking link owner",
+    recipient: "The booking link owner's address.",
+    senderLabel: "Default, reply-to guest",
+    sender:
+      "The configured EMAIL_FROM, with reply-to set to the guest who was booked.",
+    preview: () =>
+      renderBookingCancelledHostEmail({
+        title: SAMPLE_TITLE,
+        when: SAMPLE_WHEN,
+        attendeeName: SAMPLE_GUEST_NAME,
+        attendee: SAMPLE_GUEST,
+      }),
+  });
+
+  defineTransactionalEmail({
+    id: CALENDAR_EVENT_UPDATE_NOTE_EMAIL_ID,
+    name: "Event update note",
+    trigger:
+      "`update-event` runs with a non-empty guest notification message. Google Calendar still sends its own update invite; this carries only the organizer's note.",
+    recipientLabel: "Event attendees",
+    recipient:
+      "Every attendee on the event with a syntactically valid address, excluding the organizer's own `self` attendee row. One email per address.",
+    senderLabel: "Default, reply-to organizer",
+    sender:
+      "The configured EMAIL_FROM, with reply-to set to the organizer running the update.",
+    preview: () =>
+      renderEventGuestNote({
+        title: "Design review",
+        organizer: "Dana Hill",
+        message: "Moving this an hour later so the whole team can join.",
+        when: SAMPLE_WHEN,
+        kind: "update",
+        htmlLink: "https://calendar.example.com/event/sample",
+      }),
+  });
+
+  defineTransactionalEmail({
+    id: CALENDAR_EVENT_CANCELLATION_NOTE_EMAIL_ID,
+    name: "Event cancellation note",
+    trigger:
+      "`delete-event` runs with guest notification requested and a non-empty message. Google Calendar sends the cancellation itself; this carries only the organizer's note.",
+    recipientLabel: "Event attendees",
+    recipient:
+      "Every attendee on the deleted event with a syntactically valid address, excluding the organizer's own `self` attendee row. One email per address.",
+    senderLabel: "Default, reply-to organizer",
+    sender:
+      "The configured EMAIL_FROM, with reply-to set to the organizer running the deletion.",
+    preview: () =>
+      renderEventGuestNote({
+        title: "Design review",
+        organizer: "Dana Hill",
+        message: "Cancelling this week — we will pick it up after the launch.",
+        when: SAMPLE_WHEN,
+        kind: "cancellation",
+        appliesTo: "all events in the series",
+      }),
+  });
+}

package/corpus/templates/calendar/server/lib/event-guest-notifications.ts

@@ -6,6 +6,10 @@ import {
 } from "@agent-native/core/server";
 
 import type { CalendarEvent, DeleteEventScope } from "../../shared/api.js";
+import {
+  CALENDAR_EVENT_CANCELLATION_NOTE_EMAIL_ID,
+  CALENDAR_EVENT_UPDATE_NOTE_EMAIL_ID,
+} from "./emails.js";
 
 export interface GuestNotificationResult {
   requested: boolean;
@@ -96,6 +100,53 @@ function scopeLabel(scope: DeleteEventScope | undefined): string | undefined {
   return "this and following events";
 }
 
+export function renderEventGuestNote({
+  title,
+  organizer,
+  message,
+  when,
+  kind,
+  appliesTo,
+  htmlLink,
+}: {
+  title: string;
+  organizer: string;
+  message: string;
+  when: string;
+  kind: GuestNotificationKind;
+  appliesTo?: string;
+  htmlLink?: string | null;
+}) {
+  const heading =
+    kind === "cancellation" ? "Event cancellation note" : "Event update note";
+  const subjectPrefix =
+    kind === "cancellation" ? "Cancellation note" : "Update note";
+  const eventAction = kind === "cancellation" ? "cancelling" : "updating";
+  const paragraphs = [
+    `${emailStrong(organizer)} added this note while ${eventAction} ${emailStrong(title)}.`,
+    messageParagraph(message),
+    `When: ${emailStrong(when)}.`,
+  ];
+  if (appliesTo) {
+    paragraphs.push(`Applies to: ${emailStrong(appliesTo)}.`);
+  }
+
+  return {
+    subject: `${subjectPrefix}: ${title}`,
+    ...renderEmail({
+      preheader: `${subjectPrefix}: ${title}`,
+      heading,
+      paragraphs,
+      cta:
+        kind === "update" && htmlLink
+          ? { label: "Open in Google Calendar", url: htmlLink }
+          : undefined,
+      footer:
+        "Google Calendar sends the calendar update separately. This message carries the organizer note.",
+    }),
+  };
+}
+
 export async function sendEventGuestNotificationNote({
   event,
   organizerEmail,
@@ -138,33 +189,14 @@ export async function sendEventGuestNotificationNote({
     };
   }
 
-  const title = stripCrlf(event.title) || "Calendar event";
-  const organizer = stripCrlf(event.organizer?.displayName) || organizerEmail;
-  const heading =
-    kind === "cancellation" ? "Event cancellation note" : "Event update note";
-  const subjectPrefix =
-    kind === "cancellation" ? "Cancellation note" : "Update note";
-  const eventAction = kind === "cancellation" ? "cancelling" : "updating";
-  const paragraphs = [
-    `${emailStrong(organizer)} added this note while ${eventAction} ${emailStrong(title)}.`,
-    messageParagraph(normalizedMessage),
-    `When: ${emailStrong(formatWhen(event))}.`,
-  ];
-  const appliesTo = scopeLabel(scope);
-  if (appliesTo) {
-    paragraphs.push(`Applies to: ${emailStrong(appliesTo)}.`);
-  }
-
-  const rendered = renderEmail({
-    preheader: `${subjectPrefix}: ${title}`,
-    heading,
-    paragraphs,
-    cta:
-      kind === "update" && event.htmlLink
-        ? { label: "Open in Google Calendar", url: event.htmlLink }
-        : undefined,
-    footer:
-      "Google Calendar sends the calendar update separately. This message carries the organizer note.",
+  const rendered = renderEventGuestNote({
+    title: stripCrlf(event.title) || "Calendar event",
+    organizer: stripCrlf(event.organizer?.displayName) || organizerEmail,
+    message: normalizedMessage,
+    when: formatWhen(event),
+    kind,
+    appliesTo: scopeLabel(scope),
+    htmlLink: event.htmlLink,
   });
 
   let sentCount = 0;
@@ -174,10 +206,14 @@ export async function sendEventGuestNotificationNote({
       try {
         await sendEmail({
           to,
-          subject: `${subjectPrefix}: ${title}`,
+          subject: rendered.subject,
           html: rendered.html,
           text: rendered.text,
           replyTo: organizerEmail,
+          templateId:
+            kind === "cancellation"
+              ? CALENDAR_EVENT_CANCELLATION_NOTE_EMAIL_ID
+              : CALENDAR_EVENT_UPDATE_NOTE_EMAIL_ID,
         });
         sentCount += 1;
       } catch (error) {

package/corpus/templates/calendar/server/plugins/transactional-emails.ts

@@ -0,0 +1,5 @@
+import { registerCalendarEmails } from "../lib/emails.js";
+
+export default function registerTransactionalEmails(): void {
+  registerCalendarEmails();
+}