@assistant-ui/react-generative-ui 0.0.22 → 0.0.24

package/src/teams/temporalId.ts

@@ -0,0 +1,56 @@
+import { classifyTemporal } from "../temporal";
+import type { TeamsTemporalField } from "./types";
+
+export const TEMPORAL_INPUT_PREFIX = "aui:datetime:";
+const encodeFieldId = (value: string): string =>
+  Array.from(value, (char) =>
+    /^[\uD800-\uDFFF]$/.test(char)
+      ? `%u${char.charCodeAt(0).toString(16).toUpperCase()}`
+      : encodeURIComponent(char),
+  ).join("");
+
+const decodeFieldId = (value: string): string =>
+  value
+    .split(/(%uD[89A-F][0-9A-F]{2})/)
+    .map((part, index) =>
+      index % 2 === 0
+        ? decodeURIComponent(part)
+        : String.fromCharCode(Number.parseInt(part.slice(2), 16)),
+    )
+    .join("");
+
+export const encodeTemporalInputId = (field: TeamsTemporalField): string =>
+  `${TEMPORAL_INPUT_PREFIX}${field.role}:${encodeFieldId(field.fieldId)}${field.role === "time" ? `:${encodeURIComponent(field.previousValue ?? "")}` : ""}`;
+
+export const decodeTemporalInputId = (
+  id: string,
+): TeamsTemporalField | undefined => {
+  try {
+    const parts = id.slice(TEMPORAL_INPUT_PREFIX.length).split(":");
+    const role = parts[0];
+    if (
+      !id.startsWith(TEMPORAL_INPUT_PREFIX) ||
+      (role !== "date" && role !== "time") ||
+      parts.length !== (role === "date" ? 2 : 3)
+    )
+      return undefined;
+    const fieldId = decodeFieldId(parts[1]!);
+    const previousValue = role === "time" ? decodeURIComponent(parts[2]!) : "";
+    if (
+      !fieldId ||
+      fieldId === "aui" ||
+      fieldId.startsWith(TEMPORAL_INPUT_PREFIX) ||
+      (previousValue !== "" &&
+        classifyTemporal(previousValue).kind !== "instant")
+    )
+      return undefined;
+    const metadata: TeamsTemporalField = {
+      fieldId,
+      role,
+      ...(previousValue ? { previousValue } : {}),
+    };
+    return encodeTemporalInputId(metadata) === id ? metadata : undefined;
+  } catch {
+    return undefined;
+  }
+};

package/src/teams/toAdaptiveCard.ts

@@ -11,6 +11,11 @@ import {
   type NormalizedUIElement,
   type NormalizedUINode,
 } from "../ir";
