@cosmicdrift/kumiko-framework 0.327.0 → 0.328.1

package/src/testing/wait-for.ts

@@ -1,49 +0,0 @@
-/**
- * Polls a condition with escalating timeouts.
- *
- * Default schedule: 250ms → 1s → 3s between attempts. Tries first (already-true
- * returns immediately), then sleeps `delays[i]` after each failure before the
- * next try — so N delays yield N+1 attempts and the full backoff budget.
- * Throws the last assertion error if all attempts fail.
- *
- * Usage (assertion form):
- *   await waitFor(() => {
- *     expect(events).toHaveLength(1);
- *   });
- *
- * Usage (predicate form — a literal `false` return means "not yet", anything
- * else, including `undefined`, counts as success):
- *   await waitFor(() => events.length >= 4);
- */
-export async function waitFor(
-  // biome-ignore lint/suspicious/noConfusingVoidType: void must stay in the union so the existing expect(...) block form (implicit void return) still type-checks
-  fn: () => void | boolean | Promise<void | boolean>,
-  options?: { delays?: number[] },
-): Promise<void> {
-  const delays = options?.delays ?? [250, 1000, 3000];
-  if (delays.length === 0) {
-    throw new Error("waitFor: empty delay schedule");
-  }
-  let lastError: unknown;
-
-  for (let i = 0; ; i++) {
-    try {
-      const result = await fn();
-      if (result !== false) {
-        // skip: condition already true — no further polling
-        return;
-      }
-    } catch (err) {
-      lastError = err;
-    }
-    if (i >= delays.length) {
-      break;
-    }
-    await new Promise((r) => setTimeout(r, delays[i]));
-  }
-
-  if (lastError !== undefined) {
-    throw lastError;
-  }
-  throw new Error("waitFor: condition never became true within the delay schedule");
-}

package/src/testing/without-ambient-temporal.ts

@@ -1,14 +0,0 @@
-/**
- * Run `fn` with `globalThis.Temporal` deleted, then restore.
- * Used by ambient-independence regression tests (kumiko-framework#1525/#1550).
- */
-export async function withoutAmbientTemporal<T>(fn: () => T | Promise<T>): Promise<T> {
-  const savedGlobal = (globalThis as { Temporal?: unknown }).Temporal;
-  delete (globalThis as { Temporal?: unknown }).Temporal;
-  try {
-    return await fn();
-  } finally {
-    if (savedGlobal === undefined) delete (globalThis as { Temporal?: unknown }).Temporal;
-    else (globalThis as { Temporal?: unknown }).Temporal = savedGlobal;
-  }
-}

package/src/time/__tests__/boot-tz-warning.test.ts

@@ -1,46 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { warnIfNonUtcServerTimeZone } from "../boot-tz-warning";
-
-describe("warnIfNonUtcServerTimeZone", () => {
-  test("warnt nicht wenn die Prozess-TZ UTC ist", () => {
-    const messages: string[] = [];
-    const warned = warnIfNonUtcServerTimeZone("UTC", (m) => messages.push(m));
-    expect(warned).toBe(false);
-    expect(messages).toHaveLength(0);
-  });
-
-  test.each(["GMT", "Etc/UTC"])("warnt nicht bei UTC-äquivalenter Zone %s", (zone) => {
-    const messages: string[] = [];
-    const warned = warnIfNonUtcServerTimeZone(zone, (m) => messages.push(m));
-    expect(warned).toBe(false);
-    expect(messages).toHaveLength(0);
-  });
-
-  test("warnt bei nicht-UTC Zone, nennt Zone + UTC-Hinweis", () => {
-    const messages: string[] = [];
-    const warned = warnIfNonUtcServerTimeZone("Europe/Berlin", (m) => messages.push(m));
-    expect(warned).toBe(true);
-    expect(messages).toHaveLength(1);
-    expect(messages[0]).toContain("Europe/Berlin");
-    expect(messages[0]).toContain("UTC");
-  });
-
-  test("Default-Aufruf liest die ECHTE Prozess-TZ (ambient, nicht injiziert)", () => {
-    // Das ist der einzige Test der ambient-TZ liest statt sie zu injizieren —
-    // der Grund warum der tz-matrix-CI-Job (4 Legs: LA/Berlin/Tokyo/Apia)
-    // überhaupt einen Unterschied zwischen den Legs sehen kann. Ohne diese
-    // Assertion wäre "läuft in jeder Zone ohne zu werfen" in allen 4 Legs
-    // identisch grün — die beworbene Schutzwirkung ("ein `new Date(wallClock)`-
-    // Bug bricht HIER") würde nicht existieren.
-    const ambientTz = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    const messages: string[] = [];
-    const warned = warnIfNonUtcServerTimeZone(undefined, (m) => messages.push(m));
-    if (ambientTz === "UTC") {
-      expect(warned).toBe(false);
-      expect(messages).toHaveLength(0);
-    } else {
-      expect(warned).toBe(true);
-      expect(messages[0]).toContain(ambientTz);
-    }
-  });
-});

