@remit/web-client 0.0.297 → 0.0.299

package/src/hooks/calendar/draft.test.ts

@@ -27,6 +27,8 @@ import {
 const CALENDAR = "cal_work";
 const AMSTERDAM = "Europe/Amsterdam";
 const NEW_YORK = "America/New_York";
+const TOKYO = "Asia/Tokyo";
+const IN_AMSTERDAM = { clock: AMSTERDAM, anchor: AMSTERDAM };
 
 const draft = (over: Partial<EventDraft> = {}): EventDraft => ({
 	...emptyDraft("2026-06-10", CALENDAR),
@@ -68,7 +70,7 @@ const refusal = (result: CreateInput | UpdatePatch): string => {
 
 describe("creating an event", () => {
 	it("sends the calendar, the summary and a start with an offset", () => {
-		const built = createInputFromDraft(draft(), AMSTERDAM);
+		const built = createInputFromDraft(draft(), IN_AMSTERDAM);
 		assert.ok(built.ok);
 		assert.equal(built.input.calendarId, CALENDAR);
 		assert.equal(built.input.summary, "Roadmap review");
@@ -80,7 +82,7 @@ describe("creating an event", () => {
 	it("makes an all-day event a civil date ending on the next one", () => {
 		const built = createInputFromDraft(
 			draft({ allDay: true, startTime: "", endTime: "" }),
-			AMSTERDAM,
+			IN_AMSTERDAM,
 		);
 		assert.ok(built.ok);
 		assert.equal(built.input.start, "2026-06-10");
@@ -90,7 +92,7 @@ describe("creating an event", () => {
 	it("ends a night that runs past midnight on the next day", () => {
 		const built = createInputFromDraft(
 			draft({ startTime: "22:00", endDate: "2026-06-11", endTime: "01:00" }),
-			AMSTERDAM,
+			IN_AMSTERDAM,
 		);
 		assert.ok(built.ok);
 		assert.equal(built.input.start, "2026-06-10T22:00:00+02:00");
@@ -105,7 +107,7 @@ describe("creating an event", () => {
 				endTime: "",
 				endDate: "2026-06-12",
 			}),
-			AMSTERDAM,
+			IN_AMSTERDAM,
 		);
 		assert.ok(built.ok);
 		assert.equal(built.input.start, "2026-06-10");
@@ -115,7 +117,7 @@ describe("creating an event", () => {
 	it("turns a picked repeat sentence into the rule it means", () => {
 		const built = createInputFromDraft(
 			draft({ repeat: "Every weekday, 09:00" }),
-			AMSTERDAM,
+			IN_AMSTERDAM,
 		);
 		assert.ok(built.ok);
 		assert.equal(
@@ -128,7 +130,7 @@ describe("creating an event", () => {
 describe("a refusal", () => {
 	it("names the missing title", () => {
 		assert.match(
-			refusal(createInputFromDraft(draft({ title: "  " }), AMSTERDAM)),
+			refusal(createInputFromDraft(draft({ title: "  " }), IN_AMSTERDAM)),
 			/title/i,
 		);
 	});
@@ -138,7 +140,7 @@ describe("a refusal", () => {
 			refusal(
 				createInputFromDraft(
 					draft({ startTime: "11:00", endTime: "10:00" }),
-					AMSTERDAM,
+					IN_AMSTERDAM,
 				),
 			),
 			/end is not after the start/i,
@@ -155,7 +157,7 @@ describe("a refusal", () => {
 						endTime: "",
 						endDate: "2026-06-09",
 					}),
-					AMSTERDAM,
+					IN_AMSTERDAM,
 				),
 			),
 			/last day is before the first/i,
@@ -164,7 +166,7 @@ describe("a refusal", () => {
 
 	it("names a missing time rather than saving a day-long event nobody asked for", () => {
 		assert.match(
-			refusal(createInputFromDraft(draft({ endTime: "" }), AMSTERDAM)),
+			refusal(createInputFromDraft(draft({ endTime: "" }), IN_AMSTERDAM)),
 			/start and an end time/i,
 		);
 	});
@@ -174,7 +176,7 @@ describe("a refusal", () => {
 			refusal(
 				createInputFromDraft(
 					draft({ repeat: "Every other Tuesday" }),
-					AMSTERDAM,
+					IN_AMSTERDAM,
 				),
 			),
 			/repeat rule/i,
@@ -188,7 +190,7 @@ describe("editing an event", () => {
 		const patch = patchFromDrafts(
 			before,
 			{ ...before, title: "Roadmap" },
-			AMSTERDAM,
+			IN_AMSTERDAM,
 		);
 		assert.ok(patch.ok);
 		assert.deepEqual(patch.patch, { summary: "Roadmap" });
@@ -199,7 +201,7 @@ describe("editing an event", () => {
 		const patch = patchFromDrafts(
 			before,
 			{ ...before, startTime: "08:00" },
-			AMSTERDAM,
+			IN_AMSTERDAM,
 		);
 		assert.ok(patch.ok);
 		assert.equal(patch.patch.allDay, false);
@@ -212,7 +214,7 @@ describe("editing an event", () => {
 		const patch = patchFromDrafts(
 			before,
 			{ ...before, title: "Standup" },
-			AMSTERDAM,
+			IN_AMSTERDAM,
 		);
 		assert.ok(patch.ok);
 		assert.deepEqual(patch.patch, { summary: "Standup" });
@@ -220,7 +222,11 @@ describe("editing an event", () => {
 
 	it("drops the rule when the reader turns the repeat off", () => {
 		const before = draft({ repeat: "Every weekday, 09:00" });
-		const patch = patchFromDrafts(before, { ...before, repeat: "" }, AMSTERDAM);
+		const patch = patchFromDrafts(
+			before,
+			{ ...before, repeat: "" },
+			IN_AMSTERDAM,
+		);
 		assert.ok(patch.ok);
 		assert.equal(patch.patch.recurrenceRule, "");
 	});
@@ -237,7 +243,7 @@ describe("editing an event", () => {
 		const patch = patchFromDrafts(
 			before,
 			{ ...before, title: "Night shift" },
-			AMSTERDAM,
+			IN_AMSTERDAM,
 		);
 		assert.ok(patch.ok);
 		assert.deepEqual(patch.patch, { summary: "Night shift" });
@@ -253,7 +259,7 @@ describe("editing an event", () => {
 		const patch = patchFromDrafts(
 			before,
 			{ ...before, date: "2026-06-17", endDate: "2026-06-19" },
-			AMSTERDAM,
+			IN_AMSTERDAM,
 		);
 		assert.ok(patch.ok);
 		assert.equal(patch.patch.start, "2026-06-17");
@@ -262,30 +268,35 @@ describe("editing an event", () => {
 
 	it("changes nothing when nothing was touched", () => {
 		const before = draft();
-		const patch = patchFromDrafts(before, { ...before }, AMSTERDAM);
+		const patch = patchFromDrafts(before, { ...before }, IN_AMSTERDAM);
 		assert.ok(patch.ok);
 		assert.deepEqual(patch.patch, {});
 	});
 });
 
 /**
- * The clock the form shows is the calendar's, not the device's.
+ * The clock the form shows is the device's; the zone the event is anchored in
+ * is the calendar's.
  *
- * An occurrence is returned in the collection's zone and the form displays
- * those digits, so rebuilding them with whatever offset the reader's laptop
- * happens to be on moves the event by the difference — six hours for the same
- * meeting looked at from New York, with nothing on screen saying it moved.
+ * Every surface draws occurrences on the device's clock and the form shows
+ * those digits, so the offset has to be the device's — stamping the calendar's
+ * onto them moves the event by the difference, six hours for an Amsterdam
+ * calendar looked at from New York. The calendar's zone still travels as the
+ * TZID, which is what keeps a series at its hour across a DST change.
  *
  * Both assertions are absolute rather than "whatever this runner is on": the
  * bug is precisely that the runner's zone leaked in, so a test that reads it is
  * a test that cannot see the bug.
  */
 describe("an event anchored somewhere other than the device", () => {
-	it("keeps a new event on the calendar's clock", () => {
-		const built = createInputFromDraft(draft(), NEW_YORK);
+	it("pins a new event to the device's clock and anchors it in the calendar's zone", () => {
+		const built = createInputFromDraft(draft(), {
+			clock: NEW_YORK,
+			anchor: AMSTERDAM,
+		});
 		assert.ok(built.ok);
 		assert.equal(built.input.start, "2026-06-10T09:00:00-04:00");
-		assert.equal(built.input.timeZone, NEW_YORK);
+		assert.equal(built.input.timeZone, AMSTERDAM);
 	});
 
 	it("moves an event to another day without moving it to another hour", () => {
@@ -293,7 +304,7 @@ describe("an event anchored somewhere other than the device", () => {
 		const patch = patchFromDrafts(
 			before,
 			{ ...before, date: "2026-06-17", endDate: "2026-06-17" },
-			AMSTERDAM,
+			IN_AMSTERDAM,
 		);
 		assert.ok(patch.ok);
 		assert.equal(patch.patch.start, "2026-06-17T09:00:00+02:00");
@@ -308,14 +319,17 @@ describe("an event anchored somewhere other than the device", () => {
 	it("reads the zone's own winter offset rather than one it saw in June", () => {
 		const built = createInputFromDraft(
 			draft({ date: "2026-01-14", endDate: "2026-01-14" }),
-			AMSTERDAM,
+			IN_AMSTERDAM,
 		);
 		assert.ok(built.ok);
 		assert.equal(built.input.start, "2026-01-14T09:00:00+01:00");
 	});
 
 	it("falls back to the device rather than refusing a zone nothing can resolve", () => {
-		const built = createInputFromDraft(draft(), "Mars/Olympus_Mons");
+		const built = createInputFromDraft(draft(), {
+			clock: "Mars/Olympus_Mons",
+			anchor: AMSTERDAM,
+		});
 		assert.ok(built.ok);
 		assert.match(built.input.start, /^2026-06-10T09:00:00[+-]\d{2}:\d{2}$/);
 	});
@@ -327,7 +341,7 @@ describe("an event anchored somewhere other than the device", () => {
 	 * outright on a UTC runner.
 	 */
 	it("sends no zone at all where the collection names none", () => {
-		const built = createInputFromDraft(draft(), "");
+		const built = createInputFromDraft(draft(), { clock: "UTC", anchor: "" });
 		assert.ok(built.ok);
 		assert.equal(built.input.timeZone, undefined);
 		assert.equal(built.input.start, "2026-06-10T09:00:00+00:00");
@@ -339,7 +353,7 @@ describe("an event anchored somewhere other than the device", () => {
 		const patch = patchFromDrafts(
 			before,
 			{ ...before, date: "2026-06-17", endDate: "2026-06-17" },
-			"",
+			{ clock: "UTC", anchor: "" },
 		);
 		assert.ok(patch.ok);
 		assert.equal(patch.patch.timeZone, undefined);
@@ -386,3 +400,138 @@ describe("the form moving its own dates", () => {
 		assert.equal(withAllDay(span, true).endDate, "2026-06-12");
 	});
 });
+
+/**
+ * A Tokyo afternoon read in New York runs 23:30 to 00:30. The end digits are
+ * before the start digits and the event is still an hour long.
+ */
+describe("an event that crosses midnight on the device's clock", () => {
+	const FROM_NEW_YORK = { clock: NEW_YORK, anchor: TOKYO };
+	const crossing = draft({
+		startTime: "23:30",
+		endDate: "2026-06-11",
+		endTime: "00:30",
+	});
+
+	it("still takes an edit that leaves the times alone", () => {
+		const patch = patchFromDrafts(
+			crossing,
+			{ ...crossing, title: "Roadmap" },
+			FROM_NEW_YORK,
+		);
+		assert.ok(patch.ok);
+		assert.deepEqual(patch.patch, { summary: "Roadmap" });
+	});
+
+	it("ends it the next morning when it moves day", () => {
+		const patch = patchFromDrafts(
+			crossing,
+			{ ...crossing, date: "2026-06-17", endDate: "2026-06-18" },
+			FROM_NEW_YORK,
+		);
+		assert.ok(patch.ok);
+		assert.equal(patch.patch.start, "2026-06-17T23:30:00-04:00");
+		assert.equal(patch.patch.end, "2026-06-18T00:30:00-04:00");
+		assert.equal(patch.patch.timeZone, TOKYO);
+	});
+});
+
+describe("a repeat picked on the device's day", () => {
+	const FROM_NEW_YORK = { clock: NEW_YORK, anchor: TOKYO };
+	const sundayNight = draft({
+		date: "2026-06-14",
+		endDate: "2026-06-14",
+		startTime: "21:00",
+		endTime: "22:00",
+	});
+
+	it("is stored on the day the event's own zone starts it on", () => {
+		const built = createInputFromDraft(
+			{ ...sundayNight, repeat: "Every week on Sunday, 21:00" },
+			FROM_NEW_YORK,
+		);
+		assert.ok(built.ok);
+		assert.equal(built.input.recurrenceRule, "FREQ=WEEKLY;BYDAY=MO");
+	});
+
+	it("keeps the day it was picked on where both clocks agree", () => {
+		const built = createInputFromDraft(
+			{ ...sundayNight, repeat: "Every week on Sunday, 21:00" },
+			{ clock: NEW_YORK, anchor: NEW_YORK },
+		);
+		assert.ok(built.ok);
+		assert.equal(built.input.recurrenceRule, "FREQ=WEEKLY;BYDAY=SU");
+	});
+});
+
+describe("an edit to the end alone", () => {
+	it("leaves the stored start as it is", () => {
+		const before = draft();
+		const patch = patchFromDrafts(
+			before,
+			{ ...before, endTime: "11:00" },
+			IN_AMSTERDAM,
+		);
+		assert.ok(patch.ok);
+		assert.equal(patch.patch.start, undefined);
+		assert.equal(patch.patch.end, "2026-06-10T11:00:00+02:00");
+	});
+});
+
+/**
+ * An event stored as the UTC instant 2026-06-15T01:00Z: Sunday 21:00 in New
+ * York, Monday 03:00 in Amsterdam. The server expands its rule in UTC, where
+ * it is a Monday, whichever device picked the rule.
+ */
+describe("a repeat added to an event stored in UTC", () => {
+	const inUtc = (clock: string) => ({ clock, anchor: "" });
+
+	it("is stored on the UTC day from a New York device", () => {
+		const before = draft({
+			date: "2026-06-14",
+			endDate: "2026-06-14",
+			startTime: "21:00",
+			endTime: "22:00",
+		});
+		const patch = patchFromDrafts(
+			before,
+			{ ...before, repeat: "Every week on Sunday, 21:00" },
+			inUtc(NEW_YORK),
+		);
+		assert.ok(patch.ok);
+		assert.deepEqual(patch.patch, { recurrenceRule: "FREQ=WEEKLY;BYDAY=MO" });
+	});
+
+	it("is stored on the UTC day from an Amsterdam device", () => {
+		const before = draft({
+			date: "2026-06-15",
+			endDate: "2026-06-15",
+			startTime: "03:00",
+			endTime: "04:00",
+		});
+		const patch = patchFromDrafts(
+			before,
+			{ ...before, repeat: "Every week on Monday, 03:00" },
+			inUtc(AMSTERDAM),
+		);
+		assert.ok(patch.ok);
+		assert.deepEqual(patch.patch, { recurrenceRule: "FREQ=WEEKLY;BYDAY=MO" });
+	});
+
+	it("stays anchored in UTC when its time moves", () => {
+		const before = draft({
+			date: "2026-06-14",
+			endDate: "2026-06-14",
+			startTime: "21:00",
+			endTime: "22:00",
+		});
+		const patch = patchFromDrafts(
+			before,
+			{ ...before, startTime: "21:30" },
+			inUtc(NEW_YORK),
+		);
+		assert.ok(patch.ok);
+		assert.equal(patch.patch.start, "2026-06-14T21:30:00-04:00");
+		assert.equal(patch.patch.timeZone, undefined);
+	});
+});

package/src/hooks/calendar/draft.ts

@@ -14,11 +14,23 @@ import type {
 	RemitImapUpdateCalendarEventInput,
 } from "@remit/api-http-client/types.gen.ts";
 import { type CalendarEventData, type EventDraft, lastDayOf } from "@remit/ui";
-import { rruleFromText } from "./recurrence-rule";
-import { addDays, isoAtInZone } from "./window";
+import { moveRule, rruleFromText } from "./recurrence-rule";
+import { addDays, isoAtInZone, isoOnClock } from "./window";
 
 export type DraftRefusal = { ok: false; problem: string };
 
+/**
+ * The two zones a write needs. `clock` is the one the form's digits were read
+ * on — the device's, which every surface draws on — and it decides the offset,
+ * so the instant saved is the instant shown. `anchor` is the zone the event is
+ * stored in, written as the TZID a series keeps its wall time in across a DST
+ * change (`anchorZoneFor`); `""` anchors it in UTC.
+ */
+export interface DraftZones {
+	clock: string;
+	anchor: string;
+}
+
 export type CreateInput =
 	| { ok: true; input: RemitImapCreateCalendarEventInput }
 	| DraftRefusal;
@@ -69,26 +81,41 @@ export function draftFromEvent(
 }
 
 /**
- * The draft's wall clock, pinned to an instant in the calendar's own zone.
- *
- * The zone is the calendar's rather than the device's because that is the clock
- * the times were read on: the listing returns an occurrence in the collection's
- * zone, and the form shows those digits. Stamping the device's offset back onto
- * them moves the event by the difference between the two — silently, and only
- * for whoever is travelling.
+ * The draft's wall clock, pinned to an instant on the clock it was read on.
+ * Stamping any other zone's offset onto those digits moves the event by the
+ * difference between the two — silently, and only for whoever is travelling.
  */
 function timesFor(
 	draft: EventDraft,
-	timeZone: string,
+	clock: string,
 ): { start: string; end: string } {
 	if (draft.allDay)
 		return { start: draft.date, end: addDays(draft.endDate, 1) };
 	return {
-		start: isoAtInZone(draft.date, draft.startTime, timeZone),
-		end: isoAtInZone(draft.endDate, draft.endTime, timeZone),
+		start: isoAtInZone(draft.date, draft.startTime, clock),
+		end: isoAtInZone(draft.endDate, draft.endTime, clock),
 	};
 }
 
+/**
+ * The picked rule, stored on the day the event's own zone starts it on rather
+ * than on the day the device showed when it was picked.
+ */
+function storedRule(
+	draft: EventDraft,
+	start: string,
+	zones: DraftZones,
+): string {
+	const rule = rruleFromText(draft.repeat) ?? "";
+	const anchorDate = draft.allDay
+		? draft.date
+		: isoOnClock(start, zones.anchor === "" ? "UTC" : zones.anchor).slice(
+				0,
+				10,
+			);
+	return moveRule(rule, draft.date, anchorDate);
+}
+
 /**
  * An unreadable rule is only a refusal where the reader chose it. An event that
  * arrived carrying a rule this client cannot put into words is still editable —
@@ -116,11 +143,11 @@ function refuse(draft: EventDraft, checkRepeat: boolean): string {
 
 export function createInputFromDraft(
 	draft: EventDraft,
-	timeZone: string,
+	zones: DraftZones,
 ): CreateInput {
 	const problem = refuse(draft, true);
 	if (problem !== "") return { ok: false, problem };
-	const { start, end } = timesFor(draft, timeZone);
+	const { start, end } = timesFor(draft, zones.clock);
 	return {
 		ok: true,
 		input: {
@@ -131,11 +158,8 @@ export function createInputFromDraft(
 			start,
 			end,
 			allDay: draft.allDay,
-			// Absent anchors the event in UTC, which is exactly what a collection
-			// naming no zone means. There is no spelling of UTC the server takes
-			// as a TZID, so sending one instead is not an option.
-			...(timeZone === "" ? {} : { timeZone }),
-			recurrenceRule: rruleFromText(draft.repeat) ?? "",
+			...(zones.anchor === "" ? {} : { timeZone: zones.anchor }),
+			recurrenceRule: storedRule(draft, start, zones),
 		},
 	};
 }
@@ -143,9 +167,18 @@ export function createInputFromDraft(
 export function patchFromDrafts(
 	before: EventDraft,
 	after: EventDraft,
-	timeZone: string,
+	zones: DraftZones,
 ): UpdatePatch {
 	const repeatChanged = after.repeat !== before.repeat;
+	const allDayChanged = after.allDay !== before.allDay;
+	const startMoved =
+		allDayChanged ||
+		after.date !== before.date ||
+		after.startTime !== before.startTime;
+	const endMoved =
+		startMoved ||
+		after.endDate !== before.endDate ||
+		after.endTime !== before.endTime;
 	const problem = refuse(after, repeatChanged);
 	if (problem !== "") return { ok: false, problem };
 
@@ -155,24 +188,17 @@ export function patchFromDrafts(
 	if (after.location !== before.location) patch.location = after.location;
 	if (after.notes !== before.notes) patch.description = after.notes;
 
-	const moved =
-		after.date !== before.date ||
-		after.startTime !== before.startTime ||
-		after.endDate !== before.endDate ||
-		after.endTime !== before.endTime ||
-		after.allDay !== before.allDay;
-	if (moved) {
-		const { start, end } = timesFor(after, timeZone);
-		patch.start = start;
+	const { start, end } = timesFor(after, zones.clock);
+	if (startMoved) patch.start = start;
+	if (endMoved) {
 		patch.end = end;
 		patch.allDay = after.allDay;
 		// The offset pins the instant; the zone is what a series needs to keep
-		// meeting at nine when the clocks go back. A collection with none of its
-		// own says so by sending nothing.
-		if (timeZone !== "") patch.timeZone = timeZone;
+		// meeting at nine when the clocks go back.
+		if (zones.anchor !== "") patch.timeZone = zones.anchor;
 	}
 
-	if (repeatChanged) patch.recurrenceRule = rruleFromText(after.repeat) ?? "";
+	if (repeatChanged) patch.recurrenceRule = storedRule(after, start, zones);
 
 	return { ok: true, patch };
 }

package/src/hooks/calendar/index.ts

@@ -30,12 +30,14 @@ export {
 	type CreateInput,
 	createInputFromDraft,
 	type DraftRefusal,
+	type DraftZones,
 	draftFromEvent,
 	emptyDraft,
 	patchFromDrafts,
 	type UpdatePatch,
 } from "./draft";
 export {
+	anchorZoneFor,
 	type CalendarInstanceRef,
 	calendarInstanceId,
 	deviceTimeZone,
@@ -45,10 +47,11 @@ export {
 	toCalendarEventData,
 	UNZONED_CALENDAR,
 } from "./instance";
-export { rruleFromText, textFromRrule } from "./recurrence-rule";
+export { moveRule, rruleFromText, textFromRrule } from "./recurrence-rule";
 export {
 	type CalendarResourceText,
 	rruleFromIcalData,
+	storedAnchorZone,
 	textFromIcalData,
 } from "./resource";
 export {
@@ -103,5 +106,6 @@ export {
 	calendarWindowOfDays,
 	isoAt,
 	isoAtInZone,
+	isoOnClock,
 	startOfDay,
 } from "./window";

package/src/hooks/calendar/instance.test.ts

@@ -0,0 +1,70 @@
+/** An occurrence as the calendar draws it, and the zone a write anchors it in. */
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { RemitImapCalendarEventInstance } from "@remit/api-http-client/types.gen.ts";
+import { anchorZoneFor, toCalendarEventData } from "./instance";
+
+const instance = (
+	over: Partial<RemitImapCalendarEventInstance>,
+): RemitImapCalendarEventInstance =>
+	({
+		calendarId: "cal_work",
+		calendarObjectId: "obj_1",
+		recurrenceId: "",
+		icalUid: "uid-1",
+		summary: "Audit day",
+		start: "2034-03-01T00:00:00+09:00",
+		end: "2034-03-02T00:00:00+09:00",
+		allDay: true,
+		status: "Confirmed",
+		transparency: "Opaque",
+		zoneCertainty: "Explicit",
+		etag: "etag-1",
+		hasRecurrence: false,
+		...over,
+	}) as RemitImapCalendarEventInstance;
+
+describe("an occurrence drawn on a device", () => {
+	it("keeps an all-day occurrence on its civil date wherever the device is", () => {
+		const drawn = toCalendarEventData(
+			instance({}),
+			"Asia/Tokyo",
+			"Pacific/Pago_Pago",
+		);
+		assert.equal(drawn.start, "2034-03-01");
+		assert.equal(drawn.end, "2034-03-02");
+	});
+
+	it("re-reads a timed occurrence on the device's clock", () => {
+		const drawn = toCalendarEventData(
+			instance({
+				allDay: false,
+				start: "2034-02-22T08:00:00+09:00",
+				end: "2034-02-22T09:00:00+09:00",
+			}),
+			"Asia/Tokyo",
+			"America/New_York",
+		);
+		assert.equal(drawn.start, "2034-02-21T18:00:00-05:00");
+		assert.equal(drawn.end, "2034-02-21T19:00:00-05:00");
+	});
+});
+
+describe("the zone a write anchors an event in", () => {
+	it("is the collection's where it names one", () => {
+		assert.equal(anchorZoneFor("Asia/Tokyo"), "Asia/Tokyo");
+	});
+
+	it("is the device's where the collection names none, and nothing on UTC", () => {
+		const runner = process.env.TZ;
+		try {
+			process.env.TZ = "America/New_York";
+			assert.equal(anchorZoneFor(""), "America/New_York");
+			process.env.TZ = "UTC";
+			assert.equal(anchorZoneFor(""), "");
+		} finally {
+			if (runner === undefined) Reflect.deleteProperty(process.env, "TZ");
+			else process.env.TZ = runner;
+		}
+	});
+});