@open-mercato/core 0.6.4-develop.4371.1.8f3030407e → 0.6.4

package/src/modules/dictionaries/api/[dictionaryId]/route.ts

@@ -3,7 +3,11 @@ import { z } from 'zod'
 import { Dictionary } from '@open-mercato/core/modules/dictionaries/data/entities'
 import { resolveDictionariesRouteContext } from '@open-mercato/core/modules/dictionaries/api/context'
 import { CrudHttpError, isCrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { enforceCommandOptimisticLock } from '@open-mercato/shared/lib/crud/optimistic-lock-command'
 import type { OpenApiMethodDoc, OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import {
+  resolveDictionaryEntrySortMode,
+} from '@open-mercato/core/modules/dictionaries/lib/entrySort'
 import {
   dictionariesErrorSchema,
   dictionariesOkSchema,
@@ -13,10 +17,18 @@ import {
   dictionaryUpdateSchema,
   upsertDictionarySchema,
 } from '../openapi'
+import { dictionaryKeySchema } from '@open-mercato/core/modules/dictionaries/data/validators'
 
 const paramsSchema = z.object({ dictionaryId: z.string().uuid() })
+// System dictionaries use namespaced keys (e.g. `sales.deal_loss_reason`,
+// `resources.activity-types`) that the strict create-key regex rejects. The
+// manager edit dialog disables the key field but still resubmits the existing
+// key, so the update parse must accept any stored key verbatim. The strict
+// user-key regex is only enforced below when the key actually changes.
+const updateKeySchema = z.string().trim().min(1).max(100)
 const updateSchema = upsertDictionarySchema
   .partial()
+  .extend({ key: updateKeySchema.optional() })
   .refine((data) => Object.keys(data).length > 0, {
     message: 'Provide at least one field to update.',
   })
@@ -77,6 +89,7 @@ export async function GET(req: Request, ctx: { params?: { dictionaryId?: string
       isSystem: dictionary.isSystem,
       isActive: dictionary.isActive,
       managerVisibility: dictionary.managerVisibility,
+      entrySortMode: resolveDictionaryEntrySortMode(dictionary.entrySortMode),
       organizationId: dictionary.organizationId,
       isInherited: context.organizationId ? dictionary.organizationId !== context.organizationId : false,
       createdAt: dictionary.createdAt,
@@ -98,6 +111,13 @@ export async function PATCH(req: Request, ctx: { params?: { dictionaryId?: strin
     const payload = updateSchema.parse(await req.json().catch(() => ({})))
     const dictionary = await loadDictionary(context, dictionaryId)
 
+    enforceCommandOptimisticLock({
+      resourceKind: 'dictionaries.dictionary',
+      resourceId: dictionary.id,
+      current: dictionary.updatedAt ?? null,
+      request: req,
+    })
+
     if (isProtectedCurrencyDictionary(dictionary)) {
       if (payload.key && payload.key.trim().toLowerCase() !== dictionary.key) {
         throw new CrudHttpError(400, { error: context.translate('dictionaries.errors.currency_protected', 'The currency dictionary cannot be modified or deleted.') })
@@ -110,6 +130,10 @@ export async function PATCH(req: Request, ctx: { params?: { dictionaryId?: strin
     if (payload.key) {
       const key = payload.key.trim().toLowerCase()
       if (key !== dictionary.key) {
+        const strictKey = dictionaryKeySchema.safeParse(key)
+        if (!strictKey.success) {
+          throw new CrudHttpError(400, { error: context.translate('dictionaries.errors.invalid_key', 'Use lowercase letters, numbers, hyphen, or underscore.') })
+        }
         const organizationId = context.organizationId
         if (!organizationId) {
           throw new CrudHttpError(400, { error: context.translate('dictionaries.errors.organization_required', 'Organization context is required') })
@@ -141,6 +165,9 @@ export async function PATCH(req: Request, ctx: { params?: { dictionaryId?: strin
         dictionary.deletedAt = null
       }
     }
+    if (payload.entrySortMode !== undefined) {
+      dictionary.entrySortMode = payload.entrySortMode
+    }
 
     dictionary.updatedAt = new Date()
     await context.em.flush()
@@ -153,6 +180,7 @@ export async function PATCH(req: Request, ctx: { params?: { dictionaryId?: strin
       isSystem: dictionary.isSystem,
       isActive: dictionary.isActive,
       managerVisibility: dictionary.managerVisibility,
+      entrySortMode: resolveDictionaryEntrySortMode(dictionary.entrySortMode),
       createdAt: dictionary.createdAt,
       updatedAt: dictionary.updatedAt,
     })
@@ -160,6 +188,9 @@ export async function PATCH(req: Request, ctx: { params?: { dictionaryId?: strin
     if (isCrudHttpError(err)) {
       return NextResponse.json(err.body, { status: err.status })
     }
+    if (err instanceof z.ZodError) {
+      return NextResponse.json({ error: err.issues[0]?.message ?? 'Validation failed' }, { status: 400 })
+    }
     console.error('[dictionaries/:id.PATCH] Unexpected error', err)
     return NextResponse.json({ error: 'Failed to update dictionary' }, { status: 500 })
   }

package/src/modules/dictionaries/api/openapi.ts

@@ -6,6 +6,7 @@ import {
   reorderDictionaryEntriesSchema,
   setDefaultDictionaryEntrySchema,
 } from '@open-mercato/core/modules/dictionaries/data/validators'
+import { dictionaryEntrySortModeSchema } from '@open-mercato/core/modules/dictionaries/lib/entrySort'
 
 export const dictionariesTag = 'Dictionaries'
 
@@ -29,6 +30,7 @@ export const dictionarySchema = z.object({
   isSystem: z.boolean(),
   isActive: z.boolean(),
   managerVisibility: z.string().nullable().optional(),
+  entrySortMode: dictionaryEntrySortModeSchema.optional(),
   organizationId: z.string().uuid().nullable(),
   isInherited: z.boolean().optional(),
   createdAt: z.string(),
@@ -88,4 +90,3 @@ export {
   reorderDictionaryEntriesSchema,
   setDefaultDictionaryEntrySchema,
 }
-

package/src/modules/dictionaries/api/route.ts

@@ -3,6 +3,10 @@ import { Dictionary } from '@open-mercato/core/modules/dictionaries/data/entitie
 import { resolveDictionariesRouteContext } from '@open-mercato/core/modules/dictionaries/api/context'
 import { CrudHttpError, isCrudHttpError } from '@open-mercato/shared/lib/crud/errors'
 import type { OpenApiMethodDoc, OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import {
+  DEFAULT_DICTIONARY_ENTRY_SORT_MODE,
+  resolveDictionaryEntrySortMode,
+} from '@open-mercato/core/modules/dictionaries/lib/entrySort'
 import {
   dictionariesErrorSchema,
   dictionariesTag,
@@ -48,6 +52,7 @@ export async function GET(req: Request) {
         isSystem: dictionary.isSystem,
         isActive: dictionary.isActive,
         managerVisibility: dictionary.managerVisibility,
+        entrySortMode: resolveDictionaryEntrySortMode(dictionary.entrySortMode),
         organizationId: dictionary.organizationId,
         isInherited: context.organizationId ? dictionary.organizationId !== context.organizationId : false,
         createdAt: dictionary.createdAt,
@@ -91,6 +96,7 @@ export async function POST(req: Request) {
       isSystem: payload.isSystem ?? false,
       isActive: payload.isActive ?? true,
       managerVisibility: 'default',
+      entrySortMode: payload.entrySortMode ?? DEFAULT_DICTIONARY_ENTRY_SORT_MODE,
       createdAt: new Date(),
       updatedAt: new Date(),
     })
@@ -104,6 +110,7 @@ export async function POST(req: Request) {
       description: dictionary.description,
       isSystem: dictionary.isSystem,
       isActive: dictionary.isActive,
+      entrySortMode: resolveDictionaryEntrySortMode(dictionary.entrySortMode),
       createdAt: dictionary.createdAt,
       updatedAt: dictionary.updatedAt,
     }, { status: 201 })

package/src/modules/dictionaries/commands/entry-operations.ts

@@ -325,6 +325,14 @@ const setDefaultDictionaryEntryCommand: CommandHandler<
     )
     const clearedIds: string[] = []
 
+    // The partial unique index `dictionary_entries_one_default_per_dict`
+    // (dictionary_id, organization_id, tenant_id) WHERE is_default = true forbids
+    // two default entries in the same dictionary. PostgreSQL checks partial unique
+    // indexes per-statement (no deferral) and MikroORM does not guarantee that the
+    // is_default=false UPDATEs run before the is_default=true UPDATE within a single
+    // flush, so clearing and setting in one flush races to a 23505. Clear the prior
+    // default(s) in their own flush first, then set the new default in a second
+    // flush, so Postgres never observes two default rows at once.
     await withAtomicFlush(em, [
       () => {
         for (const entry of existingDefaults) {
@@ -333,6 +341,10 @@ const setDefaultDictionaryEntryCommand: CommandHandler<
           entry.updatedAt = new Date()
           clearedIds.push(entry.id)
         }
+      },
+    ], { transaction: true })
+    await withAtomicFlush(em, [
+      () => {
         targetEntry.isDefault = true
         targetEntry.updatedAt = new Date()
       },
@@ -421,12 +433,19 @@ const setDefaultDictionaryEntryCommand: CommandHandler<
         )
       : []
 
+    // Same partial-unique-index ordering constraint as `execute`: clear the
+    // current default in its own flush before restoring the previous default(s),
+    // so Postgres never sees two is_default=true rows in the dictionary at once.
     await withAtomicFlush(em, [
       () => {
         if (newDefault) {
           newDefault.isDefault = false
           newDefault.updatedAt = new Date()
         }
+      },
+    ], { transaction: true })
+    await withAtomicFlush(em, [
+      () => {
         for (const entry of previousDefaults) {
           entry.isDefault = true
           entry.updatedAt = new Date()

package/src/modules/dictionaries/components/DictionariesManager.tsx

@@ -6,12 +6,26 @@ import { Book, Plus, Pencil, Trash2 } from 'lucide-react'
 import { EmptyState } from '@open-mercato/ui/primitives/empty-state'
 import { Button } from '@open-mercato/ui/primitives/button'
 import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from '@open-mercato/ui/primitives/dialog'
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@open-mercato/ui/primitives/select'
 import { Spinner } from '@open-mercato/ui/primitives/spinner'
 import { flash } from '@open-mercato/ui/backend/FlashMessages'
-import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+import { apiCall, withScopedApiRequestHeaders } from '@open-mercato/ui/backend/utils/apiCall'
+import { buildOptimisticLockHeader } from '@open-mercato/ui/backend/utils/optimisticLock'
+import { surfaceRecordConflict } from '@open-mercato/ui/backend/conflicts'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import { useConfirmDialog } from '@open-mercato/ui/backend/confirm-dialog'
 import { DictionaryEntriesEditor } from './DictionaryEntriesEditor'
+import {
+  DEFAULT_DICTIONARY_ENTRY_SORT_MODE,
+  dictionaryEntrySortModes,
+  type DictionaryEntrySortMode,
+} from '../lib/entrySort'
 
 export type DictionarySummary = {
   id: string
@@ -20,9 +34,11 @@ export type DictionarySummary = {
   description?: string | null
   isSystem?: boolean
   isActive?: boolean
+  entrySortMode: DictionaryEntrySortMode
   organizationId: string
   isInherited: boolean
   managerVisibility: 'default' | 'hidden'
+  updatedAt?: string | null
 }
 
 type DialogState = {
@@ -30,6 +46,13 @@ type DialogState = {
   dictionary?: DictionarySummary
 }
 
+type DictionaryFormState = {
+  key: string
+  name: string
+  description: string
+  entrySortMode: DictionaryEntrySortMode
+}
+
 export function DictionariesManager() {
   const t = useT()
   const { confirm, ConfirmDialogElement } = useConfirmDialog()
@@ -38,7 +61,12 @@ export function DictionariesManager() {
   const [selectedId, setSelectedId] = React.useState<string | null>(null)
   const [loading, setLoading] = React.useState(true)
   const [dialog, setDialog] = React.useState<DialogState | null>(null)
-  const [form, setForm] = React.useState({ key: '', name: '', description: '' })
+  const [form, setForm] = React.useState<DictionaryFormState>({
+    key: '',
+    name: '',
+    description: '',
+    entrySortMode: DEFAULT_DICTIONARY_ENTRY_SORT_MODE,
+  })
   const [errors, setErrors] = React.useState<{ key?: string; name?: string }>({})
   const [submitting, setSubmitting] = React.useState(false)
   const [deleting, setDeleting] = React.useState<string | null>(null)
@@ -46,6 +74,24 @@ export function DictionariesManager() {
   const inheritedManageMessage = t('dictionaries.config.error.inheritedManage', 'Inherited dictionaries must be managed at the parent organization.')
   const requestedDictionaryId = searchParams?.get('dictionaryId') ?? null
   const requestedDictionaryKey = searchParams?.get('key')?.trim().toLowerCase() ?? null
+  const entrySortOptions = React.useMemo(
+    () => dictionaryEntrySortModes.map((mode) => ({
+      value: mode,
+      label:
+        mode === 'label_asc'
+          ? t('dictionaries.config.sortModes.labelAsc', 'A to Z')
+          : mode === 'label_desc'
+            ? t('dictionaries.config.sortModes.labelDesc', 'Z to A')
+            : mode === 'value_asc'
+              ? t('dictionaries.config.sortModes.valueAsc', 'Value A to Z')
+              : mode === 'value_desc'
+                ? t('dictionaries.config.sortModes.valueDesc', 'Value Z to A')
+                : mode === 'created_at_asc'
+                  ? t('dictionaries.config.sortModes.createdAtAsc', 'Oldest first')
+                  : t('dictionaries.config.sortModes.createdAtDesc', 'Newest first'),
+    })),
+    [t],
+  )
 
   const loadDictionaries = React.useCallback(async () => {
     setLoading(true)
@@ -63,10 +109,14 @@ export function DictionariesManager() {
             description: typeof item.description === 'string' ? item.description : null,
             isSystem: Boolean(item.isSystem),
             isActive: item.isActive !== false,
+            entrySortMode: dictionaryEntrySortModes.includes(item.entrySortMode as DictionaryEntrySortMode)
+              ? (item.entrySortMode as DictionaryEntrySortMode)
+              : DEFAULT_DICTIONARY_ENTRY_SORT_MODE,
             organizationId: typeof item.organizationId === 'string' ? item.organizationId : '',
             isInherited: item.isInherited === true,
             managerVisibility:
               item.managerVisibility === 'hidden' ? 'hidden' : 'default',
+            updatedAt: typeof item.updatedAt === 'string' ? item.updatedAt : null,
           }))
         : []
       const filtered = list.filter((dictionary: DictionarySummary) => dictionary.managerVisibility !== 'hidden')
@@ -108,7 +158,12 @@ export function DictionariesManager() {
   }, [items, requestedDictionaryId, requestedDictionaryKey, selectedId])
 
   const openCreateDialog = React.useCallback(() => {
-    setForm({ key: '', name: '', description: '' })
+    setForm({
+      key: '',
+      name: '',
+      description: '',
+      entrySortMode: DEFAULT_DICTIONARY_ENTRY_SORT_MODE,
+    })
     setDialog({ mode: 'create' })
     setErrors({})
   }, [])
@@ -118,14 +173,24 @@ export function DictionariesManager() {
       flash(inheritedManageMessage, 'info')
       return
     }
-    setForm({ key: dictionary.key, name: dictionary.name, description: dictionary.description ?? '' })
+    setForm({
+      key: dictionary.key,
+      name: dictionary.name,
+      description: dictionary.description ?? '',
+      entrySortMode: dictionary.entrySortMode,
+    })
     setDialog({ mode: 'edit', dictionary })
     setErrors({})
   }, [inheritedManageMessage])
 
   const closeDialog = React.useCallback(() => {
     setDialog(null)
-    setForm({ key: '', name: '', description: '' })
+    setForm({
+      key: '',
+      name: '',
+      description: '',
+      entrySortMode: DEFAULT_DICTIONARY_ENTRY_SORT_MODE,
+    })
     setErrors({})
   }, [])
 
@@ -158,6 +223,7 @@ export function DictionariesManager() {
         key: trimmedKey,
         name: trimmedName,
         description: form.description.trim() || undefined,
+        entrySortMode: form.entrySortMode,
       }
       if (dialog.mode === 'create') {
         const call = await apiCall<Record<string, unknown>>('/api/dictionaries', {
@@ -170,13 +236,20 @@ export function DictionariesManager() {
         }
         flash(t('dictionaries.config.success.create', 'Dictionary created.'), 'success')
       } else if (dialog.dictionary) {
-        const call = await apiCall<Record<string, unknown>>(`/api/dictionaries/${dialog.dictionary.id}`, {
-          method: 'PATCH',
-          headers: { 'content-type': 'application/json' },
-          body: JSON.stringify(payload),
-        })
+        const call = await withScopedApiRequestHeaders(
+          buildOptimisticLockHeader(dialog.dictionary.updatedAt),
+          () =>
+            apiCall<Record<string, unknown>>(`/api/dictionaries/${dialog.dictionary!.id}`, {
+              method: 'PATCH',
+              headers: { 'content-type': 'application/json' },
+              body: JSON.stringify(payload),
+            }),
+        )
         if (!call.ok) {
-          throw new Error(typeof call.result?.error === 'string' ? call.result.error : 'Failed to update dictionary')
+          throw Object.assign(
+            new Error(typeof call.result?.error === 'string' ? call.result.error : 'Failed to update dictionary'),
+            { status: call.status, ...(call.result && typeof call.result === 'object' ? call.result : {}) },
+          )
         }
         flash(t('dictionaries.config.success.update', 'Dictionary updated.'), 'success')
       }
@@ -184,12 +257,15 @@ export function DictionariesManager() {
       await loadDictionaries()
       setErrors({})
     } catch (err) {
+      if (surfaceRecordConflict(err, t)) {
+        return
+      }
       console.error('Failed to save dictionary', err)
       flash(t('dictionaries.config.error.save', 'Failed to save dictionary.'), 'error')
     } finally {
       setSubmitting(false)
     }
-  }, [closeDialog, dialog, form.description, form.key, form.name, inheritedManageMessage, loadDictionaries, t])
+  }, [closeDialog, dialog, form.description, form.entrySortMode, form.key, form.name, inheritedManageMessage, loadDictionaries, t])
 
   const handleDelete = React.useCallback(
     async (dictionary: DictionarySummary) => {
@@ -212,13 +288,22 @@ export function DictionariesManager() {
       if (!confirmed) return
       setDeleting(dictionary.id)
       try {
-        const call = await apiCall<Record<string, unknown>>(`/api/dictionaries/${dictionary.id}`, { method: 'DELETE' })
+        const call = await withScopedApiRequestHeaders(
+          buildOptimisticLockHeader(dictionary.updatedAt),
+          () => apiCall<Record<string, unknown>>(`/api/dictionaries/${dictionary.id}`, { method: 'DELETE' }),
+        )
         if (!call.ok) {
-          throw new Error(typeof call.result?.error === 'string' ? call.result.error : 'Failed to delete dictionary')
+          throw Object.assign(
+            new Error(typeof call.result?.error === 'string' ? call.result.error : 'Failed to delete dictionary'),
+            { status: call.status, ...(call.result && typeof call.result === 'object' ? call.result : {}) },
+          )
         }
         flash(t('dictionaries.config.success.delete', 'Dictionary deleted.'), 'success')
         await loadDictionaries()
       } catch (err) {
+        if (surfaceRecordConflict(err, t)) {
+          return
+        }
         console.error('Failed to delete dictionary', err)
         flash(t('dictionaries.config.error.delete', 'Failed to delete dictionary.'), 'error')
       } finally {
@@ -391,6 +476,32 @@ export function DictionariesManager() {
                 placeholder={t('dictionaries.config.dialog.descriptionPlaceholder', 'Explain how this dictionary is used (optional).')}
               />
             </div>
+            <div className="space-y-2">
+              <label className="text-sm font-medium">{t('dictionaries.config.dialog.entrySortModeLabel', 'Entry sort order')}</label>
+              <Select
+                value={form.entrySortMode}
+                onValueChange={(next) => setForm((prev) => ({
+                  ...prev,
+                  entrySortMode: dictionaryEntrySortModes.includes(next as DictionaryEntrySortMode)
+                    ? (next as DictionaryEntrySortMode)
+                    : DEFAULT_DICTIONARY_ENTRY_SORT_MODE,
+                }))}
+              >
+                <SelectTrigger>
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  {entrySortOptions.map((option) => (
+                    <SelectItem key={option.value} value={option.value}>
+                      {option.label}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+              <p className="text-xs text-muted-foreground">
+                {t('dictionaries.config.dialog.entrySortModeHelp', 'Controls the order returned by dictionary entry APIs and dropdowns.')}
+              </p>
+            </div>
           </div>
           <DialogFooter>
             <Button type="button" variant="ghost" onClick={closeDialog} disabled={submitting}>

package/src/modules/dictionaries/components/DictionaryEntriesEditor.tsx

@@ -14,7 +14,9 @@ import {
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@open-mercato/ui/primitives/table'
 import { Spinner } from '@open-mercato/ui/primitives/spinner'
 import { flash } from '@open-mercato/ui/backend/FlashMessages'
-import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+import { apiCall, withScopedApiRequestHeaders } from '@open-mercato/ui/backend/utils/apiCall'
+import { buildOptimisticLockHeader } from '@open-mercato/ui/backend/utils/optimisticLock'
+import { surfaceRecordConflict } from '@open-mercato/ui/backend/conflicts'
 import { useQueryClient } from '@tanstack/react-query'
 import { useOrganizationScopeVersion } from '@open-mercato/shared/lib/frontend/useOrganizationScope'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
@@ -45,6 +47,7 @@ type FormState = {
   label: string
   color: string | null
   icon: string | null
+  updatedAt?: string | null
 }
 
 export function DictionaryEntriesEditor({ dictionaryId, dictionaryName, readOnly = false }: DictionaryEntriesEditorProps) {
@@ -93,6 +96,7 @@ export function DictionaryEntriesEditor({ dictionaryId, dictionaryName, readOnly
           label: entry.label,
           color: entry.color ?? null,
           icon: entry.icon ?? null,
+          updatedAt: entry.updatedAt ?? null,
         })
         appearance.setColor(entry.color ?? null)
         appearance.setIcon(entry.icon ?? null)
@@ -136,17 +140,22 @@ export function DictionaryEntriesEditor({ dictionaryId, dictionaryName, readOnly
         icon: appearance.icon,
       }
       if (formState.id) {
-        const call = await apiCall<Record<string, unknown>>(
-          `/api/dictionaries/${dictionaryId}/entries/${formState.id}`,
-          {
-            method: 'PATCH',
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify(payload),
-          },
+        const call = await withScopedApiRequestHeaders(
+          buildOptimisticLockHeader(formState.updatedAt),
+          () =>
+            apiCall<Record<string, unknown>>(
+              `/api/dictionaries/${dictionaryId}/entries/${formState.id}`,
+              {
+                method: 'PATCH',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify(payload),
+              },
+            ),
         )
         if (!call.ok) {
-          throw new Error(
-            typeof call.result?.error === 'string' ? call.result.error : 'Failed to save dictionary entry',
+          throw Object.assign(
+            new Error(typeof call.result?.error === 'string' ? call.result.error : 'Failed to save dictionary entry'),
+            { status: call.status, ...(call.result && typeof call.result === 'object' ? call.result : {}) },
           )
         }
         flash(t('dictionaries.config.entries.success.update', 'Dictionary entry updated.'), 'success')
@@ -173,12 +182,15 @@ export function DictionaryEntriesEditor({ dictionaryId, dictionaryName, readOnly
       appearance.setIcon(null)
       setErrors({})
     } catch (err) {
+      if (surfaceRecordConflict(err, t)) {
+        return
+      }
       console.error('Failed to save dictionary entry', err)
       flash(t('dictionaries.config.entries.error.save', 'Failed to save dictionary entry.'), 'error')
     } finally {
       setIsSaving(false)
     }
-  }, [appearance, dictionaryId, formState.id, formState.label, formState.value, queryClient, readOnly, readOnlyMessage, t])
+  }, [appearance, dictionaryId, formState.id, formState.label, formState.updatedAt, formState.value, queryClient, readOnly, readOnlyMessage, t])
 
   const handleDelete = React.useCallback(
     async (entry: Entry) => {
@@ -194,9 +206,13 @@ export function DictionaryEntriesEditor({ dictionaryId, dictionaryName, readOnly
       if (!confirmDelete) return
       setIsDeleting(true)
       try {
-        const call = await apiCall<Record<string, unknown>>(
-          `/api/dictionaries/${dictionaryId}/entries/${entry.id}`,
-          { method: 'DELETE' },
+        const call = await withScopedApiRequestHeaders(
+          buildOptimisticLockHeader(entry.updatedAt),
+          () =>
+            apiCall<Record<string, unknown>>(
+              `/api/dictionaries/${dictionaryId}/entries/${entry.id}`,
+              { method: 'DELETE' },
+            ),
         )
         if (!call.ok) {
           throw new Error(
@@ -244,10 +260,7 @@ export function DictionaryEntriesEditor({ dictionaryId, dictionaryName, readOnly
         </TableRow>
       )
     }
-    return entries
-      .slice()
-      .sort((a, b) => a.label.localeCompare(b.label, undefined, { sensitivity: 'base' }))
-      .map((entry) => (
+    return entries.map((entry) => (
         <TableRow key={entry.id}>
           <TableCell className="font-medium">{entry.value}</TableCell>
           <TableCell>{entry.label}</TableCell>