package/src/time/__tests__/geo-tz.test.ts

@@ -1,71 +0,0 @@
-// ctx.tz.fromCoordinates / fromAddress — der GeoTzProvider-Injection-Seam.
-// Das Framework liefert nur Interface + Delegation; ohne Provider wird klar
-// geworfen statt still zu raten.
-
-import { beforeAll, describe, expect, test } from "bun:test";
-import type { GeoTzProvider } from "../geo-tz";
-import { ensureTemporalPolyfill } from "../polyfill";
-import { createTzContext } from "../tz-context";
-
-beforeAll(async () => {
-  await ensureTemporalPolyfill();
-});
-
-const BERLIN = { latitude: 52.52, longitude: 13.405 };
-
-describe("ctx.tz — GeoTzProvider seam", () => {
-  test("fromCoordinates delegiert an den Provider (sync)", async () => {
-    const provider: GeoTzProvider = { fromCoordinates: () => "Europe/Berlin" };
-    const tz = createTzContext({ geoTz: provider });
-    expect(await tz.fromCoordinates(BERLIN)).toBe("Europe/Berlin");
-  });
-
-  test("fromCoordinates delegiert an den Provider (async)", async () => {
-    const provider: GeoTzProvider = { fromCoordinates: async () => "Asia/Tokyo" };
-    const tz = createTzContext({ geoTz: provider });
-    expect(await tz.fromCoordinates({ latitude: 35.68, longitude: 139.69 })).toBe("Asia/Tokyo");
-  });
-
-  test("fromCoordinates reicht die Koordinaten unverändert durch", async () => {
-    let seen: { latitude: number; longitude: number } | undefined;
-    const provider: GeoTzProvider = {
-      fromCoordinates: (c) => {
-        seen = c;
-        return "Europe/Berlin";
-      },
-    };
-    await createTzContext({ geoTz: provider }).fromCoordinates(BERLIN);
-    expect(seen).toEqual(BERLIN);
-  });
-
-  test("fromCoordinates wirft ohne Provider", async () => {
-    const tz = createTzContext();
-    await expect(tz.fromCoordinates(BERLIN)).rejects.toThrow(/GeoTzProvider/);
-  });
-
-  test("fromAddress delegiert wenn der Provider es unterstützt", async () => {
-    const provider: GeoTzProvider = {
-      fromCoordinates: () => "UTC",
-      fromAddress: (a) => (a.country === "PT" ? "Europe/Lisbon" : "UTC"),
-    };
-    const tz = createTzContext({ geoTz: provider });
-    expect(await tz.fromAddress({ country: "PT" })).toBe("Europe/Lisbon");
-  });
-
-  test("fromAddress wirft wenn der Provider kein fromAddress hat (offline lat/lng)", async () => {
-    const provider: GeoTzProvider = { fromCoordinates: () => "UTC" };
-    const tz = createTzContext({ geoTz: provider });
-    // Regression (680/2): this message must say the PROVIDER lacks
-    // fromAddress, not the misleading "no provider configured" message.
-    await expect(tz.fromAddress({ country: "PT" })).rejects.toThrow(
-      /GeoTzProvider that implements fromAddress/,
-    );
-  });
-
-  test("fromAddress wirft ohne Provider — eigene Message, nicht die Provider-ohne-fromAddress-Message", async () => {
-    const tz = createTzContext();
-    await expect(tz.fromAddress({ country: "PT" })).rejects.toThrow(
-      /requires a GeoTzProvider — inject one/,
-    );
-  });
-});

