@agent-native/core 0.93.0 → 0.94.1

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

@@ -26,6 +26,7 @@ import { Textarea } from "@/components/ui/textarea";
 import { useUpdateEvent, useDeleteEvent } from "@/hooks/use-events";
 import { useViewPreferences } from "@/hooks/use-view-preferences";
 import { getEventDisplayColor } from "@/lib/event-colors";
+import { buildDeleteEventMutationInput } from "@/lib/event-mutation-inputs";
 import {
   sanitizeHtml,
   stripGcalInviteHtml,
@@ -136,6 +137,7 @@ export function EventDialog({
     updateEvent.mutate(
       {
         id: event.id,
+        accountEmail: event.accountEmail,
         ...updates,
         ...guestNotification,
       },
@@ -162,7 +164,7 @@ export function EventDialog({
       });
       if (!guestNotification) return;
       deleteEvent.mutate(
-        { id: event.id, ...guestNotification },
+        buildDeleteEventMutationInput(event, guestNotification),
         {
           onSuccess: () => {
             toast.success(t("eventDialog.eventDeleted"));

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

@@ -55,8 +55,12 @@ interface WeekViewProps {
     options?: { explicitDuration?: boolean },
   ) => void;
   quickEditEventId?: string | null;
-  onQuickEditSave?: (eventId: string, title: string) => void;
-  onQuickEditCancel?: (eventId: string) => void;
+  onQuickEditSave?: (
+    eventId: string,
+    title: string,
+    accountEmail?: string,
+  ) => void;
+  onQuickEditCancel?: (eventId: string, accountEmail?: string) => void;
   draftEventIds?: string[];
   onDraftUpdate?: (
     eventId: string,
@@ -281,8 +285,12 @@ interface WeekEventCardProps {
   onDeleteEvent: (eventId: string) => void;
   isDraft: boolean;
   defaultOpen: boolean;
-  onQuickEditSave?: (eventId: string, title: string) => void;
-  onQuickEditCancel?: (eventId: string) => void;
+  onQuickEditSave?: (
+    eventId: string,
+    title: string,
+    accountEmail?: string,
+  ) => void;
+  onQuickEditCancel?: (eventId: string, accountEmail?: string) => void;
   onDraftUpdate?: WeekViewProps["onDraftUpdate"];
   onDraftCreate?: WeekViewProps["onDraftCreate"];
   onDraftDiscard?: WeekViewProps["onDraftDiscard"];

package/corpus/templates/calendar/app/hooks/use-events.ts

@@ -389,6 +389,7 @@ export function useDeleteEvent() {
     },
     {
       id: string;
+      accountEmail?: string;
       scope?: "single" | "all" | "thisAndFollowing";
       sendUpdates?: "all" | "none";
       removeOnly?: boolean;

package/corpus/templates/calendar/app/lib/event-account-selection.ts

@@ -0,0 +1,36 @@
+export interface ConnectedCalendarAccount {
+  email: string;
+}
+
+export function resolveEventAccountEmail(
+  accounts: ConnectedCalendarAccount[],
+  requestedAccountEmail?: string,
+): string | undefined {
+  if (
+    requestedAccountEmail &&
+    accounts.some((account) => account.email === requestedAccountEmail)
+  ) {
+    return requestedAccountEmail;
+  }
+  return accounts[0]?.email;
+}
+
+export function reconcileEventAccountEmail(
+  accounts: ConnectedCalendarAccount[],
+  currentAccountEmail?: string,
+  draftAccountEmail?: string,
+): string | undefined {
+  if (
+    currentAccountEmail &&
+    accounts.some((account) => account.email === currentAccountEmail)
+  ) {
+    return currentAccountEmail;
+  }
+  return resolveEventAccountEmail(accounts, draftAccountEmail);
+}
+
+export function shouldShowEventAccountSelector(
+  accounts: ConnectedCalendarAccount[],
+): boolean {
+  return accounts.length > 1;
+}

package/corpus/templates/calendar/app/lib/event-form-initialization.ts

@@ -0,0 +1,21 @@
+interface EventFormInitializationInput {
+  draftId?: string;
+  draftTimezone: string;
+  date: string;
+  startTime: string;
+  endTime: string;
+  defaultTimezone: string;
+}
+
+export function buildEventFormInitializationKey({
+  draftId,
+  draftTimezone,
+  date,
+  startTime,
+  endTime,
+  defaultTimezone,
+}: EventFormInitializationInput): string {
+  return draftId
+    ? `draft:${draftId}:${draftTimezone}`
+    : `new:${date}:${startTime}:${endTime}:${defaultTimezone}`;
+}

package/corpus/templates/calendar/app/lib/event-mutation-inputs.ts

@@ -0,0 +1,18 @@
+import type { CalendarEvent, DeleteEventOptions } from "@shared/api";
+
+export type DeleteEventMutationInput = DeleteEventOptions & {
+  id: string;
+  accountEmail?: string;
+};
+
+/** Keep the event's connected account attached to every delete variant. */
+export function buildDeleteEventMutationInput(
+  event: Pick<CalendarEvent, "id" | "accountEmail">,
+  options: DeleteEventOptions = {},
+): DeleteEventMutationInput {
+  return {
+    id: event.id,
+    accountEmail: event.accountEmail,
+    ...options,
+  };
+}

package/corpus/templates/calendar/app/pages/CalendarView.tsx

@@ -84,11 +84,13 @@ import { useOverlayPeople } from "@/hooks/use-overlay-people";
 import { useSettings } from "@/hooks/use-settings";
 import { setUndoAction, runUndo } from "@/hooks/use-undo";
 import { useViewPreferences } from "@/hooks/use-view-preferences";
+import { resolveEventAccountEmail } from "@/lib/event-account-selection";
 import { getGoogleEventColorHex } from "@/lib/event-colors";
 import {
   dateTimeInTimezoneToIso,
   getLocalTimezone,
 } from "@/lib/event-form-utils";
+import { buildDeleteEventMutationInput } from "@/lib/event-mutation-inputs";
 import { isMcpEmbedSurface } from "@/lib/mcp-embed";
 import { cn } from "@/lib/utils";
 
@@ -330,6 +332,7 @@ export default function CalendarView() {
 
   const queryClient = useQueryClient();
   const googleStatus = useGoogleAuthStatus();
+  const defaultAccountEmail = googleStatus.data?.accounts?.[0]?.email;
   const settingsQuery = useSettings();
   const { data: settings } = settingsQuery;
   const { data: rawOverlayPeople } = useOverlayPeople();
@@ -394,6 +397,28 @@ export default function CalendarView() {
     [draftEvent],
   );
 
+  useEffect(() => {
+    if (!eventDraft || !defaultAccountEmail) return;
+    const resolvedAccountEmail = resolveEventAccountEmail(
+      googleStatus.data?.accounts ?? [],
+      eventDraft.accountEmail,
+    );
+    if (
+      !resolvedAccountEmail ||
+      eventDraft.accountEmail === resolvedAccountEmail
+    ) {
+      return;
+    }
+    const nextDraft = { ...eventDraft, accountEmail: resolvedAccountEmail };
+    setEventDraft(nextDraft);
+    persistCalendarDraft(nextDraft);
+  }, [
+    defaultAccountEmail,
+    eventDraft,
+    googleStatus.data?.accounts,
+    setEventDraft,
+  ]);
+
   // Warm the adjacent ranges so j/k (and the chevron buttons) feel instant.
   // Borrowed from the mail template's background-warm pattern — fire-and-forget
   // prefetch that lets React Query dedupe and reuse the response when the user
@@ -569,11 +594,24 @@ export default function CalendarView() {
       if (!draftId || !eventDraft || eventDraft.id !== draftId) return;
       if (committingDraftIdsRef.current.has(draftId)) return;
       committingDraftIdsRef.current.add(draftId);
-      const draft = pendingPatch
+      const pendingDraft = pendingPatch
         ? applyDraftPatch(eventDraft, pendingPatch)
         : eventDraft;
+      const accountEmail = resolveEventAccountEmail(
+        googleStatus.data?.accounts ?? [],
+        pendingDraft.accountEmail,
+      );
+      if (!accountEmail) {
+        committingDraftIdsRef.current.delete(draftId);
+        toast.error(t("calendarView.calendarSettingsLoading"));
+        return;
+      }
+      const draft =
+        pendingDraft.accountEmail === accountEmail
+          ? pendingDraft
+          : { ...pendingDraft, accountEmail };
       discardedCommittingDraftsRef.current.delete(draftId);
-      if (pendingPatch) {
+      if (pendingPatch || draft !== pendingDraft) {
         setEventDraft(draft);
         persistCalendarDraft(draft);
       }
@@ -621,7 +659,7 @@ export default function CalendarView() {
           ? undefined
           : (draft.endTimeZone ?? draft.startTimeZone ?? timezone),
         location,
-        accountEmail: draft.accountEmail,
+        accountEmail,
         allDay: draft.allDay ?? false,
         transparency:
           eventType === "workingLocation"
@@ -653,11 +691,18 @@ export default function CalendarView() {
           const createdEventId = result?.id;
           if (createdEventId) {
             const undo = () => {
-              deleteEvent.mutate({
-                id: createdEventId,
-                scope: "single",
-                sendUpdates: "none",
-              });
+              deleteEvent.mutate(
+                buildDeleteEventMutationInput(
+                  {
+                    id: createdEventId,
+                    accountEmail:
+                      result.accountEmail ??
+                      draft.accountEmail ??
+                      defaultAccountEmail,
+                  },
+                  { scope: "single", sendUpdates: "none" },
+                ),
+              );
             };
             setUndoAction(undo);
           }
@@ -682,7 +727,16 @@ export default function CalendarView() {
         },
       });
     },
-    [createEvent, deleteEvent, eventDraft, selectedDate, setEventDraft, t],
+    [
+      createEvent,
+      defaultAccountEmail,
+      deleteEvent,
+      eventDraft,
+      googleStatus.data?.accounts,
+      selectedDate,
+      setEventDraft,
+      t,
+    ],
   );
 
   const updateDraftEvent = useCallback(
@@ -841,12 +895,11 @@ export default function CalendarView() {
           };
 
       deleteEvent.mutate(
-        {
-          id: ev.id,
+        buildDeleteEventMutationInput(ev, {
           scope: "single",
           ...guestNotification,
           removeOnly,
-        },
+        }),
         {
           onSuccess: () => {
             if (sidebarEvent?.id === ev.id) setSidebarEvent(null);
@@ -966,6 +1019,7 @@ export default function CalendarView() {
     const undo = () => {
       updateEvent.mutate({
         id: eventId,
+        accountEmail: event.accountEmail,
         start: oldStartISO,
         end: oldEndISO,
         sendUpdates: "none",
@@ -981,6 +1035,7 @@ export default function CalendarView() {
     updateEvent.mutate(
       {
         id: eventId,
+        accountEmail: event.accountEmail,
         ...updates,
         ...guestNotification,
       },
@@ -1046,6 +1101,7 @@ export default function CalendarView() {
       const undo = () => {
         updateEvent.mutate({
           id: eventId,
+          accountEmail: event.accountEmail,
           start: oldStartISO,
           end: oldEndISO,
           sendUpdates: "none",
@@ -1061,6 +1117,7 @@ export default function CalendarView() {
       updateEvent.mutate(
         {
           id: eventId,
+          accountEmail: event.accountEmail,
           ...updates,
           ...guestNotification,
         },
@@ -1135,6 +1192,7 @@ export default function CalendarView() {
         endTimeZone: timezone,
         allDay: false,
         eventType: "default",
+        accountEmail: defaultAccountEmail,
         createdAt: now,
         updatedAt: now,
       };
@@ -1143,7 +1201,14 @@ export default function CalendarView() {
       setEventDraft(draft);
       setQuickEditEventId(calendarDraftEventId(draftId));
     },
-    [settings, settingsQuery, t, setSelectedDate, setEventDraft],
+    [
+      defaultAccountEmail,
+      settings,
+      settingsQuery,
+      t,
+      setSelectedDate,
+      setEventDraft,
+    ],
   );
 
   // Command palette natural-language quick create (e.g. "lunch with Sam
@@ -1197,6 +1262,7 @@ export default function CalendarView() {
         endTimeZone: timezone,
         allDay: false,
         eventType: "default",
+        accountEmail: defaultAccountEmail,
         createdAt: now,
         updatedAt: now,
       };
@@ -1205,11 +1271,19 @@ export default function CalendarView() {
       setEventDraft(draft);
       setQuickEditEventId(calendarDraftEventId(draftId));
     },
-    [settings, settingsQuery, t, setSelectedDate, setViewMode, setEventDraft],
+    [
+      defaultAccountEmail,
+      settings,
+      settingsQuery,
+      t,
+      setSelectedDate,
+      setViewMode,
+      setEventDraft,
+    ],
   );
 
   const handleQuickEditSave = useCallback(
-    async (eventId: string, title: string) => {
+    async (eventId: string, title: string, accountEmail?: string) => {
       setQuickEditEventId(null);
       if (calendarDraftIdFromEventId(eventId)) {
         updateDraftEvent(eventId, { title: title.trim() });
@@ -1231,14 +1305,19 @@ export default function CalendarView() {
             })
           : { sendUpdates: "none" as const };
         if (!guestNotification) return;
-        updateEvent.mutate({ id: eventId, ...updates, ...guestNotification });
+        updateEvent.mutate({
+          id: eventId,
+          accountEmail: event?.accountEmail ?? accountEmail,
+          ...updates,
+          ...guestNotification,
+        });
       }
     },
     [events, updateDraftEvent, promptGuestNotification, updateEvent],
   );
 
   const handleTitleSave = useCallback(
-    async (eventId: string, title: string) => {
+    async (eventId: string, title: string, accountEmail?: string) => {
       if (calendarDraftIdFromEventId(eventId)) {
         updateDraftEvent(eventId, { title });
         return;
@@ -1253,13 +1332,18 @@ export default function CalendarView() {
           })
         : { sendUpdates: "none" as const };
       if (!guestNotification) return;
-      updateEvent.mutate({ id: eventId, ...updates, ...guestNotification });
+      updateEvent.mutate({
+        id: eventId,
+        accountEmail: event?.accountEmail ?? accountEmail,
+        ...updates,
+        ...guestNotification,
+      });
     },
     [events, updateDraftEvent, promptGuestNotification, updateEvent],
   );
 
   const handleQuickEditCancel = useCallback(
-    (eventId: string) => {
+    (eventId: string, accountEmail?: string) => {
       setQuickEditEventId(null);
       if (calendarDraftIdFromEventId(eventId)) {
         discardDraftEvent(eventId);
@@ -1273,14 +1357,22 @@ export default function CalendarView() {
       // Delete the event if title was never set
       const ev = events.find((e) => e.id === eventId);
       if (!ev || ev.title === "(No title)") {
-        deleteEvent.mutate({
-          id: eventId,
-          scope: "single",
-          sendUpdates: "none",
-        });
+        deleteEvent.mutate(
+          buildDeleteEventMutationInput(
+            {
+              id: eventId,
+              accountEmail:
+                ev?.accountEmail ?? accountEmail ?? defaultAccountEmail,
+            },
+            {
+              scope: "single",
+              sendUpdates: "none",
+            },
+          ),
+        );
       }
     },
-    [discardDraftEvent, events, deleteEvent],
+    [defaultAccountEmail, discardDraftEvent, events, deleteEvent],
   );
 
   // IconKeyboard shortcuts — don't fire when user is typing in an input
@@ -1743,6 +1835,7 @@ export default function CalendarView() {
                 visibility: snapshot.visibility,
                 reminders: snapshot.reminders,
                 remindersUseDefault: snapshot.remindersUseDefault,
+                accountEmail: snapshot.accountEmail,
                 outOfOfficeProperties: snapshot.outOfOfficeProperties,
                 focusTimeProperties: snapshot.focusTimeProperties,
                 workingLocationProperties: snapshot.workingLocationProperties,
@@ -1754,7 +1847,7 @@ export default function CalendarView() {
               setSidebarEvent(null);
             }
             deleteEvent.mutate(
-              { id: eventId, ...options },
+              buildDeleteEventMutationInput(snapshot, options),
               {
                 onSuccess: () => {
                   setUndoAction(undo);

package/corpus/templates/calendar/changelog/2026-07-10-choose-which-connected-google-account-receives-a-new-event-w.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Choose which connected Google account receives a new event, with updates and deletions staying on that calendar.

package/corpus/templates/calendar/server/db/schema.ts

@@ -21,6 +21,8 @@ export const bookings = table("bookings", {
   meetingLink: text("meeting_link"),
   /** Google Calendar event created for this booking, if any */
   googleEventId: text("google_event_id"),
+  /** Connected calendar account that owns the provider event, if any */
+  calendarAccountId: text("calendar_account_id"),
   /** Token for public cancel/reschedule link */
   cancelToken: text("cancel_token"),
   status: text("status", { enum: ["confirmed", "cancelled"] })

package/corpus/templates/calendar/server/handlers/bookings.ts

@@ -98,23 +98,51 @@ function isValidEmail(value: string): boolean {
   return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
 }
 
-async function deleteGoogleEventForBooking({
+export async function resolveBookingCalendarAccount({
   booking,
   hostEmail,
 }: {
   booking: Pick<
     typeof schema.bookings.$inferSelect,
-    "id" | "slug" | "googleEventId"
+    "slug" | "ownerEmail" | "calendarAccountId"
   >;
   hostEmail?: string;
 }) {
-  if (!booking.googleEventId) return;
   const ownerEmail =
-    hostEmail ?? (await getBookingLinkOwnerEmail(booking.slug));
+    hostEmail ||
+    booking.ownerEmail ||
+    (await getBookingLinkOwnerEmail(booking.slug));
   if (!ownerEmail) return;
 
+  if (booking.calendarAccountId) {
+    return {
+      ownerEmail,
+      accountEmail: booking.calendarAccountId,
+    };
+  }
+
+  return googleCalendar.getDefaultAccountSelection(ownerEmail);
+}
+
+async function deleteGoogleEventForBooking({
+  booking,
+  hostEmail,
+}: {
+  booking: Pick<
+    typeof schema.bookings.$inferSelect,
+    "id" | "slug" | "googleEventId" | "ownerEmail" | "calendarAccountId"
+  >;
+  hostEmail?: string;
+}) {
+  if (!booking.googleEventId) return;
+
   try {
-    await googleCalendar.deleteEvent(booking.googleEventId, ownerEmail, {
+    const account = await resolveBookingCalendarAccount({
+      booking,
+      hostEmail,
+    });
+    if (!account) return;
+    await googleCalendar.deleteEvent(booking.googleEventId, account, {
       sendUpdates: "none",
     });
   } catch (error) {
@@ -973,6 +1001,7 @@ export const createBooking = defineEventHandler(async (event: H3Event) => {
     }
     let meetingLink: string | undefined;
     let googleEventId: string | undefined;
+    let calendarAccountId: string | undefined;
 
     // For custom-URL conferencing, use the static URL — only http(s).
     if (conferencing?.type === "custom" && conferencing.url) {
@@ -1016,6 +1045,8 @@ export const createBooking = defineEventHandler(async (event: H3Event) => {
     // host rather than relying on ambient user state.
     if (await googleCalendar.isConnected(hostEmail)) {
       try {
+        const account =
+          await googleCalendar.getDefaultAccountSelection(hostEmail);
         const descParts: string[] = [
           `Booking by ${attendeeName} (${attendeeEmail})`,
         ];
@@ -1050,7 +1081,7 @@ export const createBooking = defineEventHandler(async (event: H3Event) => {
           location: meetingLink || "",
           allDay: false,
           source: "google",
-          accountEmail: hostEmail,
+          accountEmail: account.accountEmail,
           attendees: buildBookingEventAttendees({
             attendeeEmail,
             attendeeName,
@@ -1060,11 +1091,13 @@ export const createBooking = defineEventHandler(async (event: H3Event) => {
           updatedAt: now,
         };
         const result = await googleCalendar.createEvent(calEvent, {
+          account,
           addGoogleMeet: conferencing?.type === "google_meet",
           sendUpdates: "all",
         });
         // Google Meet link is returned by the API when created
         googleEventId = result.id;
+        calendarAccountId = account.accountEmail;
         if (result.meetLink) {
           meetingLink = result.meetLink;
         }
@@ -1082,9 +1115,13 @@ export const createBooking = defineEventHandler(async (event: H3Event) => {
       const providerUpdates: {
         meetingLink?: string;
         googleEventId?: string;
+        calendarAccountId?: string;
       } = {};
       if (meetingLink) providerUpdates.meetingLink = meetingLink;
       if (googleEventId) providerUpdates.googleEventId = googleEventId;
+      if (googleEventId && calendarAccountId) {
+        providerUpdates.calendarAccountId = calendarAccountId;
+      }
       await getDb()
         .update(schema.bookings)
         .set(providerUpdates)

package/corpus/templates/calendar/server/handlers/events.ts

@@ -43,10 +43,17 @@ async function resolveAccountEmail(
   requestAccountEmail: string | undefined,
   ownerEmail: string,
 ): Promise<string> {
-  if (!requestAccountEmail || requestAccountEmail === ownerEmail) {
+  if (requestAccountEmail === ownerEmail) {
     return ownerEmail;
   }
   const status = await googleCalendar.getAuthStatus(ownerEmail);
+  if (!requestAccountEmail) {
+    return (
+      status.accounts.find((account) => account.email === ownerEmail)?.email ??
+      status.accounts[0]?.email ??
+      ownerEmail
+    );
+  }
   const isOwned = status.accounts.some((a) => a.email === requestAccountEmail);
   if (!isOwned) {
     throw new ForbiddenError("Account not owned by current user");
@@ -290,6 +297,7 @@ export const createEvent = defineEventHandler(async (event: H3Event) => {
     }
 
     const result = await googleCalendar.createEvent(calEvent, {
+      account: { ownerEmail: email, accountEmail: acctEmail },
       addGoogleMeet: shouldAutoAddGoogleMeet(calEvent, {
         addGoogleMeet:
           typeof addGoogleMeet === "boolean" ? addGoogleMeet : undefined,
@@ -372,7 +380,10 @@ export const updateEvent = defineEventHandler(async (event: H3Event) => {
 
     let existingEvent: CalendarEvent | undefined;
     const loadExistingEvent = async () => {
-      existingEvent ??= await googleCalendar.getEvent(googleEventId, acctEmail);
+      existingEvent ??= await googleCalendar.getEvent(googleEventId, {
+        ownerEmail: email,
+        accountEmail: acctEmail,
+      });
       return existingEvent;
     };
 
@@ -415,6 +426,7 @@ export const updateEvent = defineEventHandler(async (event: H3Event) => {
 
     try {
       const result = await googleCalendar.updateEvent(googleEventId, updates, {
+        account: { ownerEmail: email, accountEmail: acctEmail },
         sendUpdates:
           sendUpdates ?? (guestNotificationMessage ? "all" : undefined),
         addGoogleMeet: addGoogleMeet === true,
@@ -521,7 +533,10 @@ export const deleteEvent = defineEventHandler(async (event: H3Event) => {
     const shouldNotifyGuests = !!guestNotificationMessage && !removeOnly;
     const effectiveSendUpdates = removeOnly ? "none" : sendUpdates;
     const eventForNotification = shouldNotifyGuests
-      ? await googleCalendar.getEvent(googleEventId, accountEmail)
+      ? await googleCalendar.getEvent(googleEventId, {
+          ownerEmail: email,
+          accountEmail,
+        })
       : undefined;
 
     try {
@@ -529,15 +544,19 @@ export const deleteEvent = defineEventHandler(async (event: H3Event) => {
         // Non-organizer: decline the event to remove from calendar
         await googleCalendar.removeEventFromCalendar(
           googleEventId,
-          accountEmail,
+          { ownerEmail: email, accountEmail },
           { scope, sendUpdates: effectiveSendUpdates },
         );
       } else {
         // Organizer: actually delete the event
-        await googleCalendar.deleteEvent(googleEventId, accountEmail, {
-          scope,
-          sendUpdates: effectiveSendUpdates,
-        });
+        await googleCalendar.deleteEvent(
+          googleEventId,
+          { ownerEmail: email, accountEmail },
+          {
+            scope,
+            sendUpdates: effectiveSendUpdates,
+          },
+        );
       }
     } catch (error: any) {
       setResponseStatus(event, 500);
@@ -614,7 +633,7 @@ export const rsvpEvent = defineEventHandler(async (event: H3Event) => {
       await googleCalendar.rsvpEvent(
         googleEventId,
         status,
-        acctEmail,
+        { ownerEmail: email, accountEmail: acctEmail },
         scope,
         note,
         sendUpdates,