@open-mercato/core 0.7.1-develop.7178.1.ab93fbaf4e → 0.7.1-develop.7180.1.9717fbbb43

package/dist/modules/staff/lib/time-tracking-ui/TimeEntryDialog.js

@@ -0,0 +1,1499 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { z } from "zod";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { Lock, X } from "lucide-react";
+import {
+  Dialog,
+  DialogContent,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle
+} from "@open-mercato/ui/primitives/dialog";
+import { Alert, AlertDescription, AlertTitle } from "@open-mercato/ui/primitives/alert";
+import { Badge } from "@open-mercato/ui/primitives/badge";
+import { Button } from "@open-mercato/ui/primitives/button";
+import { Input } from "@open-mercato/ui/primitives/input";
+import { Kbd } from "@open-mercato/ui/primitives/kbd";
+import { Label } from "@open-mercato/ui/primitives/label";
+import { Separator } from "@open-mercato/ui/primitives/separator";
+import { Spinner } from "@open-mercato/ui/primitives/spinner";
+import { Switch } from "@open-mercato/ui/primitives/switch";
+import { ErrorMessage, LoadingMessage } from "@open-mercato/ui/backend/detail";
+import { apiCall, apiCallOrThrow, withScopedApiRequestHeaders } from "@open-mercato/ui/backend/utils/apiCall";
+import { TagPicker, tagChipStyle } from "./TagPicker.js";
+import { TaskPicker } from "./TaskPicker.js";
+import { slugifyProjectName } from "../time-tracking/projectCode.js";
+import { autoColorFromName } from "../timesheets-ui/colors.js";
+import { buildOptimisticLockHeader } from "@open-mercato/ui/backend/utils/optimisticLock";
+import { surfaceRecordConflict } from "@open-mercato/ui/backend/conflicts";
+import { normalizeCrudServerError } from "@open-mercato/ui/backend/utils/serverErrors";
+import { useBackendChrome } from "@open-mercato/ui/backend/BackendChromeProvider";
+import { useConfirmDialog } from "@open-mercato/ui/backend/confirm-dialog";
+import { useGuardedMutation } from "@open-mercato/ui/backend/injection/useGuardedMutation";
+import { InjectionSpot, useInjectionSpotEvents } from "@open-mercato/ui/backend/injection/InjectionSpot";
+import { extensionPoints } from "@open-mercato/core/modules/staff/extension-points";
+import { registerComponent } from "@open-mercato/shared/modules/widgets/component-registry";
+import { useRegisteredComponent } from "@open-mercato/ui/backend/injection/useRegisteredComponent";
+import {
+  callbackProp,
+  opaqueProp,
+  optionalCallbackProp
+} from "../time-tracking/componentContracts.js";
+import { extensionSpotChildId } from "@open-mercato/shared/modules/widgets/extension-points";
+import { flash } from "@open-mercato/ui/backend/FlashMessages";
+import { formatCurrency } from "@open-mercato/ui/utils/format";
+import { hasFeature } from "@open-mercato/shared/security/features";
+import { useT } from "@open-mercato/shared/lib/i18n/context";
+import { useOrganizationScopeVersion } from "@open-mercato/shared/lib/frontend/useOrganizationScope";
+import { createLogger } from "@open-mercato/shared/lib/logger";
+import { DurationInput } from "./DurationInput.js";
+import { formatDuration } from "../time-tracking/duration.js";
+import { parseClock } from "../time-tracking/interval.js";
+import { applicableRate, entryAmount } from "../time-tracking/cost.js";
+import { roundMinutes, DEFAULT_ROUNDING_SETTINGS } from "../time-tracking/rounding.js";
+import {
+  combineDateAndClock,
+  createIntervalState,
+  reduceIntervalState,
+  resetIntervalState,
+  readRowItems,
+  readRowString,
+  shiftIsoDate,
+  todayIsoDate,
+  toOverlapEntry,
+  toProjectOption,
+  toTaskOption,
+  toTimeEntryRecord
+} from "./timeEntryDialogState.js";
+const logger = createLogger("staff").child({ component: "TimeEntryDialog" });
+const TIME_ENTRY_DIALOG_MUTATION_CONTEXT_ID = "staff.time_tracking.entryDialog";
+const TIME_ENTRY_ENTITY_ID = "staff:staff_time_entry";
+function fieldValueSnapshot(value) {
+  return JSON.stringify(value ?? null);
+}
+const RATES_FEATURE = "staff.timesheets.rates.view";
+const ENTRIES_LIST_PATH = "/backend/staff/time-tracking/entries";
+const REPORTS_PATH = "/backend/staff/time-tracking/reports";
+const DIALOG_QUERY_ROOT = ["staff", "time-tracking", "entry-dialog"];
+const DIRECTORY_PAGE_SIZE = 100;
+const TASK_SEARCH_PAGE_SIZE = 50;
+const TASK_SEARCH_DEBOUNCE_MS = 250;
+const FALLBACK_SETTINGS = {
+  rounding: { ...DEFAULT_ROUNDING_SETTINGS },
+  defaults: { billable: true, chainStartFromPreviousEnd: true },
+  warnings: { overlap: true }
+};
+function readSettings(payload) {
+  const source = payload ?? {};
+  const rounding = source.rounding ?? {};
+  const defaults = source.defaults ?? {};
+  const warnings = source.warnings ?? {};
+  return {
+    rounding: {
+      unitMinutes: rounding.unitMinutes === 5 || rounding.unitMinutes === 10 || rounding.unitMinutes === 15 ? rounding.unitMinutes : 0,
+      direction: rounding.direction === "nearest" ? "nearest" : "up"
+    },
+    defaults: {
+      billable: typeof defaults.billable === "boolean" ? defaults.billable : true,
+      chainStartFromPreviousEnd: typeof defaults.chainStartFromPreviousEnd === "boolean" ? defaults.chainStartFromPreviousEnd : true
+    },
+    warnings: { overlap: typeof warnings.overlap === "boolean" ? warnings.overlap : true }
+  };
+}
+function parseRateText(value) {
+  const trimmed = value.trim().replace(",", ".");
+  if (!trimmed) return null;
+  const parsed = Number(trimmed);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+}
+const NO_FIELD_ISSUES = { task: null, duration: null };
+function readFieldIssues(error) {
+  const { fieldErrors } = normalizeCrudServerError(error);
+  if (!fieldErrors) return null;
+  const task = fieldErrors.taskId ?? fieldErrors.task ?? null;
+  const duration = fieldErrors.durationMinutes ?? fieldErrors.duration ?? null;
+  if (!task && !duration) return null;
+  return { task, duration };
+}
+function formSnapshot(values) {
+  return JSON.stringify([
+    values.taskId,
+    values.description.trim(),
+    values.date,
+    values.startText,
+    values.endText,
+    values.durationMinutes,
+    values.isBillable,
+    values.rateOverrideEnabled,
+    values.rateOverrideAmount,
+    [...values.tagIds].sort((a, b) => a < b ? -1 : a > b ? 1 : 0)
+  ]);
+}
+async function fetchTaskOptions(term) {
+  const params = new URLSearchParams({
+    page: "1",
+    pageSize: String(TASK_SEARCH_PAGE_SIZE),
+    sortField: "title",
+    sortDir: "asc"
+  });
+  const responses = await Promise.all(
+    [
+      `/api/staff/timesheets/tasks?${params.toString()}&q=${encodeURIComponent(term)}`,
+      `/api/staff/timesheets/tasks?${params.toString()}&reference=${encodeURIComponent(term)}`
+    ].map((url) => apiCall(url).catch(() => null))
+  );
+  const merged = /* @__PURE__ */ new Map();
+  for (const response of responses) {
+    if (!response?.ok) continue;
+    for (const row of readRowItems(response.result)) {
+      const option = toTaskOption(row);
+      if (option && !merged.has(option.id)) merged.set(option.id, option);
+    }
+  }
+  return [...merged.values()];
+}
+async function fetchTaskById(id) {
+  const call = await apiCall(
+    `/api/staff/timesheets/tasks?ids=${encodeURIComponent(id)}&pageSize=1`
+  );
+  if (!call.ok) return null;
+  const row = readRowItems(call.result)[0];
+  return row ? toTaskOption(row) : null;
+}
+function readErrorCode(error) {
+  const body = error?.body;
+  if (body && typeof body.code === "string") return body.code;
+  if (body && typeof body.error === "string") return body.error;
+  return null;
+}
+function DefaultTimeEntryDialog({
+  open,
+  onOpenChange,
+  entryId,
+  defaults,
+  headerHint,
+  onSaved,
+  onShowEntry
+}) {
+  const t = useT();
+  const scopeVersion = useOrganizationScopeVersion();
+  const { payload } = useBackendChrome();
+  const { confirm, ConfirmDialogElement } = useConfirmDialog();
+  const canSeeMoney = hasFeature(payload?.grantedFeatures, RATES_FEATURE);
+  const isEdit = typeof entryId === "string" && entryId.length > 0;
+  const [taskId, setTaskId] = React.useState(null);
+  const [description, setDescription] = React.useState("");
+  const [date, setDate] = React.useState(() => todayIsoDate());
+  const [interval, setIntervalState] = React.useState(() => createIntervalState({}));
+  const [isBillable, setIsBillable] = React.useState(true);
+  const [rateOverrideEnabled, setRateOverrideEnabled] = React.useState(false);
+  const [rateText, setRateText] = React.useState("");
+  const [tagIds, setTagIds] = React.useState([]);
+  const [overlaps, setOverlaps] = React.useState([]);
+  const [savingMode, setSavingMode] = React.useState(null);
+  const [fieldIssues, setFieldIssues] = React.useState(NO_FIELD_ISSUES);
+  const saving = savingMode !== null;
+  const [taskSearch, setTaskSearch] = React.useState("");
+  const [debouncedTaskSearch, setDebouncedTaskSearch] = React.useState("");
+  const [pinnedTask, setPinnedTask] = React.useState(null);
+  const [baseline, setBaseline] = React.useState(null);
+  const taskTriggerRef = React.useRef(null);
+  const focusTaskPicker = React.useCallback(() => {
+    const host = taskTriggerRef.current;
+    if (!host) return false;
+    const focusable = host.querySelector("input, select, button");
+    if (!focusable) return false;
+    focusable.focus();
+    return true;
+  }, []);
+  const seedKeyRef = React.useRef(null);
+  const billableDefaultRef = React.useRef(null);
+  const versionRef = React.useRef(null);
+  const { runMutation, retryLastMutation } = useGuardedMutation({
+    contextId: TIME_ENTRY_DIALOG_MUTATION_CONTEXT_ID,
+    blockedMessage: t("staff.time_tracking.entryDialog.errors.save", "Could not save the time entry.")
+  });
+  const settingsQuery = useQuery({
+    queryKey: [...DIALOG_QUERY_ROOT, "settings", `scope:${scopeVersion}`],
+    enabled: open,
+    staleTime: 3e5,
+    queryFn: async () => {
+      const call = await apiCall("/api/staff/timesheets/settings");
+      return call.ok ? readSettings(call.result) : FALLBACK_SETTINGS;
+    }
+  });
+  const settings = settingsQuery.data ?? FALLBACK_SETTINGS;
+  const selfQuery = useQuery({
+    queryKey: [...DIALOG_QUERY_ROOT, "self", `scope:${scopeVersion}`],
+    enabled: open,
+    staleTime: 3e5,
+    queryFn: async () => {
+      const call = await apiCall(
+        "/api/staff/team-members/self"
+      );
+      const member = call.ok ? call.result?.member ?? null : null;
+      if (!member?.id) return null;
+      return { id: member.id, displayName: member.displayName ?? "" };
+    }
+  });
+  const tasksQuery = useQuery({
+    queryKey: [...DIALOG_QUERY_ROOT, "tasks", `scope:${scopeVersion}`],
+    enabled: open,
+    staleTime: 6e4,
+    queryFn: async () => {
+      const call = await apiCall(
+        `/api/staff/timesheets/tasks?page=1&pageSize=${DIRECTORY_PAGE_SIZE}&sortField=title&sortDir=asc`
+      );
+      if (!call.ok) return [];
+      return readRowItems(call.result).map(toTaskOption).filter((task) => task !== null);
+    }
+  });
+  React.useEffect(() => {
+    if (!open) {
+      setDebouncedTaskSearch("");
+      return;
+    }
+    const handle = setTimeout(() => setDebouncedTaskSearch(taskSearch.trim()), TASK_SEARCH_DEBOUNCE_MS);
+    return () => clearTimeout(handle);
+  }, [open, taskSearch]);
+  const taskSearchQuery = useQuery({
+    queryKey: [...DIALOG_QUERY_ROOT, "task-search", `scope:${scopeVersion}`, debouncedTaskSearch],
+    enabled: open && debouncedTaskSearch.length > 0,
+    staleTime: 6e4,
+    queryFn: () => fetchTaskOptions(debouncedTaskSearch)
+  });
+  const projectsQuery = useQuery({
+    queryKey: [...DIALOG_QUERY_ROOT, "projects", `scope:${scopeVersion}`],
+    enabled: open,
+    staleTime: 6e4,
+    queryFn: async () => {
+      const call = await apiCall(
+        `/api/staff/timesheets/time-projects?page=1&pageSize=${DIRECTORY_PAGE_SIZE}&sortField=name&sortDir=asc`
+      );
+      if (!call.ok) return [];
+      return readRowItems(call.result).map(toProjectOption).filter((project2) => project2 !== null);
+    }
+  });
+  const staffMemberId = selfQuery.data?.id ?? null;
+  const statusesQuery = useQuery({
+    queryKey: [...DIALOG_QUERY_ROOT, "task-statuses", `scope:${scopeVersion}`],
+    enabled: open,
+    staleTime: 3e5,
+    queryFn: async () => {
+      const call = await apiCall(
+        `/api/staff/timesheets/task-statuses?page=1&pageSize=${DIRECTORY_PAGE_SIZE}`
+      );
+      if (!call.ok) return {};
+      const map = {};
+      for (const row of readRowItems(call.result)) {
+        const id = readRowString(row, "id");
+        if (!id) continue;
+        map[id] = {
+          id,
+          name: readRowString(row, "name") ?? "",
+          color: readRowString(row, "color"),
+          isDone: row.is_done === true || row.isDone === true
+        };
+      }
+      return map;
+    }
+  });
+  const recentQuery = useQuery({
+    queryKey: [...DIALOG_QUERY_ROOT, "recent-tasks", `scope:${scopeVersion}`, staffMemberId ?? "none"],
+    enabled: open && !!staffMemberId,
+    staleTime: 6e4,
+    queryFn: async () => {
+      const since = shiftIsoDate(todayIsoDate(), -21);
+      const call = await apiCall(
+        `/api/staff/timesheets/time-entries?page=1&pageSize=100&sortField=date&sortDir=desc&staffMemberId=${encodeURIComponent(staffMemberId)}&from=${since}`
+      );
+      if (!call.ok) return [];
+      const seen = [];
+      for (const row of readRowItems(call.result)) {
+        const taskId2 = readRowString(row, "task_id", "taskId");
+        if (taskId2 && !seen.includes(taskId2)) seen.push(taskId2);
+        if (seen.length >= 6) break;
+      }
+      return seen;
+    }
+  });
+  const tagsQuery = useQuery({
+    queryKey: [...DIALOG_QUERY_ROOT, "tags", `scope:${scopeVersion}`],
+    enabled: open,
+    staleTime: 3e5,
+    queryFn: async () => {
+      const call = await apiCall(
+        `/api/staff/timesheets/tags?page=1&pageSize=${DIRECTORY_PAGE_SIZE}&sortField=label&sortDir=asc`
+      );
+      if (!call.ok) return [];
+      return readRowItems(call.result).map((row) => {
+        const id = readRowString(row, "id");
+        return id ? { id, label: readRowString(row, "label") ?? id, color: readRowString(row, "color") } : null;
+      }).filter((tag) => tag !== null);
+    }
+  });
+  const entryQuery = useQuery({
+    queryKey: [...DIALOG_QUERY_ROOT, "entry", `scope:${scopeVersion}`, entryId ?? "new"],
+    enabled: open && isEdit,
+    staleTime: 0,
+    queryFn: async () => {
+      const call = await apiCall(
+        `/api/staff/timesheets/time-entries?ids=${encodeURIComponent(entryId)}&pageSize=1`
+      );
+      if (!call.ok) throw new Error("[internal] time entry request failed");
+      const row = readRowItems(call.result)[0];
+      if (!row) return null;
+      const record = toTimeEntryRecord(row);
+      if (!record) return null;
+      if (record.id !== entryId) {
+        throw new Error("[internal] time entry response did not match the requested id");
+      }
+      return record;
+    }
+  });
+  const entry = entryQuery.data ?? null;
+  const locked = !!entry?.isLocked;
+  const lockedReportId = entry?.lockedReportId ?? null;
+  const directoryTasks = React.useMemo(() => tasksQuery.data ?? [], [tasksQuery.data]);
+  const searchedTasks = React.useMemo(() => taskSearchQuery.data ?? [], [taskSearchQuery.data]);
+  React.useEffect(() => {
+    if (!taskId) {
+      setPinnedTask(null);
+      return;
+    }
+    const found = directoryTasks.find((task) => task.id === taskId) ?? searchedTasks.find((task) => task.id === taskId) ?? null;
+    if (found) setPinnedTask(found);
+  }, [directoryTasks, searchedTasks, taskId]);
+  const unresolvedTaskId = taskId && !pinnedTask && !tasksQuery.isPending && !taskSearchQuery.isFetching ? taskId : null;
+  const unresolvedTaskQuery = useQuery({
+    queryKey: [...DIALOG_QUERY_ROOT, "task", `scope:${scopeVersion}`, unresolvedTaskId ?? "none"],
+    enabled: open && !!unresolvedTaskId,
+    staleTime: 6e4,
+    queryFn: () => fetchTaskById(unresolvedTaskId)
+  });
+  const tasks = React.useMemo(() => {
+    const merged = /* @__PURE__ */ new Map();
+    for (const task of directoryTasks) merged.set(task.id, task);
+    for (const task of searchedTasks) if (!merged.has(task.id)) merged.set(task.id, task);
+    for (const task of [pinnedTask, unresolvedTaskQuery.data ?? null]) {
+      if (task && !merged.has(task.id)) merged.set(task.id, task);
+    }
+    return [...merged.values()];
+  }, [directoryTasks, pinnedTask, searchedTasks, unresolvedTaskQuery.data]);
+  const projects = React.useMemo(() => projectsQuery.data ?? [], [projectsQuery.data]);
+  const tagOptions = React.useMemo(() => tagsQuery.data ?? [], [tagsQuery.data]);
+  const projectById = React.useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const project2 of projects) map.set(project2.id, project2);
+    return map;
+  }, [projects]);
+  const selectedTask = React.useMemo(
+    () => tasks.find((task) => task.id === taskId) ?? null,
+    [taskId, tasks]
+  );
+  const projectId = selectedTask?.timeProjectId ?? entry?.timeProjectId ?? defaults?.timeProjectId ?? null;
+  const project = projectId ? projectById.get(projectId) ?? null : null;
+  const resetForm = React.useCallback(
+    (seed) => {
+      setTaskId(seed.taskId);
+      setDescription(seed.description);
+      setDate(seed.date || todayIsoDate());
+      setIntervalState(
+        (current) => resetIntervalState(current, {
+          start: seed.start,
+          end: seed.end,
+          durationMinutes: seed.durationMinutes
+        })
+      );
+      setIsBillable(seed.isBillable);
+      setRateOverrideEnabled(seed.rateOverrideAmount !== null);
+      setRateText(seed.rateOverrideAmount !== null ? String(seed.rateOverrideAmount) : "");
+      setTagIds(seed.tagIds);
+      setOverlaps([]);
+      setFieldIssues(NO_FIELD_ISSUES);
+      const derived = createIntervalState({
+        start: seed.start,
+        end: seed.end,
+        durationMinutes: seed.durationMinutes
+      });
+      setBaseline({
+        taskId: seed.taskId,
+        description: seed.description,
+        date: seed.date || todayIsoDate(),
+        startText: derived.startText,
+        endText: derived.endText,
+        durationMinutes: derived.durationMinutes,
+        isBillable: seed.isBillable,
+        rateOverrideEnabled: seed.rateOverrideAmount !== null,
+        rateOverrideAmount: seed.rateOverrideAmount,
+        tagIds: seed.tagIds
+      });
+    },
+    []
+  );
+  React.useEffect(() => {
+    if (!open) {
+      seedKeyRef.current = null;
+      billableDefaultRef.current = null;
+      setBaseline(null);
+      setTaskSearch("");
+      setPinnedTask(null);
+      return;
+    }
+    if (isEdit && !entry) return;
+    const key = isEdit ? `edit:${entry?.id ?? entryId}:${entry?.updatedAt ?? ""}` : "create";
+    if (seedKeyRef.current === key) return;
+    seedKeyRef.current = key;
+    versionRef.current = entry?.updatedAt ?? null;
+    if (entry) {
+      resetForm({
+        taskId: entry.taskId,
+        description: entry.description,
+        date: entry.date,
+        start: entry.startText,
+        end: entry.endText,
+        durationMinutes: entry.durationMinutes,
+        isBillable: entry.isBillable,
+        rateOverrideAmount: entry.rateOverrideAmount,
+        tagIds: entry.tagIds
+      });
+      return;
+    }
+    resetForm({
+      taskId: defaults?.taskId ?? null,
+      description: defaults?.description ?? "",
+      date: defaults?.date ?? todayIsoDate(),
+      start: defaults?.startClock ?? null,
+      end: defaults?.endClock ?? null,
+      durationMinutes: defaults?.durationMinutes ?? null,
+      isBillable: defaults?.isBillable ?? true,
+      rateOverrideAmount: null,
+      tagIds: defaults?.tagIds ?? []
+    });
+  }, [defaults, entry, entryId, isEdit, open, resetForm]);
+  React.useEffect(() => {
+    if (!open || isEdit || settingsQuery.isPending) return;
+    if (defaults?.isBillable !== void 0 && defaults?.isBillable !== null) return;
+    if (billableDefaultRef.current === seedKeyRef.current) return;
+    billableDefaultRef.current = seedKeyRef.current;
+    setIsBillable(settings.defaults.billable);
+    setBaseline(
+      (current) => current ? { ...current, isBillable: settings.defaults.billable } : current
+    );
+  }, [defaults?.isBillable, isEdit, open, settings.defaults.billable, settingsQuery.isPending]);
+  const durationMinutes = interval.durationMinutes;
+  const startClock = interval.startText;
+  const endClock = interval.endText;
+  React.useEffect(() => {
+    if (!open || locked || !settings.warnings.overlap) {
+      setOverlaps([]);
+      return;
+    }
+    if (!date || parseClock(startClock) === null || !durationMinutes) {
+      setOverlaps([]);
+      return;
+    }
+    let cancelled = false;
+    const params = new URLSearchParams({
+      date,
+      startedAt: startClock,
+      durationMinutes: String(durationMinutes)
+    });
+    if (parseClock(endClock) !== null) params.set("endedAt", endClock);
+    if (isEdit && entryId) params.set("excludeId", entryId);
+    void apiCall(`/api/staff/timesheets/time-entries/overlaps?${params.toString()}`).then((call) => {
+      if (cancelled) return;
+      if (!call.ok) {
+        setOverlaps([]);
+        return;
+      }
+      setOverlaps(
+        readRowItems(call.result).map(toOverlapEntry).filter((item) => item !== null)
+      );
+    }).catch(() => {
+      if (!cancelled) setOverlaps([]);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [date, durationMinutes, endClock, entryId, isEdit, locked, open, settings.warnings.overlap, startClock]);
+  const rateOverrideAmount = rateOverrideEnabled ? parseRateText(rateText) : null;
+  const currencyCode = project?.currencyCode ?? entry?.currencyCode ?? null;
+  const entryFormValues = React.useMemo(
+    () => ({
+      taskId,
+      description,
+      date,
+      startText: startClock,
+      endText: endClock,
+      durationMinutes,
+      isBillable,
+      rateOverrideEnabled,
+      rateOverrideAmount,
+      tagIds
+    }),
+    [
+      date,
+      description,
+      durationMinutes,
+      endClock,
+      isBillable,
+      rateOverrideAmount,
+      rateOverrideEnabled,
+      startClock,
+      tagIds,
+      taskId
+    ]
+  );
+  const entryInjectionContext = React.useMemo(
+    () => ({
+      formId: TIME_ENTRY_DIALOG_MUTATION_CONTEXT_ID,
+      entityId: TIME_ENTRY_ENTITY_ID,
+      recordId: entryId ?? null,
+      resourceKind: "staff.timesheets.time_entry",
+      resourceId: entryId ?? "new",
+      operation: isEdit ? "update" : "create",
+      locked,
+      retryLastMutation
+    }),
+    [entryId, isEdit, locked, retryLastMutation]
+  );
+  const { triggerEvent: triggerEntryFormEvent } = useInjectionSpotEvents(extensionPoints.hosts.timeEntryForm.spotId);
+  const injectedFieldWritesRef = React.useRef(/* @__PURE__ */ new Set());
+  const applyInjectedFieldValue = React.useCallback((fieldId, value) => {
+    switch (fieldId) {
+      case "taskId":
+        injectedFieldWritesRef.current.add(fieldId);
+        setTaskId(typeof value === "string" && value.length > 0 ? value : null);
+        return;
+      case "description":
+        injectedFieldWritesRef.current.add(fieldId);
+        setDescription(typeof value === "string" ? value : "");
+        return;
+      case "date":
+        if (typeof value !== "string") return;
+        injectedFieldWritesRef.current.add(fieldId);
+        setDate(value);
+        return;
+      case "isBillable":
+        injectedFieldWritesRef.current.add(fieldId);
+        setIsBillable(value === true);
+        return;
+      case "rateOverrideEnabled":
+        injectedFieldWritesRef.current.add(fieldId);
+        setRateOverrideEnabled(value === true);
+        return;
+      case "rateOverrideAmount":
+        injectedFieldWritesRef.current.add(fieldId);
+        setRateText(typeof value === "number" || typeof value === "string" ? String(value) : "");
+        return;
+      case "tagIds":
+        if (!Array.isArray(value)) return;
+        injectedFieldWritesRef.current.add(fieldId);
+        setTagIds(value.filter((id) => typeof id === "string"));
+        return;
+      case "startText":
+        if (typeof value !== "string") return;
+        injectedFieldWritesRef.current.add(fieldId);
+        setIntervalState((current) => reduceIntervalState(current, { field: "start", value }));
+        return;
+      case "endText":
+        if (typeof value !== "string") return;
+        injectedFieldWritesRef.current.add(fieldId);
+        setIntervalState((current) => reduceIntervalState(current, { field: "end", value }));
+        return;
+      case "durationMinutes":
+        injectedFieldWritesRef.current.add(fieldId);
+        setIntervalState(
+          (current) => reduceIntervalState(current, {
+            field: "duration",
+            minutes: typeof value === "number" ? value : null,
+            invalid: false
+          })
+        );
+        return;
+      default:
+    }
+  }, []);
+  const previousEntryFormValuesRef = React.useRef(null);
+  React.useEffect(() => {
+    if (!open || locked) {
+      previousEntryFormValuesRef.current = null;
+      injectedFieldWritesRef.current.clear();
+      return;
+    }
+    const previous = previousEntryFormValuesRef.current;
+    previousEntryFormValuesRef.current = entryFormValues;
+    if (!previous) return;
+    const injectedWrites = injectedFieldWritesRef.current;
+    const changedFieldIds = Object.keys(entryFormValues).filter(
+      (fieldId) => fieldValueSnapshot(previous[fieldId]) !== fieldValueSnapshot(entryFormValues[fieldId])
+    );
+    for (const fieldId of changedFieldIds) {
+      if (injectedWrites.delete(fieldId)) continue;
+      void triggerEntryFormEvent("onFieldChange", entryFormValues, entryInjectionContext, {
+        fieldId,
+        fieldValue: entryFormValues[fieldId]
+      }).then((result) => {
+        if (!result.ok || !result.fieldChange) return;
+        const change = result.fieldChange;
+        if (change.value !== void 0) applyInjectedFieldValue(fieldId, change.value);
+        for (const [sideFieldId, sideValue] of Object.entries(change.sideEffects ?? {})) {
+          applyInjectedFieldValue(sideFieldId, sideValue);
+        }
+        for (const message of change.messages ?? []) flash(message.text, message.severity);
+      }).catch((err) => {
+        logger.error("staff.time_tracking entry dialog onFieldChange failed", { err });
+      });
+    }
+  }, [
+    applyInjectedFieldValue,
+    entryFormValues,
+    entryInjectionContext,
+    locked,
+    open,
+    triggerEntryFormEvent
+  ]);
+  const roundedMinutes = roundMinutes(durationMinutes ?? 0, settings.rounding);
+  const rate = applicableRate({ rateOverrideAmount }, { hourlyRate: project?.hourlyRate ?? null });
+  const cost = entryAmount(
+    { isBillable, roundedMinutes, rateOverrideAmount },
+    { hourlyRate: project?.hourlyRate ?? null }
+  );
+  const computedBadge = (field) => /* @__PURE__ */ jsx(Badge, { variant: "neutral", "data-testid": `entry-dialog-computed-${field}`, children: t("staff.time_tracking.entryDialog.computed", "computed") });
+  const midnightEndDate = interval.crossesMidnight ? shiftIsoDate(date, 1) : null;
+  const canSubmit = !locked && !interval.durationInvalid && !saving;
+  React.useEffect(() => {
+    if (!taskId) return;
+    setFieldIssues((current) => current.task ? { ...current, task: null } : current);
+  }, [taskId]);
+  React.useEffect(() => {
+    if (!durationMinutes) return;
+    setFieldIssues((current) => current.duration ? { ...current, duration: null } : current);
+  }, [durationMinutes]);
+  const validateRequired = React.useCallback(() => {
+    const next = {
+      task: taskId ? null : t("staff.time_tracking.entryDialog.errors.taskRequired", "Pick the task this time belongs to."),
+      duration: durationMinutes ? null : t("staff.time_tracking.entryDialog.errors.durationRequired", "Enter how long the work took.")
+    };
+    setFieldIssues(next);
+    return !next.task && !next.duration;
+  }, [durationMinutes, t, taskId]);
+  const isDirty = React.useMemo(() => {
+    if (locked || !baseline) return false;
+    return formSnapshot(baseline) !== formSnapshot({
+      taskId,
+      description,
+      date,
+      startText: startClock,
+      endText: endClock,
+      durationMinutes,
+      isBillable,
+      rateOverrideEnabled,
+      rateOverrideAmount,
+      tagIds
+    });
+  }, [
+    baseline,
+    date,
+    description,
+    durationMinutes,
+    endClock,
+    isBillable,
+    locked,
+    rateOverrideAmount,
+    rateOverrideEnabled,
+    startClock,
+    tagIds,
+    taskId
+  ]);
+  const requestClose = React.useCallback(async () => {
+    if (saving) return;
+    if (!isDirty) {
+      onOpenChange(false);
+      return;
+    }
+    const confirmed = await confirm({
+      title: t("staff.time_tracking.entryDialog.discard.title", "Discard this time entry?"),
+      text: t(
+        "staff.time_tracking.entryDialog.discard.text",
+        "It has not been saved yet, so closing now loses what you entered."
+      ),
+      confirmText: t("staff.time_tracking.entryDialog.discard.confirm", "Discard"),
+      cancelText: t("staff.time_tracking.entryDialog.discard.cancel", "Keep editing"),
+      variant: "destructive"
+    });
+    if (confirmed) onOpenChange(false);
+  }, [confirm, isDirty, onOpenChange, saving, t]);
+  const buildPayload = React.useCallback(() => {
+    const startedAt = parseClock(startClock) !== null ? combineDateAndClock(date, startClock) : null;
+    const endedAt = parseClock(endClock) !== null ? combineDateAndClock(date, endClock, interval.crossesMidnight ? 1 : 0) : null;
+    return {
+      date,
+      durationMinutes: durationMinutes ?? 0,
+      startedAt,
+      endedAt,
+      taskId,
+      timeProjectId: projectId,
+      description: description.trim() ? description.trim() : null,
+      isBillable,
+      tagIds,
+      rateOverrideAmount: canSeeMoney ? rateOverrideAmount : void 0
+    };
+  }, [
+    canSeeMoney,
+    date,
+    description,
+    durationMinutes,
+    endClock,
+    interval.crossesMidnight,
+    isBillable,
+    projectId,
+    rateOverrideAmount,
+    startClock,
+    tagIds,
+    taskId
+  ]);
+  const reportFailure = React.useCallback(
+    (error) => {
+      if (surfaceRecordConflict(error, t)) return;
+      if (readErrorCode(error) === "entry_locked") {
+        flash(
+          t(
+            "staff.time_tracking.entryDialog.locked.notice",
+            "This entry is closed in a report, so it can no longer be edited."
+          ),
+          "error"
+        );
+        return;
+      }
+      const issues = readFieldIssues(error);
+      if (issues) {
+        setFieldIssues(issues);
+        return;
+      }
+      logger.error("staff.time_tracking entry dialog save failed", { err: error });
+      flash(
+        error instanceof Error && error.message ? error.message : t("staff.time_tracking.entryDialog.errors.save", "Could not save the time entry."),
+        "error"
+      );
+    },
+    [t]
+  );
+  const submit = React.useCallback(
+    async (mode) => {
+      if (!canSubmit) return;
+      if (!validateRequired()) return;
+      if (!isEdit && !staffMemberId) {
+        flash(
+          t(
+            "staff.time_tracking.entryDialog.errors.noStaffMember",
+            "Your account is not linked to a staff member, so time cannot be logged."
+          ),
+          "error"
+        );
+        return;
+      }
+      const body2 = buildPayload();
+      const beforeSave = await triggerEntryFormEvent("onBeforeSave", entryFormValues, entryInjectionContext);
+      if (!beforeSave.ok) {
+        if (beforeSave.fieldErrors) {
+          const taskIssue = beforeSave.fieldErrors.taskId ?? beforeSave.fieldErrors.task ?? null;
+          const durationIssue = beforeSave.fieldErrors.durationMinutes ?? beforeSave.fieldErrors.duration ?? null;
+          if (taskIssue || durationIssue) setFieldIssues({ task: taskIssue, duration: durationIssue });
+        }
+        flash(
+          beforeSave.message || t("ui.forms.flash.saveBlocked", "Save blocked by validation"),
+          "error"
+        );
+        return;
+      }
+      const injectedRequestHeaders = beforeSave.requestHeaders ?? {};
+      setSavingMode(mode);
+      try {
+        const saved = await runMutation({
+          operation: () => withScopedApiRequestHeaders(
+            {
+              ...injectedRequestHeaders,
+              ...isEdit ? buildOptimisticLockHeader(versionRef.current) : {}
+            },
+            () => apiCallOrThrow(
+              "/api/staff/timesheets/time-entries",
+              {
+                method: isEdit ? "PUT" : "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify(
+                  isEdit ? { id: entryId, ...body2 } : { staffMemberId, source: "manual", ...body2 }
+                )
+              },
+              {
+                errorMessage: t(
+                  "staff.time_tracking.entryDialog.errors.save",
+                  "Could not save the time entry."
+                )
+              }
+            )
+          ),
+          context: {
+            formId: TIME_ENTRY_DIALOG_MUTATION_CONTEXT_ID,
+            resourceKind: "staff.timesheets.time_entry",
+            resourceId: entryId ?? "new",
+            retryLastMutation
+          }
+        });
+        const savedId = typeof saved?.result?.id === "string" ? saved.result.id : entryId ?? null;
+        try {
+          await triggerEntryFormEvent("onAfterSave", entryFormValues, entryInjectionContext);
+        } catch (err) {
+          logger.error("staff.time_tracking entry dialog onAfterSave failed", { err });
+        }
+        flash(t("staff.time_tracking.entryDialog.saved", "Time entry saved."), "success");
+        if (mode === "again") {
+          const chain = settings.defaults.chainStartFromPreviousEnd;
+          const nextDate = interval.crossesMidnight && midnightEndDate ? midnightEndDate : date;
+          const nextStart = chain ? endClock || null : null;
+          seedKeyRef.current = "create";
+          setDescription("");
+          setDate(nextDate);
+          setIntervalState((current) => resetIntervalState(current, { start: nextStart }));
+          setOverlaps([]);
+          setBaseline({
+            taskId,
+            description: "",
+            date: nextDate,
+            startText: nextStart ?? "",
+            endText: "",
+            durationMinutes: null,
+            isBillable,
+            rateOverrideEnabled,
+            rateOverrideAmount,
+            tagIds
+          });
+          onSaved?.({ id: savedId, keptOpen: true });
+          focusTaskPicker();
+          return;
+        }
+        onSaved?.({ id: savedId, keptOpen: false });
+        onOpenChange(false);
+      } catch (error) {
+        reportFailure(error);
+      } finally {
+        setSavingMode(null);
+      }
+    },
+    [
+      buildPayload,
+      canSubmit,
+      date,
+      endClock,
+      entryFormValues,
+      entryId,
+      entryInjectionContext,
+      interval.crossesMidnight,
+      isBillable,
+      isEdit,
+      midnightEndDate,
+      onOpenChange,
+      onSaved,
+      rateOverrideAmount,
+      rateOverrideEnabled,
+      reportFailure,
+      retryLastMutation,
+      runMutation,
+      settings.defaults.chainStartFromPreviousEnd,
+      staffMemberId,
+      t,
+      tagIds,
+      taskId,
+      triggerEntryFormEvent,
+      validateRequired
+    ]
+  );
+  const handleShowOverlap = React.useCallback(
+    (overlap2) => {
+      if (onShowEntry) {
+        onShowEntry(overlap2.id);
+        return;
+      }
+      window.open(`${ENTRIES_LIST_PATH}?ids=${encodeURIComponent(overlap2.id)}`, "_blank", "noopener");
+    },
+    [onShowEntry]
+  );
+  const pickerItems = React.useMemo(
+    () => tasks.map((task) => {
+      const project2 = task.timeProjectId ? projectById.get(task.timeProjectId) : void 0;
+      return {
+        id: task.id,
+        reference: task.reference,
+        title: task.title,
+        projectId: task.timeProjectId,
+        projectName: project2?.name ?? null,
+        customerName: project2?.customerName ?? null,
+        statusId: task.taskStatusId ?? null,
+        assigneeInitials: null,
+        assigneeName: null,
+        loggedMinutes: task.loggedMinutes ?? null
+      };
+    }),
+    [projectById, tasks]
+  );
+  const queryClient = useQueryClient();
+  const createTag = React.useCallback(
+    async (label) => {
+      const color = autoColorFromName(label).key;
+      try {
+        const created = await apiCallOrThrow(
+          "/api/staff/timesheets/tags",
+          {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ label, slug: slugifyProjectName(label).toLowerCase(), color })
+          },
+          { errorMessage: t("staff.time_tracking.entryDialog.errors.createTag", "Could not create the tag.") }
+        );
+        const id = typeof created?.result?.id === "string" ? created.result.id : null;
+        if (!id) return null;
+        const option = { id, label, color };
+        queryClient.setQueryData(
+          [...DIALOG_QUERY_ROOT, "tags", `scope:${scopeVersion}`],
+          (current) => [...current ?? [], option]
+        );
+        await queryClient.invalidateQueries({ queryKey: [...DIALOG_QUERY_ROOT, "tags"] });
+        return option;
+      } catch (error) {
+        logger.warn("staff.time_tracking.entryDialog tag create failed", { err: error });
+        flash(t("staff.time_tracking.entryDialog.errors.createTag", "Could not create the tag."), "error");
+        return null;
+      }
+    },
+    [queryClient, scopeVersion, t]
+  );
+  const overlap = overlaps[0] ?? null;
+  const availableTags = React.useMemo(
+    () => tagOptions.filter((tag) => !tagIds.includes(tag.id)),
+    [tagIds, tagOptions]
+  );
+  const assignedTags = React.useMemo(() => {
+    const byId = new Map(tagOptions.map((tag) => [tag.id, tag]));
+    return tagIds.map((id) => byId.get(id) ?? { id, label: id, color: null });
+  }, [tagIds, tagOptions]);
+  const rateLabel = rate !== null ? formatCurrency(rate, currencyCode) ?? String(rate) : null;
+  const projectRateLabel = project?.hourlyRate !== null && project?.hourlyRate !== void 0 ? formatCurrency(project.hourlyRate, currencyCode) ?? String(project.hourlyRate) : null;
+  const body = (() => {
+    if (isEdit && entryQuery.isLoading) {
+      return /* @__PURE__ */ jsx(LoadingMessage, { label: t("staff.time_tracking.entryDialog.loading", "Loading the time entry\u2026") });
+    }
+    if (isEdit && entryQuery.isError) {
+      return /* @__PURE__ */ jsx(ErrorMessage, { label: t("staff.time_tracking.entryDialog.errors.load", "Could not load the time entry.") });
+    }
+    if (isEdit && !entry) {
+      return /* @__PURE__ */ jsx(ErrorMessage, { label: t("staff.time_tracking.entryDialog.errors.notFound", "Time entry not found or not accessible.") });
+    }
+    return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-4", children: [
+      /* @__PURE__ */ jsx(
+        InjectionSpot,
+        {
+          spotId: extensionSpotChildId(extensionPoints.hosts.timeEntryForm.spotId, "before-fields"),
+          context: entryInjectionContext,
+          data: entryFormValues
+        }
+      ),
+      locked ? /* @__PURE__ */ jsxs(Alert, { status: "warning", "data-testid": "entry-dialog-locked", children: [
+        /* @__PURE__ */ jsxs(AlertTitle, { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsx(Lock, { className: "size-3.5", "aria-hidden": "true" }),
+          t("staff.time_tracking.entryDialog.locked.badge", "Locked")
+        ] }),
+        /* @__PURE__ */ jsx(AlertDescription, { children: t(
+          "staff.time_tracking.entryDialog.locked.notice",
+          "This entry is closed in a report, so it can no longer be edited."
+        ) }),
+        lockedReportId ? /* @__PURE__ */ jsx(
+          Button,
+          {
+            type: "button",
+            variant: "outline",
+            size: "sm",
+            className: "mt-2",
+            "data-testid": "entry-dialog-locked-report",
+            onClick: () => window.open(`${REPORTS_PATH}?id=${encodeURIComponent(lockedReportId)}`, "_blank", "noopener"),
+            children: t("staff.time_tracking.entryDialog.locked.showReport", "Show the report")
+          }
+        ) : null
+      ] }) : null,
+      /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1.5", children: [
+        /* @__PURE__ */ jsxs(Label, { htmlFor: "entry-dialog-task", children: [
+          t("staff.time_tracking.entryDialog.task", "Task"),
+          /* @__PURE__ */ jsx("span", { "aria-hidden": "true", children: " *" })
+        ] }),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            "data-testid": "entry-dialog-task",
+            ref: taskTriggerRef,
+            "aria-invalid": fieldIssues.task ? true : void 0,
+            "aria-describedby": fieldIssues.task ? "entry-dialog-task-message" : void 0,
+            children: /* @__PURE__ */ jsx(
+              TaskPicker,
+              {
+                value: taskId,
+                onChange: (next) => setTaskId(next || null),
+                items: pickerItems,
+                recentTaskIds: recentQuery.data ?? [],
+                statuses: statusesQuery.data ?? {},
+                onQueryChange: setTaskSearch,
+                searching: taskSearchQuery.isFetching,
+                loading: tasksQuery.isLoading,
+                disabled: locked
+              }
+            )
+          }
+        ),
+        fieldIssues.task ? /* @__PURE__ */ jsx(
+          "p",
+          {
+            id: "entry-dialog-task-message",
+            className: "text-xs text-status-error-text",
+            role: "alert",
+            "data-testid": "entry-dialog-task-error",
+            children: fieldIssues.task
+          }
+        ) : /* @__PURE__ */ jsx("p", { className: "text-xs text-muted-foreground", children: t(
+          "staff.time_tracking.entryDialog.taskHint",
+          "The project and the customer follow from the task \u2014 you do not pick them separately."
+        ) })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1.5", children: [
+        /* @__PURE__ */ jsx(Label, { htmlFor: "entry-dialog-description", children: t("staff.time_tracking.entryDialog.description", "Description") }),
+        /* @__PURE__ */ jsx(
+          Input,
+          {
+            id: "entry-dialog-description",
+            value: description,
+            disabled: locked,
+            onChange: (event) => setDescription(event.target.value),
+            "data-testid": "entry-dialog-description"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-1 gap-4 sm:grid-cols-2", children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1.5", children: [
+          /* @__PURE__ */ jsx(Label, { htmlFor: "entry-dialog-date", children: t("staff.time_tracking.entryDialog.date", "Date") }),
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              id: "entry-dialog-date",
+              type: "date",
+              value: date,
+              disabled: locked,
+              onChange: (event) => setDate(event.target.value),
+              "data-testid": "entry-dialog-date"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1.5", children: [
+          /* @__PURE__ */ jsxs(Label, { htmlFor: "entry-dialog-duration", className: "flex items-center gap-2", children: [
+            t("staff.time_tracking.entryDialog.duration", "Duration"),
+            interval.computed === "duration" ? computedBadge("duration") : null
+          ] }),
+          /* @__PURE__ */ jsx(
+            DurationInput,
+            {
+              id: "entry-dialog-duration",
+              value: durationMinutes,
+              disabled: locked,
+              error: fieldIssues.duration ?? void 0,
+              ariaLabel: t("staff.time_tracking.entryDialog.duration", "Duration"),
+              onChange: (minutes, state) => setIntervalState(
+                (current) => reduceIntervalState(current, {
+                  field: "duration",
+                  minutes,
+                  invalid: state.status === "invalid"
+                })
+              )
+            },
+            `entry-dialog-duration-${interval.durationEpoch}`
+          )
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-1 gap-4 sm:grid-cols-2", children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1.5", children: [
+          /* @__PURE__ */ jsxs(Label, { htmlFor: "entry-dialog-start", className: "flex items-center gap-2", children: [
+            t("staff.time_tracking.entryDialog.start", "Start"),
+            interval.computed === "start" ? computedBadge("start") : null
+          ] }),
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              id: "entry-dialog-start",
+              value: startClock,
+              disabled: locked,
+              inputClassName: "font-mono tabular-nums",
+              placeholder: "15:10",
+              onChange: (event) => setIntervalState(
+                (current) => reduceIntervalState(current, { field: "start", value: event.target.value })
+              ),
+              "data-testid": "entry-dialog-start"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1.5", children: [
+          /* @__PURE__ */ jsxs(Label, { htmlFor: "entry-dialog-end", className: "flex items-center gap-2", children: [
+            t("staff.time_tracking.entryDialog.end", "End"),
+            interval.computed === "end" ? computedBadge("end") : null
+          ] }),
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              id: "entry-dialog-end",
+              value: endClock,
+              disabled: locked,
+              inputClassName: "font-mono tabular-nums",
+              placeholder: "16:25",
+              onChange: (event) => setIntervalState(
+                (current) => reduceIntervalState(current, { field: "end", value: event.target.value })
+              ),
+              "data-testid": "entry-dialog-end"
+            }
+          ),
+          /* @__PURE__ */ jsx("p", { className: "text-xs text-muted-foreground", children: t(
+            "staff.time_tracking.entryDialog.endHint",
+            "Change this field and the duration recalculates itself."
+          ) })
+        ] })
+      ] }),
+      midnightEndDate ? /* @__PURE__ */ jsx("p", { className: "text-xs text-muted-foreground", "data-testid": "entry-dialog-midnight", children: t("staff.time_tracking.entryDialog.midnight", "This entry ends the next day, {date}.", {
+        date: midnightEndDate
+      }) }) : null,
+      overlap ? /* @__PURE__ */ jsxs(Alert, { status: "warning", "data-testid": "entry-dialog-overlap", children: [
+        /* @__PURE__ */ jsx(AlertTitle, { children: t("staff.time_tracking.entryDialog.overlap.title", "This time overlaps another entry") }),
+        /* @__PURE__ */ jsx(AlertDescription, { children: t(
+          "staff.time_tracking.entryDialog.overlap.body",
+          "{start} \u2013 {end} \xB7 \u201E{task}\u201D \xB7 {project} ({duration}). Overlapping is allowed \u2014 if it is intentional, just save.",
+          {
+            start: overlap.startText,
+            end: overlap.endText,
+            task: overlap.taskTitle ?? overlap.description ?? t("staff.time_tracking.entryDialog.overlap.noTask", "no task"),
+            project: overlap.projectName ?? t("staff.time_tracking.entryDialog.overlap.noProject", "no project"),
+            duration: formatDuration(overlap.durationMinutes, "clock")
+          }
+        ) }),
+        /* @__PURE__ */ jsxs("div", { className: "mt-2 flex flex-wrap gap-2", children: [
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              type: "button",
+              variant: "outline",
+              size: "sm",
+              onClick: () => handleShowOverlap(overlap),
+              "data-testid": "entry-dialog-overlap-show",
+              children: t("staff.time_tracking.entryDialog.overlap.show", "Show that entry")
+            }
+          ),
+          overlap.endText ? /* @__PURE__ */ jsx(
+            Button,
+            {
+              type: "button",
+              variant: "outline",
+              size: "sm",
+              disabled: locked,
+              onClick: () => setIntervalState(
+                (current) => reduceIntervalState(current, { field: "snapStart", value: overlap.endText })
+              ),
+              "data-testid": "entry-dialog-overlap-snap",
+              children: t("staff.time_tracking.entryDialog.overlap.snap", "Snap start to {time}", {
+                time: overlap.endText
+              })
+            }
+          ) : null
+        ] })
+      ] }) : null,
+      /* @__PURE__ */ jsx(Separator, {}),
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3", children: [
+        /* @__PURE__ */ jsx(
+          Switch,
+          {
+            checked: isBillable,
+            disabled: locked,
+            onCheckedChange: (next) => setIsBillable(next),
+            "aria-label": t("staff.time_tracking.entryDialog.billable", "Billable"),
+            "data-testid": "entry-dialog-billable"
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 flex-1 flex-col", children: [
+          /* @__PURE__ */ jsx("span", { className: "text-sm font-medium text-foreground", children: t("staff.time_tracking.entryDialog.billable", "Billable") }),
+          /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: t("staff.time_tracking.entryDialog.billableHint", "On by default for this project.") })
+        ] }),
+        canSeeMoney && rateLabel ? /* @__PURE__ */ jsx(Badge, { variant: "success", "data-testid": "entry-dialog-rate-badge", children: t("staff.time_tracking.entryDialog.ratePerHour", "{amount}/h", { amount: rateLabel }) }) : null
+      ] }),
+      canSeeMoney ? /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3", children: [
+          /* @__PURE__ */ jsx(
+            Switch,
+            {
+              checked: rateOverrideEnabled,
+              disabled: locked,
+              onCheckedChange: (next) => setRateOverrideEnabled(next),
+              "aria-label": t("staff.time_tracking.entryDialog.rateOverride", "Custom rate for this entry"),
+              "data-testid": "entry-dialog-rate-override"
+            }
+          ),
+          /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 flex-1 flex-col", children: [
+            /* @__PURE__ */ jsx("span", { className: "text-sm font-medium text-foreground", children: t("staff.time_tracking.entryDialog.rateOverride", "Custom rate for this entry") }),
+            /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: t(
+              "staff.time_tracking.entryDialog.rateOverrideHint",
+              "Overrides the project rate here only."
+            ) })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-1 gap-4 sm:grid-cols-2", children: [
+          rateOverrideEnabled ? /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1.5", children: [
+            /* @__PURE__ */ jsx(Label, { htmlFor: "entry-dialog-rate", children: t("staff.time_tracking.entryDialog.rate", "Rate") }),
+            /* @__PURE__ */ jsx(
+              Input,
+              {
+                id: "entry-dialog-rate",
+                value: rateText,
+                disabled: locked,
+                inputMode: "decimal",
+                onChange: (event) => setRateText(event.target.value),
+                "data-testid": "entry-dialog-rate"
+              }
+            ),
+            projectRateLabel ? /* @__PURE__ */ jsx("p", { className: "text-xs text-muted-foreground", children: t(
+              "staff.time_tracking.entryDialog.rateHint",
+              "Defaults to {amount} (the project rate).",
+              { amount: projectRateLabel }
+            ) }) : null
+          ] }) : null,
+          /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1.5", children: [
+            /* @__PURE__ */ jsxs(Label, { htmlFor: "entry-dialog-cost", className: "flex items-center gap-2", children: [
+              t("staff.time_tracking.entryDialog.cost", "Cost"),
+              computedBadge("cost")
+            ] }),
+            /* @__PURE__ */ jsx(
+              Input,
+              {
+                id: "entry-dialog-cost",
+                readOnly: true,
+                disabled: true,
+                value: cost === null ? "" : formatCurrency(cost, currencyCode) ?? String(cost),
+                inputClassName: "font-mono tabular-nums",
+                "data-testid": "entry-dialog-cost"
+              }
+            ),
+            rateLabel && durationMinutes ? /* @__PURE__ */ jsx("p", { className: "text-xs text-muted-foreground", "data-testid": "entry-dialog-cost-hint", children: t(
+              "staff.time_tracking.entryDialog.costHint",
+              "{raw} rounded to {rounded} \xD7 {rate}",
+              {
+                raw: formatDuration(durationMinutes, "clock"),
+                rounded: formatDuration(roundedMinutes, "clock"),
+                rate: rateLabel
+              }
+            ) }) : null
+          ] })
+        ] })
+      ] }) : /* @__PURE__ */ jsx("p", { className: "text-xs text-muted-foreground", "data-testid": "entry-dialog-money-hidden", children: t(
+        "staff.time_tracking.entryDialog.moneyHidden",
+        "Rates and cost are hidden \u2014 your permissions do not cover money on time entries."
+      ) }),
+      /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1.5", children: [
+        /* @__PURE__ */ jsx("span", { className: "text-xs font-medium text-muted-foreground", children: t("staff.time_tracking.entryDialog.tags", "Tags") }),
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [
+          assignedTags.map((tag) => /* @__PURE__ */ jsxs(
+            Badge,
+            {
+              variant: "neutral",
+              className: "gap-1",
+              style: tagChipStyle(tag),
+              children: [
+                tag.label,
+                locked ? null : /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    type: "button",
+                    "aria-label": t("staff.time_tracking.entryDialog.removeTag", "Remove tag {label}", {
+                      label: tag.label
+                    }),
+                    onClick: () => setTagIds((current) => current.filter((id) => id !== tag.id)),
+                    children: /* @__PURE__ */ jsx(X, { className: "size-3", "aria-hidden": "true" })
+                  }
+                )
+              ]
+            },
+            tag.id
+          )),
+          !locked ? /* @__PURE__ */ jsx(
+            TagPicker,
+            {
+              available: availableTags,
+              onAssign: (id) => setTagIds((current) => current.includes(id) ? current : [...current, id]),
+              onCreate: createTag,
+              labels: {
+                add: t("staff.time_tracking.entryDialog.addTag", "Add tag"),
+                create: (name) => t("staff.time_tracking.entryDialog.createTag", 'Create "{name}"', { name }),
+                empty: t("staff.time_tracking.entryDialog.noTags", "No matching tag")
+              }
+            }
+          ) : null
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx(
+        InjectionSpot,
+        {
+          spotId: extensionSpotChildId(extensionPoints.hosts.timeEntryForm.spotId, "fields"),
+          context: entryInjectionContext,
+          data: entryFormValues
+        }
+      ),
+      /* @__PURE__ */ jsx(Alert, { status: "information", "data-testid": "entry-dialog-creator", children: /* @__PURE__ */ jsx(AlertDescription, { children: selfQuery.data?.displayName ? t(
+        "staff.time_tracking.entryDialog.creator",
+        "Entry author: {name} \u2014 assigned automatically and not editable.",
+        { name: selfQuery.data.displayName }
+      ) : t(
+        "staff.time_tracking.entryDialog.creatorUnknown",
+        "The entry author is assigned automatically and is not editable."
+      ) }) }),
+      /* @__PURE__ */ jsx(
+        InjectionSpot,
+        {
+          spotId: extensionSpotChildId(extensionPoints.hosts.timeEntryForm.spotId, "after-fields"),
+          context: entryInjectionContext,
+          data: entryFormValues
+        }
+      )
+    ] });
+  })();
+  return /* @__PURE__ */ jsx(
+    Dialog,
+    {
+      open,
+      onOpenChange: (next) => {
+        if (next) {
+          onOpenChange(true);
+          return;
+        }
+        void requestClose();
+      },
+      children: /* @__PURE__ */ jsxs(
+        DialogContent,
+        {
+          size: "lg",
+          "data-testid": "entry-dialog",
+          onOpenAutoFocus: (event) => {
+            if (locked || !taskTriggerRef.current) return;
+            event.preventDefault();
+            focusTaskPicker();
+          },
+          onKeyDown: (event) => {
+            if ((event.metaKey || event.ctrlKey) && event.key === "Enter") {
+              event.preventDefault();
+              void submit(event.shiftKey ? "again" : "close");
+            }
+          },
+          children: [
+            /* @__PURE__ */ jsxs(DialogHeader, { children: [
+              /* @__PURE__ */ jsx(DialogTitle, { children: isEdit ? t("staff.time_tracking.entryDialog.titleEdit", "Time entry") : t("staff.time_tracking.entryDialog.titleCreate", "New time entry") }),
+              headerHint ? /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: headerHint }) : null
+            ] }),
+            body,
+            /* @__PURE__ */ jsxs(DialogFooter, { children: [
+              /* @__PURE__ */ jsxs("span", { className: "mr-auto hidden items-center gap-1 whitespace-nowrap text-xs text-muted-foreground sm:flex", children: [
+                /* @__PURE__ */ jsx(Kbd, { children: "\u2318" }),
+                /* @__PURE__ */ jsx(Kbd, { children: "\u21B5" }),
+                t("staff.time_tracking.entryDialog.shortcutSave", "save"),
+                locked ? null : /* @__PURE__ */ jsxs(Fragment, { children: [
+                  /* @__PURE__ */ jsx("span", { "aria-hidden": "true", children: "\xB7" }),
+                  /* @__PURE__ */ jsx(Kbd, { children: "\u2318" }),
+                  /* @__PURE__ */ jsx(Kbd, { children: "\u21E7" }),
+                  /* @__PURE__ */ jsx(Kbd, { children: "\u21B5" }),
+                  t("staff.time_tracking.entryDialog.shortcutSaveAgain", "save and add another")
+                ] }),
+                /* @__PURE__ */ jsx("span", { "aria-hidden": "true", children: "\xB7" }),
+                /* @__PURE__ */ jsx(Kbd, { children: "esc" }),
+                t("staff.time_tracking.entryDialog.shortcutCancel", "cancel")
+              ] }),
+              /* @__PURE__ */ jsx(
+                InjectionSpot,
+                {
+                  spotId: extensionSpotChildId(extensionPoints.hosts.timeEntryForm.spotId, "footer"),
+                  context: entryInjectionContext,
+                  data: entryFormValues
+                }
+              ),
+              /* @__PURE__ */ jsx(Button, { type: "button", variant: "ghost", onClick: () => {
+                void requestClose();
+              }, children: locked ? t("staff.time_tracking.entryDialog.close", "Close") : t("staff.time_tracking.entryDialog.cancel", "Cancel") }),
+              locked ? null : /* @__PURE__ */ jsxs(Fragment, { children: [
+                /* @__PURE__ */ jsxs(
+                  Button,
+                  {
+                    type: "button",
+                    variant: "outline",
+                    disabled: !canSubmit,
+                    onClick: () => void submit("again"),
+                    "data-testid": "entry-dialog-save-again",
+                    children: [
+                      savingMode === "again" ? /* @__PURE__ */ jsx(Spinner, { className: "size-4" }) : null,
+                      t("staff.time_tracking.entryDialog.saveAndNew", "Save and add another")
+                    ]
+                  }
+                ),
+                /* @__PURE__ */ jsxs(
+                  Button,
+                  {
+                    type: "button",
+                    disabled: !canSubmit,
+                    onClick: () => void submit("close"),
+                    "data-testid": "entry-dialog-save",
+                    children: [
+                      savingMode === "close" ? /* @__PURE__ */ jsx(Spinner, { className: "size-4" }) : null,
+                      t("staff.time_tracking.entryDialog.save", "Save")
+                    ]
+                  }
+                )
+              ] })
+            ] }),
+            ConfirmDialogElement
+          ]
+        }
+      )
+    }
+  );
+}
+const timeEntryDialogPropsSchema = z.object({
+  open: z.boolean(),
+  onOpenChange: callbackProp(),
+  entryId: z.string().nullable().optional(),
+  defaults: opaqueProp().optional(),
+  headerHint: z.string().nullable().optional(),
+  onSaved: optionalCallbackProp(),
+  onShowEntry: optionalCallbackProp()
+});
+registerComponent({
+  id: extensionPoints.hosts.timeEntryDialogComponent.componentId,
+  component: DefaultTimeEntryDialog,
+  metadata: {
+    module: "staff",
+    description: "Create/edit dialog for a single time entry.",
+    propsSchema: timeEntryDialogPropsSchema
+  }
+});
+function TimeEntryDialog(props) {
+  const Resolved = useRegisteredComponent(
+    extensionPoints.hosts.timeEntryDialogComponent.componentId,
+    DefaultTimeEntryDialog
+  );
+  return /* @__PURE__ */ jsx(Resolved, { ...props });
+}
+var TimeEntryDialog_default = TimeEntryDialog;
+export {
+  ENTRIES_LIST_PATH,
+  RATES_FEATURE,
+  REPORTS_PATH,
+  TIME_ENTRY_DIALOG_MUTATION_CONTEXT_ID,
+  TimeEntryDialog,
+  TimeEntryDialog_default as default
+};
+//# sourceMappingURL=TimeEntryDialog.js.map