package/src/time/__tests__/iana.test.ts

@@ -1,35 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { isValidIanaTimeZone } from "../iana";
-
-describe("isValidIanaTimeZone", () => {
-  // Die 5 Zonen der geplanten CI-TZ-Matrix (timezones.md) müssen alle gültig
-  // sein — sonst kann die Matrix sie nicht setzen.
-  test.each(["UTC", "Europe/Berlin", "America/Los_Angeles", "Asia/Tokyo", "Pacific/Apia"])(
-    "akzeptiert kanonische Zone %s",
-    (zone) => {
-      expect(isValidIanaTimeZone(zone)).toBe(true);
-    },
-  );
-
-  test.each(["", "Mars/Phobos", "europe/berlin", "Europe/Berlin ", "GMT+2", "not-a-zone"])(
-    "lehnt ungültigen / nicht-kanonischen String %p ab",
-    (value) => {
-      expect(isValidIanaTimeZone(value)).toBe(false);
-    },
-  );
-
-  // Intl.supportedValuesOf("timeZone") listet nur kanonische Namen — gültige
-  // IANA-Aliase fehlen darin, obwohl Intl.DateTimeFormat/Temporal/ctx.tz.parse
-  // sie klaglos akzeptieren. Ein valider Alias darf hier nicht als "invalid"
-  // rejected werden (stiller Breaking-Change für Consumer, die Alias-Zonen
-  // speichern).
-  test.each(["US/Pacific", "GMT", "Etc/UTC"])("akzeptiert gültigen IANA-Alias %s", (zone) => {
-    expect(isValidIanaTimeZone(zone)).toBe(true);
-  });
-
-  test("liefert über mehrere Aufrufe konsistent (lazy Set gecacht)", () => {
-    expect(isValidIanaTimeZone("Europe/Berlin")).toBe(true);
-    expect(isValidIanaTimeZone("Europe/Berlin")).toBe(true);
-    expect(isValidIanaTimeZone("Mars/Phobos")).toBe(false);
-  });
-});

package/src/time/__tests__/polyfill-reinstall.test.ts

@@ -1,17 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { withoutAmbientTemporal } from "../../testing/without-ambient-temporal";
-import { ensureTemporalPolyfill, getTemporal } from "../polyfill";
-
-describe("ensureTemporalPolyfill — re-install after teardown", () => {
-  test("re-assigns globalThis.Temporal after delete", async () => {
-    await ensureTemporalPolyfill();
-    expect("Temporal" in globalThis).toBe(true);
-
-    await withoutAmbientTemporal(async () => {
-      expect("Temporal" in globalThis).toBe(false);
-      await ensureTemporalPolyfill();
-      expect("Temporal" in globalThis).toBe(true);
-      expect(getTemporal().Now.instant().toString()).toMatch(/Z$/);
-    });
-  });
-});

package/src/time/__tests__/polyfill.test.ts