+import {
+  classifyTemporal,
+  splitTemporalMinutes,
+  temporalOffsetLabel,
+} from "../temporal";
 import {
   factTrend,
   formatFactDelta,
@@ -26,6 +31,7 @@ import {
   buildSubmitAction,
   utf8ByteLength,
 } from "./constants";
+import { encodeTemporalInputId } from "./temporalId";
 import type {
   AdaptiveCardResult,
   TeamsActionSet,
@@ -108,7 +114,12 @@ function reservedSafeId(
   context: ConversionContext,
 ): string {
   const reserved = id === RESERVED_INPUT_ID;
-  const base = reserved ? `${RESERVED_INPUT_ID}_` : id;
+  const temporalReserved = /^_*aui:datetime:/.test(id);
+  const base = reserved
+    ? `${RESERVED_INPUT_ID}_`
+    : temporalReserved
+      ? `_${id}`
+      : id;
   let candidate = base;
   let n = 2;
   while (context.usedInputIds.has(candidate)) {
@@ -122,6 +133,13 @@ function reservedSafeId(
       component,
       `the input id "${RESERVED_INPUT_ID}" collides with the submit envelope's reserved key and was renamed to "${candidate}".`,
     );
+  } else if (temporalReserved) {
+    warn(
+      context,
+      "fallback",
+      component,
+      `the input id "${id}" collides with the reserved datetime namespace and was renamed to "${candidate}".`,
+    );
   } else if (candidate !== base) {
     warn(
       context,
@@ -593,6 +611,149 @@ export function convertElement(
     case "DatePicker": {
       const name = asString(props["name"]);
       const label = asString(props["label"]);
+      const mode = props["inputType"];
+      if (mode === "time") {
+        const id = reservedSafeId(name || "datepicker", "DatePicker", context);
+        const rawValue = asString(props["value"]);
+        const parts = splitTemporalMinutes(rawValue);
+        if (
+          classifyTemporal(rawValue).kind === "time" &&
+          parts?.droppedPrecision
+        ) {
+          warn(
+            context,
+            "dropped",
+            "DatePicker",
+            "Nonzero seconds were dropped from the time value.",
+          );
+        }
+        const value = parts?.time;
+        const rawMin = asString(props["min"]);
+        const minParts = splitTemporalMinutes(rawMin);
+        let min = minParts?.time;
+        if (
+          classifyTemporal(rawMin).kind === "time" &&
+          minParts?.droppedPrecision
+        ) {
+          const minuteOfDay =
+            Number(minParts.time.slice(0, 2)) * 60 +
+            Number(minParts.time.slice(3, 5)) +
+            1;
+          if (minuteOfDay === 24 * 60) {
+            min = undefined;
+            warn(
+              context,
+              "dropped",
+              "DatePicker",
+              "The time minimum rounds past 23:59 and was dropped.",
+            );
+          } else {
+            min = `${String(Math.floor(minuteOfDay / 60)).padStart(2, "0")}:${String(minuteOfDay % 60).padStart(2, "0")}`;
+          }
+        }
+        const rawMax = asString(props["max"]);
+        const maxParts = splitTemporalMinutes(rawMax);
+        const max = maxParts?.time;
+        if (
+          classifyTemporal(rawMax).kind === "time" &&
+          maxParts?.droppedPrecision
+        ) {
+          warn(
+            context,
+            "dropped",
+            "DatePicker",
+            rawMax.slice(6, 8) === "00"
+              ? "Nonzero fractional seconds were dropped from the time maximum."
+              : /\.\d*[1-9]/.test(rawMax)
+                ? "Nonzero seconds and fractional seconds were dropped from the time maximum."
+                : "Nonzero seconds were dropped from the time maximum.",
+          );
+        }
+        const input: TeamsCardElement = {
+          type: "Input.Time",
+          id,
+          ...(label ? { label } : {}),
+          ...(classifyTemporal(rawValue).kind === "time" && value !== undefined
+            ? { value }
+            : {}),
+          ...(classifyTemporal(rawMin).kind === "time" && min !== undefined
+            ? { min }
+            : {}),
+          ...(classifyTemporal(rawMax).kind === "time" && max !== undefined
+            ? { max }
+            : {}),
+        };
+        return withCompanionSubmit(element, input, context);
+      }
+      if (mode === "datetime") {
+        const rawValue = asString(props["value"]);
+        const temporal = classifyTemporal(rawValue);
+        const fieldId = reservedSafeId(
+          name || "datepicker",
+          "DatePicker",
+          context,
+        );
+        const dateId = encodeTemporalInputId({ fieldId, role: "date" });
+        const timeId = encodeTemporalInputId({
+          fieldId,
+          role: "time",
+          ...(temporal.kind === "instant" ? { previousValue: rawValue } : {}),
+        });
+        const parts = splitTemporalMinutes(rawValue);
+        if (temporal.kind === "floating" && parts?.droppedPrecision) {
+          warn(
+            context,
+            "dropped",
+            "DatePicker",
+            "Nonzero seconds were dropped from the datetime value.",
+          );
+        }
+        const offsetLabel = temporalOffsetLabel(rawValue);
+        const boundDate = (raw: unknown) => {
+          const value = asString(raw);
+          return classifyTemporal(value).kind === "date"
+            ? value
+            : splitTemporalMinutes(
+                value,
+                temporal.kind === "instant" ? temporal.offset : undefined,
+              )?.date;
+        };
+        const min = boundDate(props["min"]);
+        const max = boundDate(props["max"]);
+        const dateInput: TeamsCardElement = {
+          type: "Input.Date",
+          id: dateId,
+          ...(label ? { label } : {}),
+          ...(parts?.date !== undefined ? { value: parts.date } : {}),
+          ...(min !== undefined ? { min } : {}),
+          ...(max !== undefined ? { max } : {}),
+        };
+        const timeInput: TeamsCardElement = {
+          type: "Input.Time",
+          id: timeId,
+          ...(label || offsetLabel
+            ? {
+                label: `${label ? `${label} time` : "Time"}${offsetLabel ? ` (${offsetLabel})` : ""}`,
+              }
+            : {}),
+          ...(parts?.time !== undefined ? { value: parts.time } : {}),
+        };
+        if (element.action === undefined) return [dateInput, timeInput];
+        const [input, submit] = withCompanionSubmit(
+          element,
+          timeInput,
+          context,
+        );
+        return [dateInput, input!, submit!];
+      }
+      if (mode !== undefined && mode !== "date") {
+        warn(
+          context,
+          "dropped",
+          "DatePicker",
+          "Unsupported inputType was dropped; the picker was rendered as a date input.",
+        );
+      }
       const rawValue = props["value"];
       const value =
         typeof rawValue === "string" && DATE_PATTERN.test(rawValue)
@@ -868,7 +1029,10 @@ export function toAdaptiveCard(
   node: unknown,
   _options?: ToAdaptiveCardOptions,
 ): AdaptiveCardResult {
-  const context: ConversionContext = { warnings: [], usedInputIds: new Set() };
+  const context: ConversionContext = {
+    warnings: [],
+    usedInputIds: new Set(),
+  };
   try {
     const bounded = boundSpec(node, (reason) =>
       warn(context, "clamped", "Root", clampReasonDetail(reason)),

package/src/teams/toTeamsAttachments.ts

@@ -77,7 +77,10 @@ export function toTeamsAttachments(
   _options?: ToAdaptiveCardOptions,
 ): TeamsAttachmentsResult {
   const warnings: TeamsConversionWarning[] = [];
-  const context: ConversionContext = { warnings, usedInputIds: new Set() };
+  const context: ConversionContext = {
+    warnings,
+    usedInputIds: new Set(),
+  };
   try {
     const bounded = boundSpec(node, (reason) =>
       warnings.push({

package/src/teams/types.ts

@@ -55,6 +55,11 @@ export interface TeamsSubmitData {
   };
 }
 
+export type TeamsTemporalField = { readonly fieldId: string } & (
+  | { readonly role: "date" }
+  | { readonly role: "time"; readonly previousValue?: string }
+);
+
 /**
  * A submit action. `data` carries the resume payload under an `aui` key so
  * {@link decodeSubmitData} can invert it out of the merged `activity.value`
@@ -160,6 +165,17 @@ export interface TeamsInputDate {
   readonly spacing?: "large";
 }
 
+export interface TeamsInputTime {
+  readonly type: "Input.Time";
+  readonly id: string;
+  readonly label?: string;
+  readonly value?: string;
+  readonly min?: string;
+  readonly max?: string;
+  readonly separator?: true;
+  readonly spacing?: "large";
+}
+
 /** One cell inside a {@link TeamsTableRow}. */
 export interface TeamsTableCell {
   readonly type: "TableCell";
@@ -199,6 +215,7 @@ export type TeamsCardElement =
   | TeamsInputToggle
   | TeamsInputText
   | TeamsInputDate
+  | TeamsInputTime
   | TeamsTable;
 
 /** A Microsoft Teams Adaptive Card, pinned to schema version 1.5 (the Teams desktop/web cap; mobile clients cap at 1.2). */

package/src/teams.ts

@@ -21,6 +21,7 @@ export type {
   TeamsInputChoiceSet,
   TeamsInputDate,
   TeamsInputText,
+  TeamsInputTime,
   TeamsInputToggle,
   TeamsSubmitAction,
   TeamsSubmitData,

package/src/temporal.test.ts

@@ -0,0 +1,337 @@
+import { describe, expect, it } from "vitest";
+import {
+  classifyTemporal,
+  formatTemporalInstant,
+  formatTemporalUnixSeconds,
+  fromLocalDateTime,
+  fromOffsetDateTime,
+  mergeTemporalMinutes,
+  normalizeTemporalInputValue,
+  splitTemporalMinutes,
+  temporalOffsetLabel,
+  toLocalDateTime,
+  toPickerLocalDateTime,
+} from "./temporal";
+
+describe("temporal values", () => {
+  it("splits instants in their own offset or another offset", () => {
+    expect(splitTemporalMinutes("2025-12-15T17:00:00+02:00")).toEqual({
+      date: "2025-12-15",
+      time: "17:00",
+      droppedPrecision: false,
+    });
+    expect(splitTemporalMinutes("2025-12-14T23:30:00Z", "+02:00")).toEqual({
+      date: "2025-12-15",
+      time: "01:30",
+      droppedPrecision: false,
+    });
+    expect(temporalOffsetLabel("2025-12-15T17:00Z")).toBe("UTC");
+    expect(temporalOffsetLabel("2025-12-15T17:00+02:00")).toBe("UTC+02:00");
+  });
+
+  it("merges a wall minute using the original offset and precision", () => {
+    expect(
+      fromOffsetDateTime(
+        "2025-12-16T18:20",
+        "2025-12-15T17:00:30.123456+02:00",
+      ),
+    ).toBe("2025-12-16T18:20:30.123456+02:00");
+    expect(fromOffsetDateTime("2025-12-16T18:20", "2025-12-15T17:00:00Z")).toBe(
+      "2025-12-16T18:20:00Z",
+    );
+    expect(fromOffsetDateTime("2025-12-16T18:20")).toBe("2025-12-16T18:20");
+    expect(fromOffsetDateTime("", "2025-12-15T17:00Z")).toBe("");
+  });
+  it.each([
+    ["17:00", { time: "17:00", droppedPrecision: false }],
+    ["17:00:00", { time: "17:00", droppedPrecision: false }],
+    ["17:00:30", { time: "17:00", droppedPrecision: true }],
+    [
+      "2025-12-15T17:00",
+      { date: "2025-12-15", time: "17:00", droppedPrecision: false },
+    ],
+    [
+      "2025-12-15T17:00:00.000",
+      { date: "2025-12-15", time: "17:00", droppedPrecision: false },
+    ],
+    [
+      "2025-12-15T17:00:00.001",
+      { date: "2025-12-15", time: "17:00", droppedPrecision: true },
+    ],
+    [
+      "2025-12-15T17:00Z",
+      { date: "2025-12-15", time: "17:00", droppedPrecision: false },
+    ],
+    [
+      "2025-12-15T17:00:30.001Z",
+      { date: "2025-12-15", time: "17:00", droppedPrecision: true },
+    ],
+    [
+      "2025-12-15T17:00:00.000Z",
+      { date: "2025-12-15", time: "17:00", droppedPrecision: false },
+    ],
+    ["2025-12-15", undefined],
+    ["invalid", undefined],
+    ["", undefined],
+  ])("splits %s into minute precision wall-clock parts", (value, expected) => {
+    expect(splitTemporalMinutes(value as string)).toEqual(expected);
+  });
+
+  it.each([
+    ["2025-12-15", "17:00", "2025-12-15T17:00"],
+    ["2025-12-15", "17:00:30", "2025-12-15T17:00"],
+    ["", "17:00", ""],
+    ["2025-12-15", "", ""],
+    ["2025-02-29", "17:00", ""],
+    ["2025-12-15", "24:00", ""],
+  ])("merges %j and %j without assigning a zone", (date, time, expected) => {
+    expect(mergeTemporalMinutes(date!, time!)).toBe(expected);
+  });
+
+  it.each([
+    [1765818000, "Z", "2025-12-15T17:00:00Z"],
+    [1765810800, "+02:00", "2025-12-15T17:00:00+02:00"],
+    [0, "-00:00", "1970-01-01T00:00:00-00:00"],
+    [-1, "Z", "1969-12-31T23:59:59Z"],
+    [0, "+24:00", undefined],
+    [0.5, "Z", undefined],
+    [Infinity, "Z", undefined],
+    [NaN, "Z", undefined],
+    [Number.MAX_SAFE_INTEGER, "Z", undefined],
+  ])(
+    "formats unix seconds %s with offset %s safely",
+    (seconds, offset, expected) => {
+      expect(
+        formatTemporalUnixSeconds(seconds as number, offset as string),
+      ).toBe(expected);
+    },
+  );
+
+  it.each([
+    ["12:00:00", "12:00"],
+    ["12:00:00.000", "12:00"],
+    ["12:00:05.1200", "12:00:05.12"],
+    ["2025-12-15T12:00:00.000", "2025-12-15T12:00"],
+    ["2025-12-15T12:00:05.1200", "2025-12-15T12:00:05.12"],
+    ["12:00:05.123456", "12:00:05.123"],
+    ["12:00:05.000456", "12:00:05"],
+    ["2025-12-15T12:00:05.123456789", "2025-12-15T12:00:05.123"],
+    ["2025-12-15", "2025-12-15"],
+  ])("normalizes the browser input value %s", (value, expected) => {
+    expect(normalizeTemporalInputValue(value!)).toBe(expected);
+  });
+
+  it("completes normalization of a 100000 digit zero fraction", () => {
+    const zeros = "0".repeat(100_000);
+    for (const value of [zeros, `12:00:00.${zeros}`, `12:00:00.${zeros}1`]) {
+      expect(normalizeTemporalInputValue(value)).toBe(value);
+    }
+    expect(normalizeTemporalInputValue("12:00:00.000000000")).toBe("12:00");
+    expect(normalizeTemporalInputValue("12:00:00.100000000")).toBe(
+      "12:00:00.1",
+    );
+  });
+
+  it("uses a fixed viewer time zone with seasonal offsets", () => {
+    expect(Intl.DateTimeFormat().resolvedOptions().timeZone).toBe(
+      "America/New_York",
+    );
+    expect(new Date("2026-01-15T12:00Z").getTimezoneOffset()).toBe(300);
+    expect(new Date("2026-07-15T12:00Z").getTimezoneOffset()).toBe(240);
+  });
+
+  it.each(["0002", "0020", "0202"])(
+    "preserves minute edits in %s when the zone offset has seconds",
+    (year) => {
+      const local = `${year}-12-15T12:00`;
+      const value = fromLocalDateTime(local, "2025-12-15T17:00Z");
+      expect(value).toBe(`${year}-12-15T16:56:02Z`);
+      expect(toPickerLocalDateTime(value)).toBe(local);
+    },
+  );
+
+  it("preserves entered seconds with a minute precision anchor", () => {
+    const local = "2025-12-15T12:00:30";
+    const value = fromLocalDateTime(local, "2025-12-15T17:00Z");
+    expect(value).toBe("2025-12-15T17:00:30Z");
+    expect(toPickerLocalDateTime(value)).toBe(local);
+  });
+
+  it.each([
+    ["2026-07-15", "date"],
+    ["2024-02-29", "date"],
+    ["00:00", "time"],
+    ["23:59:59", "time"],
+    ["12:34:56.1", "time"],
+    ["12:34:56.1200", "time"],
+    ["2026-07-15T12:34", "floating"],
+    ["2026-07-15T12:34:56", "floating"],
+    ["2026-07-15T12:34:56.123456", "floating"],
+  ])("classifies and passes through %s as %s", (value, kind) => {
+    expect(classifyTemporal(value!)).toMatchObject({ kind, value });
+    expect(toLocalDateTime(value!)).toBe(value);
+    expect(fromLocalDateTime(value!, value!)).toBe(value);
+  });
+
+  describe.each([
+    { offset: "Z", local: "2026-07-15T08:34" },
+    { offset: "+08:00", local: "2026-07-15T00:34" },
+    { offset: "-05:30", local: "2026-07-15T14:04" },
+  ])("$offset instants", ({ offset, local }) => {
+    it.each([
+      { suffix: "", precision: "minutes" },
+      { suffix: ":56", precision: "seconds" },
+      { suffix: ":56.1", precision: 1 },
+      { suffix: ":56.12", precision: 2 },
+      { suffix: ":56.123", precision: 3 },
+      { suffix: ":56.123456789", precision: 9 },
+      { suffix: ":00.000009", precision: 6 },
+    ])(
+      "round trips local wall time at $precision precision",
+      ({ suffix, precision }) => {
+        const value = `2026-07-15T12:34${suffix}${offset}`;
+        const parsed = classifyTemporal(value);
+        expect(parsed).toMatchObject({
+          kind: "instant",
+          epochMs: Date.parse(value),
+          offset,
+          precision,
+        });
+        if (parsed.kind !== "instant") throw new Error("Expected an instant");
+        expect(formatTemporalInstant(parsed)).toBe(value);
+        const wallTime = toLocalDateTime(value, parsed.precision);
+        expect(wallTime).toBe(`${local}${suffix}`);
+        expect(fromLocalDateTime(wallTime, value)).toBe(value);
+      },
+    );
+  });
+
+  it("formats an instant in another offset and precision across calendar boundaries", () => {
+    const parsed = classifyTemporal("2026-01-01T00:15:30.120Z");
+    if (parsed.kind !== "instant") throw new Error("Expected an instant");
+    expect(formatTemporalInstant(parsed, "-05:30", "minutes")).toBe(
+      "2025-12-31T18:45-05:30",
+    );
+    expect(formatTemporalInstant(parsed, "+08:00", "seconds")).toBe(
+      "2026-01-01T08:15:30+08:00",
+    );
+    expect(formatTemporalInstant(parsed, "Z", 6)).toBe(
+      "2026-01-01T00:15:30.120000Z",
+    );
+  });
+
+  it("preserves offset spelling and uses the edited fractional digits", () => {
+    expect(
+      fromLocalDateTime(
+        "2026-07-16T10:20:30.123456789",
+        "2026-07-15T12:34:56.123456789-00:00",
+      ),
+    ).toBe("2026-07-16T14:20:30.123456789-00:00");
+  });
+
+  it.each([
+    ["2025-12-15T12:00:00.750", "2025-12-15T17:00:00.750Z", 3],
+    ["2025-12-15T12:00:00.75", "2025-12-15T17:00:00.750Z", 2],
+    ["2025-12-15T12:00:00", "2025-12-15T17:00:00.000Z", undefined],
+    ["2025-12-15T12:00:00.250", "2025-12-15T17:00:00.250Z", 3],
+    ["2025-12-15T12:00:00.750987", "2025-12-15T17:00:00.750987Z", 6],
+  ])(
+    "round trips a local fraction edit of %s",
+    (local, expected, precision) => {
+      const result = fromLocalDateTime(local!, "2025-12-15T17:00:00.250Z");
+      expect(result).toBe(expected);
+      expect(toLocalDateTime(result, precision)).toBe(local);
+    },
+  );
+
+  it.each([
+    [
+      "2026-07-16T08:34:56",
+      "2026-07-15T12:34:56.000456Z",
+      "2026-07-16T12:34:56.000456Z",
+    ],
+    [
+      "2026-07-16T08:34",
+      "2026-07-15T12:34:00.000456Z",
+      "2026-07-16T12:34:00.000456Z",
+    ],
+  ])(
+    "keeps a sub-millisecond tail the control cannot show after an edit to %s",
+    (local, anchor, expected) => {
+      expect(fromLocalDateTime(local, anchor)).toBe(expected);
+    },
+  );
+
+  it("uses zero for a native zero or omitted fraction", () => {
+    expect(
+      fromLocalDateTime("2025-12-15T12:00:00.000", "2025-12-15T17:00:00.250Z"),
+    ).toBe("2025-12-15T17:00:00.000Z");
+    expect(
+      fromLocalDateTime("2025-12-15T12:00:00", "2025-12-15T17:00:00.250123Z"),
+    ).toBe("2025-12-15T17:00:00.000000Z");
+  });
+
+  it.each([
+    ["2026-01-15T12:34", "2026-01-15T12:34:00-05:00"],
+    ["2026-07-15T12:34", "2026-07-15T12:34:00-04:00"],
+  ])("uses the viewer offset at %s for an empty value", (value, expected) => {
+    expect(fromLocalDateTime(value!, "")).toBe(expected);
+    expect(fromLocalDateTime(value!)).toBe(expected);
+  });
+
+  it.each([
+    {
+      value: "2026-03-08T02:30:45",
+      parts: [2026, 2, 8, 2, 30, 45] as const,
+      expected: "2026-03-08T07:30:45.000000Z",
+      local: "2026-03-08T03:30:45",
+    },
+    {
+      value: "2026-11-01T01:30:45",
+      parts: [2026, 10, 1, 1, 30, 45] as const,
+      expected: "2026-11-01T05:30:45.000000Z",
+      local: "2026-11-01T01:30:45",
+    },
+  ])(
+    "resolves DST wall time $value like the native constructor",
+    ({ value, parts, expected, local }) => {
+      const result = fromLocalDateTime(value, "2026-01-15T12:00:00.123456Z");
+      expect(result).toBe(expected);
+      const [year, month, day, hour, minute, second] = parts;
+      expect(Date.parse(result)).toBe(
+        new Date(year, month, day, hour, minute, second).getTime(),
+      );
+      expect(toLocalDateTime(result)).toBe(local);
+      expect(fromLocalDateTime(value, value)).toBe(value);
+    },
+  );
+
+  it("preserves an empty input when an instant is cleared", () => {
+    expect(fromLocalDateTime("", "2026-07-15T12:34:56+08:00")).toBe("");
+  });
+
+  it.each([
+    "",
+    "not a date",
+    "2026-02-29",
+    "2026-04-31",
+    "2026-13-01",
+    "2026-01-00",
+    "24:00",
+    "12:60",
+    "12:34:60",
+    "2026-07-15T24:00Z",
+    "2026-07-15T12:60Z",
+    "2026-07-15T12:34:60Z",
+    "2026-02-29T12:34Z",
+    "2026-07-15T12:34.1Z",
+    "2026-07-15T12:34+24:00",
+    "2026-07-15T12:34+08:60",
+    "2026-07-15T12:34+0800",
+    "2026-07-15 12:34Z",
+  ])("classifies %j as unparseable and passes it through", (value) => {
+    expect(classifyTemporal(value)).toEqual({ kind: "unparseable", value });
+    expect(toLocalDateTime(value)).toBe(value);
+    expect(fromLocalDateTime(value)).toBe(value);
+  });
+});