@abraca/nuxt 2.0.1 → 2.0.4

package/dist/runtime/composables/useAAFollowPeer.js

@@ -2,17 +2,42 @@ import { computed, onScopeDispose, ref, watch } from "vue";
 import { useAbracadabra } from "./useAbracadabra.js";
 import { useSyncedMap } from "./useYDoc.js";
 import { useAwareness } from "./useAwareness.js";
-const _followingClientId = ref(null);
+const _followingPublicKey = ref(null);
+const _followingClientIdFallback = ref(null);
 export function useAAFollowPeer(options = {}) {
   const { doc, provider } = useAbracadabra();
   const { data, set } = useSyncedMap(doc, "aware-ui");
   const { states } = useAwareness();
-  const followingClientId = _followingClientId;
   let unsubInteraction = null;
+  const followingClientId = computed(() => {
+    const pk = _followingPublicKey.value;
+    if (pk) {
+      for (const [cid, st] of states.value.entries()) {
+        const peerPk = st?.user?.publicKey;
+        if (peerPk === pk) return cid;
+      }
+      return null;
+    }
+    return _followingClientIdFallback.value;
+  });
+  const isFollowing = computed(
+    () => _followingPublicKey.value != null || _followingClientIdFallback.value != null
+  );
+  const followingPublicKey = computed(() => _followingPublicKey.value);
+  const followingUserCache = ref(null);
   const followingUser = computed(() => {
-    if (followingClientId.value == null) return null;
-    const state = states.value.get(followingClientId.value);
-    return state?.user ?? null;
+    const cid = followingClientId.value;
+    if (cid != null) {
+      const state = states.value.get(cid);
+      if (state?.user) return state.user;
+    }
+    return followingUserCache.value;
+  });
+  watch(followingUser, (user) => {
+    if (user) followingUserCache.value = { ...user };
+  }, { flush: "post" });
+  watch(isFollowing, (active) => {
+    if (!active) followingUserCache.value = null;
   });
   function detachInteraction() {
     unsubInteraction?.();
@@ -31,14 +56,31 @@ export function useAAFollowPeer(options = {}) {
       window.removeEventListener("wheel", onBreak);
     };
   }
-  function follow(clientId) {
-    if (followingClientId.value === clientId) return;
-    followingClientId.value = clientId;
+  function follow(clientIdOrPublicKey) {
+    if (typeof clientIdOrPublicKey === "string") {
+      if (_followingPublicKey.value === clientIdOrPublicKey) return;
+      _followingPublicKey.value = clientIdOrPublicKey;
+      _followingClientIdFallback.value = null;
+    } else {
+      const cid = clientIdOrPublicKey;
+      const state = states.value.get(cid);
+      const pk = state?.user?.publicKey;
+      if (pk) {
+        if (_followingPublicKey.value === pk) return;
+        _followingPublicKey.value = pk;
+        _followingClientIdFallback.value = null;
+      } else {
+        if (_followingClientIdFallback.value === cid) return;
+        _followingPublicKey.value = null;
+        _followingClientIdFallback.value = cid;
+      }
+    }
     attachInteractionBreaker();
   }
   function unfollow() {
-    if (followingClientId.value == null) return;
-    followingClientId.value = null;
+    if (_followingPublicKey.value == null && _followingClientIdFallback.value == null) return;
+    _followingPublicKey.value = null;
+    _followingClientIdFallback.value = null;
     detachInteraction();
     options.onBreak?.();
   }
@@ -71,5 +113,12 @@ export function useAAFollowPeer(options = {}) {
     }
   });
   onScopeDispose(detachInteraction);
-  return { follow, unfollow, followingClientId, followingUser };
+  return {
+    follow,
+    unfollow,
+    followingClientId,
+    followingPublicKey,
+    followingUser,
+    isFollowing
+  };
 }

package/dist/runtime/composables/useAAViewport.d.ts

@@ -6,7 +6,7 @@ import type { MaybeRefOrGetter } from 'vue';
  * scoped container as `peer:viewport:<scope>` ephemeral state.
  *
  * Use case: render "Janis is reading the API section" overlays in long docs.