@@ -1,73 +0,0 @@
-// Smoke-Test für die Temporal-Polyfill-Initialisierung.
-// Sicher dass nach ensureTemporalPolyfill() die wichtigsten Temporal-Typen
-// (Instant, PlainDate, ZonedDateTime) konstruktor-fähig sind.
-
-import { describe, expect, test } from "bun:test";
-import { ensureTemporalPolyfill, getTemporal } from "../polyfill";
-
-describe("Temporal Polyfill", () => {
-  test("ensureTemporalPolyfill ist idempotent + Temporal nach dreifachem Aufruf nutzbar", async () => {
-    await ensureTemporalPolyfill();
-    await ensureTemporalPolyfill();
-    await ensureTemporalPolyfill();
-    // Idempotenz beweisen: nach mehrfachem Aufruf muss Temporal weiterhin
-    // konstruktor-fähig sein (kein zerstörter global state, kein verschütteter
-    // Singleton).
-    const T = getTemporal();
-    expect(T.Instant.from("2026-04-18T10:00:00Z").epochMilliseconds).toBe(
-      Date.UTC(2026, 3, 18, 10, 0, 0),
-    );
-  });
-
-  test("Temporal.Instant ist nach Polyfill konstruktor-fähig", async () => {
-    await ensureTemporalPolyfill();
-    const T = getTemporal();
-    const instant = T.Instant.from("2026-04-18T10:00:00Z");
-    expect(instant.toString()).toBe("2026-04-18T10:00:00Z");
-  });
-
-  test("Temporal.PlainDate funktioniert", async () => {
-    await ensureTemporalPolyfill();
-    const T = getTemporal();
-    const date = T.PlainDate.from("2026-04-18");
-    expect(date.toString()).toBe("2026-04-18");
-    expect(date.year).toBe(2026);
-    expect(date.month).toBe(4);
-    expect(date.day).toBe(18);
-  });
-
-  test("Temporal.ZonedDateTime mit IANA-Zone (Europe/Lisbon) funktioniert", async () => {
-    await ensureTemporalPolyfill();
-    const T = getTemporal();
-    const zdt = T.ZonedDateTime.from("2026-04-18T10:00:00[Europe/Lisbon]");
-    expect(zdt.timeZoneId).toBe("Europe/Lisbon");
-    expect(zdt.hour).toBe(10);
-    // Lisbon ist im April auf WEST (UTC+1 wegen DST), deshalb 09:00 UTC.
-    expect(zdt.toInstant().toString()).toBe("2026-04-18T09:00:00Z");
-  });
-
-  test("DST-Übergang 2026-03-29 02:30 Europe/Berlin existiert nicht", async () => {
-    await ensureTemporalPolyfill();
-    const T = getTemporal();
-    // Deutschland Spring-Forward 2026: 02:00 → 03:00 in der Nacht 28→29 März.
-    // 02:30 existiert NICHT in Berlin-TZ. Temporal handhabt das via
-    // `disambiguation: "reject"` korrekt.
-    expect(() =>
-      T.ZonedDateTime.from(
-        { year: 2026, month: 3, day: 29, hour: 2, minute: 30, timeZone: "Europe/Berlin" },
-        { disambiguation: "reject" },
-      ),
-    ).toThrow();
-  });
-
-  test("getTemporal vor Polyfill-Init throwt wenn Native fehlt", () => {
-    // Note: in unserem Test-Run ist Temporal nach dem ersten ensureTemporalPolyfill()
-    // schon installiert (Module-Singleton). Daher prüfen wir das `throws`-Verhalten
-    // nur indirekt über die Implementierung — direkter Test wäre flaky weil
-    // global state geteilt wird.
-    // Stattdessen: einfach sicherstellen dass nach Init getTemporal nicht throwt.
-    const T = getTemporal();
-    expect(T).toBeDefined();
-    expect(typeof T.Instant.from).toBe("function");
-  });
-});

package/src/time/__tests__/tz-context.test.ts

@@ -1,121 +0,0 @@
-// Unit-Tests für ctx.tz API.
-// Test-Fokus: korrekte Konvertierung Wall-Clock+TZ ↔ Instant ↔ JSON-Pair.
-
-import { beforeAll, describe, expect, test } from "bun:test";
-import { ensureTemporalPolyfill } from "../polyfill";
-import { createTzContext } from "../tz-context";
-
-beforeAll(async () => {
-  await ensureTemporalPolyfill();
-});
-
-describe("ctx.tz — defaults", () => {
-  test("ohne Options: tenant + user beide UTC", () => {
-    const tz = createTzContext();
-    expect(tz.tenant).toBe("UTC");
-    expect(tz.user).toBe("UTC");
-  });
-
-  test("nur tenant gesetzt: user fällt auf tenant zurück", () => {
-    const tz = createTzContext({ tenant: "Europe/Berlin" });
-    expect(tz.tenant).toBe("Europe/Berlin");
-    expect(tz.user).toBe("Europe/Berlin");
-  });
-
-  test("user-Override sticht tenant", () => {
-    const tz = createTzContext({ tenant: "Europe/Berlin", user: "Asia/Tokyo" });
-    expect(tz.tenant).toBe("Europe/Berlin");
-    expect(tz.user).toBe("Asia/Tokyo");
-  });
-});
-
-describe("ctx.tz — now / today", () => {
-  test("now() liefert Temporal.Instant", () => {
-    const tz = createTzContext();
-    const instant = tz.now();
-    expect(typeof instant.epochMilliseconds).toBe("number");
-    // Sollte nahe an aktueller Wall-Time sein (innerhalb 5 Sekunden).
-    expect(Math.abs(instant.epochMilliseconds - Date.now())).toBeLessThan(5000);
-  });
-
-  test("nowIn(tz) liefert ZonedDateTime in der richtigen Zone", () => {
-    const tz = createTzContext();
-    const zdt = tz.nowIn("Europe/Berlin");
-    expect(zdt.timeZoneId).toBe("Europe/Berlin");
-  });
-
-  test("today(tz) liefert PlainDate ohne Zeit-Komponente", () => {
-    const tz = createTzContext();
-    const today = tz.today("Europe/Lisbon");
-    // PlainDate hat keine .hour-Property — wenn es eines hätte, wäre's ein
-    // ZonedDateTime und der Test würde TypeError werfen.
-    expect("hour" in today).toBe(false);
-    expect(today.toString()).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-  });
-
-  test("todayRange(tz) liefert UTC-Instants für DB-Range-Query", () => {
-    const tz = createTzContext();
-    const range = tz.todayRange("Europe/Berlin");
-    // Differenz zwischen start + end ist genau 24h (oder 23/25h bei DST).
-    const diffHours =
-      (range.end.epochMilliseconds - range.start.epochMilliseconds) / (1000 * 60 * 60);
-    expect(diffHours).toBeGreaterThanOrEqual(23);
-    expect(diffHours).toBeLessThanOrEqual(25);
-  });
-});
-
-describe("ctx.tz — parse + JSON-Pair Konvertierungen", () => {
-  test("parse(wallClock, tz) liefert ZonedDateTime mit korrekter UTC-Konvertierung", () => {
-    const tz = createTzContext();
-    // 2026-04-03 10:00 Lisbon = 09:00 UTC (WEST = UTC+1)
-    const zdt = tz.parse("2026-04-03T10:00:00", "Europe/Lisbon");
-    expect(zdt.timeZoneId).toBe("Europe/Lisbon");
-    expect(zdt.toInstant().toString()).toBe("2026-04-03T09:00:00Z");
-  });
-
-  test("toLocatedJson(zdt) liefert { at, tz } OHNE Offset-Marker", () => {
-    const tz = createTzContext();
-    const zdt = tz.parse("2026-04-03T10:00:00", "Europe/Lisbon");
-    const json = tz.toLocatedJson(zdt);
-    expect(json).toEqual({ at: "2026-04-03T10:00:00", tz: "Europe/Lisbon" });
-    // Kein "Z", kein "+01:00" im at-Feld — sonst ist die JSON-Form nicht
-    // mehr idiotensicher.
-    expect(json.at).not.toContain("Z");
-    expect(json.at).not.toContain("+");
-  });
-
-  test("fromLocatedJson({ at, tz }) ist Inverse zu toLocatedJson", () => {
-    const tz = createTzContext();
-    const original = tz.parse("2026-04-03T10:00:00", "Europe/Lisbon");
-    const json = tz.toLocatedJson(original);
-    const restored = tz.fromLocatedJson(json);
-    expect(restored.toInstant().equals(original.toInstant())).toBe(true);
-    expect(restored.timeZoneId).toBe(original.timeZoneId);
-  });
-
-  test("Round-Trip funktioniert über DST-Übergang (Lisbon-Sommerzeit-Ende)", () => {
-    const tz = createTzContext();
-    // 2026-10-25 in Lisbon: Fall-Back von 02:00 → 01:00. Wir nehmen 14:00,
-    // was eindeutig im WET ist (UTC+0).
-    const zdt = tz.parse("2026-10-25T14:00:00", "Europe/Lisbon");
-    const json = tz.toLocatedJson(zdt);
-    expect(json.at).toBe("2026-10-25T14:00:00");
-    expect(json.tz).toBe("Europe/Lisbon");
-    const restored = tz.fromLocatedJson(json);
-    // Nach DST-Wechsel ist Lisbon UTC+0 → 14:00 lokal = 14:00 UTC.
-    expect(restored.toInstant().toString()).toBe("2026-10-25T14:00:00Z");
-  });
-});
-
-describe("ctx.tz — Cross-Server-TZ Garantie", () => {
-  test("derselbe Wall-Clock+TZ liefert denselben UTC-Instant unabhängig vom Server-TZ", () => {
-    // Das ist der Kern der Migration: ein Server in Berlin und einer in
-    // Tokyo schicken denselben "Pickup 10:00 Lissabon" — beide müssen den
-    // gleichen UTC-Instant produzieren. Temporal erfüllt das per Design,
-    // wir prüfen es zur Sicherheit.
-    const tz = createTzContext();
-    const zdt1 = tz.parse("2026-04-03T10:00:00", "Europe/Lisbon");
-    const zdt2 = tz.fromLocatedJson({ at: "2026-04-03T10:00:00", tz: "Europe/Lisbon" });
-    expect(zdt1.toInstant().equals(zdt2.toInstant())).toBe(true);
-  });
-});