- * Pair with `<APresenceCursors>` for a complete spatial-presence layer.
+ * Pair with `<APresenceCursors>` for a complete presence layer.
  */
 export interface PeerViewport {
     clientId: number;

package/dist/runtime/composables/useAbracadabraAuth.d.ts

@@ -21,6 +21,8 @@ export declare function useAbracadabraAuth(): {
     confirmPasswordReset: any;
     changePassword: any;
     setPassword: any;
+    hasPassword: any;
+    refreshHasPassword: any;
     recoverIdentity: any;
     unblockConnection: any;
     setUserName: any;

package/dist/runtime/composables/useAbracadabraAuth.js

@@ -24,6 +24,8 @@ export function useAbracadabraAuth() {
     confirmPasswordReset: abra.confirmPasswordReset,
     changePassword: abra.changePassword,
     setPassword: abra.setPassword,
+    hasPassword: abra.hasPassword,
+    refreshHasPassword: abra.refreshHasPassword,
     recoverIdentity: abra.recoverIdentity,
     unblockConnection: abra.unblockConnection,
     setUserName: abra.setUserName,

package/dist/runtime/composables/useEmailVerification.d.ts

@@ -1,33 +1,47 @@
-/**
- * useEmailVerification
- *
- * Wraps the email-verification half of the auth lifecycle.
- * - `request()` triggers a verification email (rate-limited 1/min, 10/day).
- * - `confirm(token)` consumes the token from the email link; no auth needed.
- *
- * `verified` mirrors the most recent local result of `confirm()` — the
- * server doesn't currently expose `email_verified_at` on `getMe()`, so
- * the canonical signal is "did `confirm()` succeed in this session".
- *
- * Usage:
- *   const { verified, isRequesting, isConfirming, error, request, confirm } = useEmailVerification()
- */
-declare function request(): Promise<void>;
-declare function confirm(token: string): Promise<void>;
+/** Known error codes raised by `useEmailVerification()` actions. */
+export type EmailVerificationErrorCode = 'rate_limited' | 'token_expired' | 'token_invalid' | 'verification_disabled' | 'already_verified' | 'email_not_set' | 'unauthorized' | 'forbidden' | 'network_error' | 'server_error' | 'unknown';
+export interface EmailVerificationError {
+    code: EmailVerificationErrorCode;
+    message: string;
+    status?: number;
+    retryAfterSeconds?: number;
+}
+export type EmailVerificationAction = 'request' | 'confirm';
+export interface EmailVerificationResult {
+    ok: boolean;
+    error?: EmailVerificationError;
+}
+declare function classifyError(err: unknown): EmailVerificationError;
 export declare function useEmailVerification(): {
-    /** True after a successful `confirm()` in the current session. */
+    /** True after a successful `confirm()` in this session. */
     verified: import("vue").Ref<boolean, boolean>;
-    /** Whether a `request()` is in flight. */
-    isRequesting: import("vue").Ref<boolean, boolean>;
-    /** Whether a `confirm()` is in flight. */
-    isConfirming: import("vue").Ref<boolean, boolean>;
-    /** Last error message, or null. */
-    error: import("vue").Ref<string | null, string | null>;
     /** Epoch ms of the last successful `request()`, or null. */
     lastSentAt: import("vue").Ref<number | null, number | null>;
-    /** Send a verification email to the current user. Requires auth. */
-    request: typeof request;
+    /** Currently-running action, or null. */
+    busy: import("vue").Ref<EmailVerificationAction | null, EmailVerificationAction | null>;
+    /** Most recent typed error, or null. Cleared at the start of every action. */
+    error: import("vue").Ref<{
+        code: EmailVerificationErrorCode;
+        message: string;
+        status?: number | undefined;
+        retryAfterSeconds?: number | undefined;
+    } | null, EmailVerificationError | {
+        code: EmailVerificationErrorCode;
+        message: string;
+        status?: number | undefined;
+        retryAfterSeconds?: number | undefined;
+    } | null>;
+    /** Most recent successful action, or null. */
+    lastSuccess: import("vue").Ref<EmailVerificationAction | null, EmailVerificationAction | null>;
+    /** Wipe `error` without re-running anything. */
+    clearError: () => void;
+    /** Send a verification email to the current user. Auth required. */
+    request: () => Promise<EmailVerificationResult>;
     /** Confirm a verification token from the email link. No auth required. */
-    confirm: typeof confirm;
+    confirm: (opts: {
+        token: string;
+    }) => Promise<EmailVerificationResult>;
+    /** Internal helper exposed for testing. */
+    _classifyError: typeof classifyError;
 };
 export {};

package/dist/runtime/composables/useEmailVerification.js

@@ -1,58 +1,110 @@
 import { ref } from "vue";
-import { useAbracadabra } from "#imports";
+import { useAbracadabra } from "./useAbracadabra.js";
 const verified = ref(false);
-const isRequesting = ref(false);
-const isConfirming = ref(false);
-const error = ref(null);
 const lastSentAt = ref(null);
-async function request() {
-  const abra = useAbracadabra();
-  const client = abra.client.value;
-  if (!client) throw new Error("Not connected");
-  isRequesting.value = true;
-  error.value = null;
-  try {
-    await client.requestEmailVerification();
-    lastSentAt.value = Date.now();
-  } catch (e) {
-    error.value = e instanceof Error ? e.message : "Failed to send verification email";
-    throw e;
-  } finally {
-    isRequesting.value = false;
-  }
+const busy = ref(null);
+const error = ref(null);
+const lastSuccess = ref(null);
+function extractServerMessage(raw) {
+  const trailing = raw.replace(/ \(\d+\)$/, "").trim();
+  const colon = trailing.indexOf(": ");
+  if (colon === -1) return trailing;
+  const head = trailing.slice(0, colon);
+  if (/^[A-Z]+ \//.test(head)) return trailing.slice(colon + 2).trim();
+  return trailing;
 }
-async function confirm(token) {
-  const abra = useAbracadabra();
-  const client = abra.client.value;
-  if (!client) throw new Error("Not connected");
-  isConfirming.value = true;
-  error.value = null;
-  try {
-    await client.confirmEmailVerification(token);
-    verified.value = true;
-  } catch (e) {
-    error.value = e instanceof Error ? e.message : "Verification failed";
-    verified.value = false;
-    throw e;
-  } finally {
-    isConfirming.value = false;
+function classifyError(err) {
+  if (err instanceof TypeError && /fetch|network/i.test(err.message)) {
+    return { code: "network_error", message: err.message };
+  }
+  if (!(err instanceof Error)) {
+    return { code: "unknown", message: String(err) };
+  }
+  const status = err.status;
+  const serverMsg = extractServerMessage(err.message);
+  const lower = serverMsg.toLowerCase();
+  const retryMatch = lower.match(/retry(?:[-\s]?after)?[:\s]+(\d+)/);
+  const retryAfterSeconds = retryMatch ? Number(retryMatch[1]) : void 0;
+  if (status === 429) {
+    return { code: "rate_limited", message: serverMsg, status, retryAfterSeconds };
+  }
+  if (status === 410 || /token (?:expired|invalid)/.test(lower)) {
+    return {
+      code: lower.includes("expired") ? "token_expired" : "token_invalid",
+      message: serverMsg,
+      status
+    };
+  }
+  if (status === 404 || /verification (?:is )?disabled/.test(lower)) {
+    return { code: "verification_disabled", message: serverMsg, status };
+  }
+  if (lower.includes("already verified") || lower.includes("already_verified")) {
+    return { code: "already_verified", message: serverMsg, status };
   }
+  if (lower.includes("no email") || lower.includes("email not set") || lower.includes("email_not_set")) {
+    return { code: "email_not_set", message: serverMsg, status };
+  }
+  if (status === 401) return { code: "unauthorized", message: serverMsg, status };
+  if (status === 403) return { code: "forbidden", message: serverMsg, status };
+  if (typeof status === "number" && status >= 500) {
+    return { code: "server_error", message: serverMsg, status };
+  }
+  return { code: "unknown", message: serverMsg, status };
 }
 export function useEmailVerification() {
+  const abra = useAbracadabra();
+  function clearError() {
+    error.value = null;
+  }
+  async function run(action, fn) {
+    const client = abra.client.value;
+    if (!client) {
+      const err = { code: "network_error", message: "Not connected" };
+      error.value = err;
+      return { ok: false, error: err };
+    }
+    busy.value = action;
+    error.value = null;
+    try {
+      await fn(client);
+      lastSuccess.value = action;
+      return { ok: true };
+    } catch (e) {
+      const err = classifyError(e);
+      error.value = err;
+      return { ok: false, error: err };
+    } finally {
+      busy.value = null;
+    }
+  }
+  async function request() {
+    const res = await run("request", (client) => client.requestEmailVerification());
+    if (res.ok) lastSentAt.value = Date.now();
+    return res;
+  }
+  async function confirm(opts) {
+    const res = await run("confirm", (client) => client.confirmEmailVerification(opts.token));
+    if (res.ok) verified.value = true;
+    return res;
+  }
   return {
-    /** True after a successful `confirm()` in the current session. */
+    /** True after a successful `confirm()` in this session. */
     verified,
-    /** Whether a `request()` is in flight. */
-    isRequesting,
-    /** Whether a `confirm()` is in flight. */
-    isConfirming,
-    /** Last error message, or null. */
-    error,
     /** Epoch ms of the last successful `request()`, or null. */
     lastSentAt,
-    /** Send a verification email to the current user. Requires auth. */
+    /** Currently-running action, or null. */
+    busy,
+    /** Most recent typed error, or null. Cleared at the start of every action. */
+    error,
+    /** Most recent successful action, or null. */
+    lastSuccess,
+    /** Wipe `error` without re-running anything. */
+    clearError,
+    /** Send a verification email to the current user. Auth required. */
     request,
     /** Confirm a verification token from the email link. No auth required. */
-    confirm
+    confirm,
+    /** Internal helper exposed for testing. */
+    _classifyError: classifyError
   };
 }

package/dist/runtime/composables/usePasswordAuth.d.ts

@@ -0,0 +1,64 @@
+/** Known error codes raised by `usePasswordAuth()` actions. */
+export type PasswordAuthErrorCode = 'rate_limited' | 'locked_out' | 'password_too_short' | 'invalid_credentials' | 'token_expired' | 'token_invalid' | 'password_already_set' | 'email_taken' | 'username_taken' | 'password_login_disabled' | 'password_reset_disabled' | 'invite_required' | 'invite_invalid' | 'network_error' | 'forbidden' | 'unauthorized' | 'server_error' | 'unknown';
+export interface PasswordAuthError {
+    code: PasswordAuthErrorCode;
+    message: string;
+    /** HTTP status code, when the error came from the REST API. */
+    status?: number;
+    /** Seconds the caller should wait before retrying — only set for `rate_limited` / `locked_out`. */
+    retryAfterSeconds?: number;
+}
+export type PasswordAuthAction = 'login' | 'register' | 'reset-request' | 'reset-confirm' | 'change' | 'set';
+export interface PasswordAuthResult {
+    ok: boolean;
+    error?: PasswordAuthError;
+}
+declare function classifyError(err: unknown): PasswordAuthError;
+export declare function usePasswordAuth(): {
+    busy: import("vue").Ref<PasswordAuthAction | null, PasswordAuthAction | null>;
+    error: import("vue").Ref<{
+        code: PasswordAuthErrorCode;
+        message: string;
+        status?: number
+        /** Seconds the caller should wait before retrying — only set for `rate_limited` / `locked_out`. */
+         | undefined;
+        retryAfterSeconds?: number | undefined;
+    } | null, PasswordAuthError | {
+        code: PasswordAuthErrorCode;
+        message: string;
+        status?: number
+        /** Seconds the caller should wait before retrying — only set for `rate_limited` / `locked_out`. */
+         | undefined;
+        retryAfterSeconds?: number | undefined;
+    } | null>;
+    lastSuccess: import("vue").Ref<PasswordAuthAction | null, PasswordAuthAction | null>;
+    clearError: () => void;
+    login: (opts: {
+        username: string;
+        password: string;
+    }) => Promise<PasswordAuthResult>;
+    register: (opts: {
+        username: string;
+        password: string;
+        email?: string;
+        displayName?: string;
+        inviteCode?: string;
+    }) => Promise<PasswordAuthResult>;
+    requestReset: (opts: {
+        identifier: string;
+    }) => Promise<PasswordAuthResult>;
+    confirmReset: (opts: {
+        token: string;
+        newPassword: string;
+    }) => Promise<PasswordAuthResult>;
+    changePassword: (opts: {
+        currentPassword: string;
+        newPassword: string;
+    }) => Promise<PasswordAuthResult>;
+    setPassword: (opts: {
+        password: string;
+    }) => Promise<PasswordAuthResult>;
+    /** Internal helper exposed for testing — classify any error to its code. */
+    _classifyError: typeof classifyError;
+};
+export {};

package/dist/runtime/composables/usePasswordAuth.js

@@ -0,0 +1,126 @@
+import { ref } from "vue";
+import { useAbracadabraAuth } from "./useAbracadabraAuth.js";
+function extractServerMessage(raw) {
+  const trailing = raw.replace(/ \(\d+\)$/, "").trim();
+  const colon = trailing.indexOf(": ");
+  if (colon === -1) return trailing;
+  const head = trailing.slice(0, colon);
+  if (/^[A-Z]+ \//.test(head)) return trailing.slice(colon + 2).trim();
+  return trailing;
+}
+function classifyError(err) {
+  if (err instanceof TypeError && /fetch|network/i.test(err.message)) {
+    return { code: "network_error", message: err.message };
+  }
+  if (!(err instanceof Error)) {
+    return { code: "unknown", message: String(err) };
+  }
+  const status = err.status;
+  const serverMsg = extractServerMessage(err.message);
+  const lower = serverMsg.toLowerCase();
+  const retryMatch = lower.match(/retry(?:[-\s]?after)?[:\s]+(\d+)/);
+  const retryAfterSeconds = retryMatch ? Number(retryMatch[1]) : void 0;
+  if (status === 423) {
+    return { code: "locked_out", message: serverMsg, status, retryAfterSeconds };
+  }
+  if (status === 429) {
+    return { code: "rate_limited", message: serverMsg, status, retryAfterSeconds };
+  }
+  if (status === 410 || /token (?:expired|invalid)/.test(lower)) {
+    return {
+      code: lower.includes("expired") ? "token_expired" : "token_invalid",
+      message: serverMsg,
+      status
+    };
+  }
+  if (lower.includes("password too short")) {
+    return { code: "password_too_short", message: serverMsg, status };
+  }
+  if (lower.includes("password_already_set")) {
+    return { code: "password_already_set", message: serverMsg, status };
+  }
+  if (lower.includes("password login is disabled")) {
+    return { code: "password_login_disabled", message: serverMsg, status };
+  }
+  if (lower.includes("password reset disabled") || lower.includes("password reset is disabled")) {
+    return { code: "password_reset_disabled", message: serverMsg, status };
+  }
+  if (lower.includes("username") && (lower.includes("taken") || lower.includes("exists") || lower.includes("in use"))) {
+    return { code: "username_taken", message: serverMsg, status };
+  }
+  if (lower.includes("email") && (lower.includes("taken") || lower.includes("exists") || lower.includes("in use"))) {
+    return { code: "email_taken", message: serverMsg, status };
+  }
+  if (lower.includes("invite required") || lower.includes("invite is required")) {
+    return { code: "invite_required", message: serverMsg, status };
+  }
+  if (lower.includes("invite") && (lower.includes("invalid") || lower.includes("expired") || lower.includes("used"))) {
+    return { code: "invite_invalid", message: serverMsg, status };
+  }
+  if (status === 401 || lower.includes("unauthorized") || lower.includes("invalid credentials") || lower.includes("bad password")) {
+    return { code: status === 401 ? "unauthorized" : "invalid_credentials", message: serverMsg, status };
+  }
+  if (status === 403) {
+    return { code: "forbidden", message: serverMsg, status };
+  }
+  if (typeof status === "number" && status >= 500) {
+    return { code: "server_error", message: serverMsg, status };
+  }
+  return { code: "unknown", message: serverMsg, status };
+}
+export function usePasswordAuth() {
+  const auth = useAbracadabraAuth();
+  const busy = ref(null);
+  const error = ref(null);
+  const lastSuccess = ref(null);
+  function clearError() {
+    error.value = null;
+  }
+  async function run(action, fn) {
+    busy.value = action;
+    error.value = null;
+    try {
+      await fn();
+      lastSuccess.value = action;
+      return { ok: true };
+    } catch (e) {
+      const err = classifyError(e);
+      error.value = err;
+      return { ok: false, error: err };
+    } finally {
+      busy.value = null;
+    }
+  }
+  async function login(opts) {
+    return run("login", () => auth.loginWithPassword(opts));
+  }
+  async function register(opts) {
+    return run("register", () => auth.registerWithPassword(opts));
+  }
+  async function requestReset(opts) {
+    return run("reset-request", () => auth.requestPasswordReset(opts));
+  }
+  async function confirmReset(opts) {
+    return run("reset-confirm", () => auth.confirmPasswordReset(opts));
+  }
+  async function changePassword(opts) {
+    return run("change", () => auth.changePassword(opts));
+  }
+  async function setPassword(opts) {
+    return run("set", () => auth.setPassword(opts.password));
+  }
+  return {
+    busy,
+    error,
+    lastSuccess,
+    clearError,
+    login,
+    register,
+    requestReset,
+    confirmReset,
+    changePassword,
+    setPassword,
+    /** Internal helper exposed for testing — classify any error to its code. */
+    _classifyError: classifyError
+  };
+}

package/dist/runtime/composables/useTiptapHistory.d.ts

@@ -12,9 +12,9 @@
  *   const history = useTiptapHistory(editorRef)
  *   <UButton :disabled="!history.canUndo.value" @click="history.undo" />
  */
-import { type MaybeRef } from 'vue';
+import { type MaybeRefOrGetter } from 'vue';
 import type { Editor } from '@tiptap/vue-3';
-export declare function useTiptapHistory(editor: MaybeRef<Editor | null | undefined>): {
+export declare function useTiptapHistory(editor: MaybeRefOrGetter<Editor | null | undefined>): {
     canUndo: import("vue").ComputedRef<boolean>;
     canRedo: import("vue").ComputedRef<boolean>;
     undo: () => void;

package/dist/runtime/composables/useTiptapHistory.js

@@ -1,12 +1,12 @@
-import { computed, unref } from "vue";
+import { computed, toValue } from "vue";
 export function useTiptapHistory(editor) {
-  const canUndo = computed(() => !!unref(editor)?.can?.().undo?.());
-  const canRedo = computed(() => !!unref(editor)?.can?.().redo?.());
+  const canUndo = computed(() => !!toValue(editor)?.can?.().undo?.());
+  const canRedo = computed(() => !!toValue(editor)?.can?.().redo?.());
   function undo() {
-    unref(editor)?.commands?.undo?.();
+    toValue(editor)?.commands?.undo?.();
   }
   function redo() {
-    unref(editor)?.commands?.redo?.();
+    toValue(editor)?.commands?.redo?.();
   }
   return { canUndo, canRedo, undo, redo };
 }

package/dist/runtime/extensions/views/MetaFieldView.vue

@@ -140,12 +140,23 @@ function onDateTimeRange(range) {
     [endKey.value]: `${dvToIso(range.end)}T${et}:00.000Z`
   });
 }
-function onStartTime(t2) {
+function asSingleTime(t2) {
+  if (t2 && typeof t2 === "object" && "hour" in t2 && "minute" in t2) {
+    const v = t2;
+    if (typeof v.hour === "number" && typeof v.minute === "number") {
+      return { hour: v.hour, minute: v.minute };
+    }
+  }
+  return null;
+}
+function onStartTime(raw) {
+  const t2 = asSingleTime(raw);
   if (!t2) return;
   const date = getStr(startKey.value).slice(0, 10) || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   patch({ [startKey.value]: `${date}T${timeToHHMM(t2)}:00.000Z` });
 }
-function onEndTime(t2) {
+function onEndTime(raw) {
+  const t2 = asSingleTime(raw);
   if (!t2) return;
   const date = getStr(endKey.value).slice(0, 10) || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   patch({ [endKey.value]: `${date}T${timeToHHMM(t2)}:00.000Z` });
@@ -257,15 +268,18 @@ function onSingleDatetimeDate(d) {
   const time = getStr(metaKey.value).slice(11, 16) || "00:00";
   patch({ [metaKey.value]: `${date}T${time}:00.000Z` });
 }
-function onSingleTime(t2) {
+function onSingleTime(raw) {
+  const t2 = asSingleTime(raw);
   if (!t2) return;
   patch({ [metaKey.value]: timeToHHMM(t2) });
 }
-function onTimeRangeStart(t2) {
+function onTimeRangeStart(raw) {
+  const t2 = asSingleTime(raw);
   if (!t2) return;
   patch({ [startKey.value]: timeToHHMM(t2) });
 }
-function onTimeRangeEnd(t2) {
+function onTimeRangeEnd(raw) {
+  const t2 = asSingleTime(raw);
   if (!t2) return;
   patch({ [endKey.value]: timeToHHMM(t2) });
 }
@@ -1089,7 +1103,10 @@ function removeOption(opt) {
             <UInputTime
               size="sm"
               :model-value="isoToTime(getStr(metaKey).slice(11, 16) || '00:00')"
-              @update:model-value="(t2) => t2 && patch({ [metaKey]: `${getStr(metaKey).slice(0, 10) || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}T${timeToHHMM(t2)}:00.000Z` })"
+              @update:model-value="(raw) => {
+  const t2 = asSingleTime(raw);
+  if (t2) patch({ [metaKey]: `${getStr(metaKey).slice(0, 10) || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}T${timeToHHMM(t2)}:00.000Z` });
+}"
             />
           </div>
         </template>