package/src/time/__tests__/tz-dateline.test.ts

@@ -1,34 +0,0 @@
-// Pacific/Apia sits far east of the dateline at UTC+13/+14 — a morning wall
-// clock there falls on the PREVIOUS UTC calendar day. Phrased as a date-
-// ordering property (not a fixed offset) so the test stays green regardless
-// of the tzdata DST view (UTC+13 and +14 both push 10:00 to the prior day).
-
-import { beforeAll, describe, expect, test } from "bun:test";
-import { ensureTemporalPolyfill } from "../polyfill";
-import { createTzContext } from "../tz-context";
-
-beforeAll(async () => {
-  await ensureTemporalPolyfill();
-});
-
-describe("ctx.tz — Pacific/Apia dateline", () => {
-  test("a morning wall clock in Apia maps to the previous UTC calendar day", () => {
-    const tz = createTzContext();
-    const zdt = tz.parse("2026-01-15T10:00:00", "Pacific/Apia");
-    expect(zdt.timeZoneId).toBe("Pacific/Apia");
-
-    const utcDate = zdt.toInstant().toZonedDateTimeISO("UTC").toPlainDate().toString();
-    expect(utcDate).toBe("2026-01-14");
-
-    // Offset is a large positive value (UTC+13 or +14).
-    expect(zdt.offsetNanoseconds).toBeGreaterThan(12 * 3600 * 1e9);
-  });
-
-  test("round-trip preserves wall clock + instant across the dateline", () => {
-    const tz = createTzContext();
-    const original = tz.parse("2026-01-15T10:00:00", "Pacific/Apia");
-    const restored = tz.fromLocatedJson(tz.toLocatedJson(original));
-    expect(restored.toInstant().equals(original.toInstant())).toBe(true);
-    expect(restored.timeZoneId).toBe("Pacific/Apia");
-  });
-});

package/src/time/boot-tz-warning.ts

@@ -1,30 +0,0 @@
-// Boot-Warnung wenn die Prozess-Uhr nicht in UTC läuft. Der gesamte
-// Server-Code nimmt UTC an (System-TZ ist kein Konzept — siehe timezones.md);
-// eine abweichende Prozess-TZ lässt versehentliche new Date()-Pfade
-// lokal-abhängig brechen ("grün in UTC-CI, kaputt in Berlin-Prod"). Soft:
-// nicht-UTC ist in Dev legitim, daher Warnung statt Boot-Fehler.
-
-function resolvedServerTimeZone(): string {
-  return Intl.DateTimeFormat().resolvedOptions().timeZone;
-}
-
-/**
- * Warnt einmalig beim Server-Start, wenn die Prozess-TZ nicht UTC ist.
- * Parameter sind für Tests injizierbar. Gibt zurück, ob gewarnt wurde.
- */
-export function warnIfNonUtcServerTimeZone(
-  resolvedTimeZone: string = resolvedServerTimeZone(),
-  // biome-ignore lint/suspicious/noConsole: boot-time warning, no logger wired this early
-  warn: (message: string) => void = console.warn,
-): boolean {
-  // GMT and Etc/UTC are UTC-equivalent (no offset, no DST) — TZ=GMT is a
-  // legitimate way to pin a process to UTC and must not trip this warning.
-  if (resolvedTimeZone === "UTC" || resolvedTimeZone === "GMT" || resolvedTimeZone === "Etc/UTC") {
-    return false;
-  }
-  warn(
-    `[kumiko] Server time zone is "${resolvedTimeZone}" — the framework assumes UTC. ` +
-      "Set TZ=UTC for the server process to avoid time-zone-dependent bugs.",
-  );
-  return true;
-}

package/src/time/iana.ts

@@ -1,19 +0,0 @@
-// IANA-Zonenname-Validierung. Intl.supportedValuesOf("timeZone") liefert nur
-// KANONISCHE Namen — gültige Aliase wie "US/Pacific", "GMT", "Etc/UTC" fehlen
-// darin, obwohl Intl.DateTimeFormat, Temporal und ctx.tz.parse sie alle
-// klaglos akzeptieren. Intl.DateTimeFormat selbst ist aber case-INSENSITIVE
-// ("europe/berlin" resolved klaglos zu "Europe/Berlin") — ein reines
-// try/catch würde also Tippfehler in der Groß-/Kleinschreibung durchlassen.
-// Der exakte Vergleich mit resolvedOptions().timeZone schließt das: ein
-// gültiger kanonischer Name ODER Alias resolved IMMER zu sich selbst
-// (empirisch verifiziert für US/Pacific, GMT, Etc/UTC), ein falsch-gecasteter
-// String resolved zur kanonischen Form und matcht damit nicht mehr exakt.
-export function isValidIanaTimeZone(value: string): boolean {
-  try {
-    return (
-      new Intl.DateTimeFormat(undefined, { timeZone: value }).resolvedOptions().timeZone === value
-    );
-  } catch {
-    return false;
-  }
-}

package/src/time/index.ts

@@ -1,23 +0,0 @@
-// Time-Modul: Temporal-Polyfill + ctx.tz Helper.
-//
-// Aktueller Stand (Iteration 1-4 von Gap-03 in samples/beammycar/MIGRATION.md):
-//   - ensureTemporalPolyfill: installiert Temporal global wenn nötig
-//   - getTemporal: type-safer Zugriff auf globalThis.Temporal
-//   - createTzContext: ctx.tz Factory mit now/today/parse/toLocatedJson/...
-//   - LocatedTimestampJson: API-Boundary-Form { at, tz }
-//   - isValidIanaTimeZone: IANA-Zonennamen-Validierung (type:"tz"-Felder)
-//   - warnIfNonUtcServerTimeZone: Boot-Warnung bei nicht-UTC Prozess-TZ
-//   - GeoTzProvider: optionaler Geo→Zone-Adapter (ctx.tz.fromCoordinates/fromAddress)
-
-export { warnIfNonUtcServerTimeZone } from "./boot-tz-warning";
-export type { GeoAddress, GeoCoordinates, GeoTzProvider } from "./geo-tz";
-export { isValidIanaTimeZone } from "./iana";
-export { instantToLegacyDate, legacyDateToInstant } from "./legacy-date";
-export { ensureTemporalPolyfill, getTemporal } from "./polyfill";
-export {
-  createTzContext,
-  createTzContextAsync,
-  type LocatedTimestampJson,
-  type TzContext,
-  type TzContextOptions,
-} from "./tz-context";

package/src/time/legacy-date.ts

@@ -1,18 +0,0 @@
-import { Temporal } from "temporal-polyfill";
-
-// Temporal→Date-Bridge für Lib-APIs die JS-Date verlangen (imapflow
-// search({since}), nodemailer-Header, ...). Gegenstück zur
-// dateToInstant-Richtung der DB-/Event-Store-Boundaries: Feature-Code
-// rechnet in Temporal, konvertiert erst am Aufruf der Fremd-API — der
-// no-date-api-Guard bleibt für Feature-Code scharf, die Konstruktion
-// lebt hier im allowlisteten Time-Layer.
-
-export function instantToLegacyDate(instant: Temporal.Instant): Date {
-  return new Date(instant.epochMilliseconds);
-}
-
-/** Gegenrichtung: Date aus einer Fremd-Lib (imapflow INTERNALDATE,
- *  mailparser Date-Header) → Temporal.Instant. */
-export function legacyDateToInstant(date: Date): Temporal.Instant {
-  return Temporal.Instant.fromEpochMilliseconds(date.getTime());
-}

package/src/time/polyfill.ts

@@ -1,59 +0,0 @@
-// Temporal polyfill bootstrap.
-//
-// Temporal is native in Chromium 144+ / Firefox 139+, but missing in Safari,
-// iOS, and Hermes. Bun/Node coverage is incomplete. Boot installs
-// `temporal-polyfill` once so server/web/mobile share one API.
-//
-// Idempotent: if `globalThis.Temporal` already exists the call is a no-op.
-// The cache is the live global check — not a sticky module flag — so tests
-// that delete the ambient global (fw#1550) still re-install on the next call.
-// Re-install uses the value export + Object.assign (not `temporal-polyfill/global`
-// side-effect import): ESM caches the side-effect module and would not re-run
-// after a teardown.
-
-let polyfillPromise: Promise<void> | null = null;
-
-/**
- * Ensure `globalThis.Temporal` is available. Idempotent.
- */
-export async function ensureTemporalPolyfill(): Promise<void> {
-  if ("Temporal" in globalThis) {
-    // skip: Temporal already on globalThis (native or prior polyfill)
-    return;
-  }
-  if (polyfillPromise) {
-    await polyfillPromise;
-    if ("Temporal" in globalThis) {
-      // skip: Concurrent boot — peer call finished install
-      return;
-    }
-    // Peer resolved but global still missing (torn down mid-flight).
-    polyfillPromise = null;
-  }
-
-  polyfillPromise = (async () => {
-    if ("Temporal" in globalThis) {
-      // skip: raced native/peer install
-      return;
-    }
-    // Value export — assign ourselves so teardown + re-call still works
-    // (side-effect `temporal-polyfill/global` is ESM-cached and silent on re-import).
-    const { Temporal } = await import("temporal-polyfill");
-    Object.assign(globalThis, { Temporal });
-  })();
-
-  await polyfillPromise;
-}
-
-/**
- * Type-safe access to globalThis.Temporal. Throws if the polyfill has not
- * been installed yet (boot-order bug).
- */
-export function getTemporal(): typeof Temporal {
-  if (!("Temporal" in globalThis)) {
-    throw new Error(
-      "Temporal not available. Call ensureTemporalPolyfill() during framework boot before any time-related code runs.",
-    );
-  }
-  return Temporal;
-}