@kernhq/module-inventory 0.3.0 → 0.4.0

package/src/client/errors.ts

@@ -25,8 +25,14 @@
  *
  * Pure and string-free: this file decides *which* key, `i18n.ts` holds the words, and a `.svelte`
  * file cannot be unit-tested. `errorMessage()` at the bottom is the one function the screens call.
+ *
+ * The one import is a number from the contract — the same file the server reads it from — because a
+ * limit a sentence refuses to name is a limit nobody can plan around. It brings no runtime with it;
+ * what this file still must never reach for is `i18n.ts`, which drags a Svelte compiler in behind it.
  */
 
+import { MAX_LIVE_CATEGORIES } from '../contract/models.js'
+
 /** What oRPC hands a screen. `code` is the contract's `ErrorCode`; `data` is what the server put in it. */
 export interface ServerError {
   code?: unknown
@@ -121,10 +127,24 @@ const REASON_KEYS: Record<string, string> = {
   'inventory.repair.already_complete': 'error_repair_already_complete',
   'inventory.repair.returned_before_sent': 'error_repair_returned_before_sent',
   'inventory.category.name_taken': 'error_category_name_taken',
+  'inventory.category.order_stale': 'error_category_order_stale',
+  'inventory.category.limit_reached': 'error_category_limit_reached',
 }
 
 export const reasonKeys = (): readonly string[] => Object.keys(REASON_KEYS)
 
+/**
+ * The one refusal whose sentence has a number in it, and where that number comes from.
+ *
+ * A limit stated as "quite a lot" is not stated. `KernError.conflict` carries a reason and no data,
+ * so the server cannot hand the figure over — and it does not need to: it is a constant in the
+ * contract, which is the same file both halves read. Passed through `t`, it goes through
+ * `Intl.NumberFormat`, so a Persian reader is shown ۵۰۰ rather than 500.
+ */
+const REASON_VALUES: Record<string, Record<string, string | number>> = {
+  'inventory.category.limit_reached': { max: MAX_LIVE_CATEGORIES },
+}
+
 /**
  * The sentence a whole class of failure earns, when no reason narrows it further.
  *
@@ -162,12 +182,17 @@ export interface ErrorLine {
   key: string
   /** The server's own sentence, for a failure nothing here recognised. Null otherwise. */
   detail: string | null
+  /** What the sentence's placeholders need. Absent for every key that has none. */
+  values?: Record<string, string | number>
 }
 
 export function errorLine(err: unknown): ErrorLine {
   const reason = reasonOf(err)
   const byReason = reason ? REASON_KEYS[reason] : undefined
-  if (byReason) return { key: byReason, detail: null }
+  if (byReason) {
+    const values = reason ? REASON_VALUES[reason] : undefined
+    return values ? { key: byReason, detail: null, values } : { key: byReason, detail: null }
+  }
 
   const code = codeOf(err)
 
@@ -194,8 +219,11 @@ export function errorLine(err: unknown): ErrorLine {
  * `@kernhq/ui`, and that entry point drags a Svelte compiler into whatever imports it, which is
  * what makes a helper untestable.
  */
-export function errorMessage(err: unknown, translate: (key: string) => string): string {
+export function errorMessage(
+  err: unknown,
+  translate: (key: string, values?: Record<string, string | number>) => string,
+): string {
   const line = errorLine(err)
-  const sentence = translate(line.key)
+  const sentence = translate(line.key, line.values)
   return line.detail ? `${sentence} — ${line.detail}` : sentence
 }

package/src/client/messages.ts

@@ -128,13 +128,22 @@ export const en: Record<string, Message> = {
   'inventory.category_new': 'New category',
   'inventory.category_edit': 'Edit category',
   'inventory.category_name_placeholder': 'Laptops, Furniture, Cameras…',
-  'inventory.category_order': 'Position',
-  'inventory.category_order_hint':
-    'Lower comes first. Categories sharing a position fall back to their names.',
-  // A hint and an error are not the same sentence. This field passed the hint as both, so typing
-  // "x" restated how positions sort — in red, under a field whose problem was that it held no
-  // number. An error says what is wrong with what is there.
-  'inventory.category_order_invalid': 'Use a whole number from 0 to 9999',
+  // This was a **Position** field: a number box, and a hint explaining that lower comes first and
+  // that two categories sharing a number fall back to their names. That is a database column with a
+  // form around it. Nobody arranges their filing by integer, and the form invited the one state it
+  // then had to explain. The order is dragged now, so the words are about the gesture — and about
+  // the buttons beside it, because a drag is unreachable by keyboard.
+  'inventory.category_reorder_hint':
+    'Drag a category, or use the arrows on its row, to change the order they appear in.',
+  'inventory.category_move_up': 'Move {name} up',
+  'inventory.category_move_down': 'Move {name} down',
+  // What a screen reader is told after a move — "after Cameras", never "position 3 of 9". A
+  // neighbour's name is the thing that says where something is; a number is two more facts to hold
+  // in your head to work out the same answer. Worded as where it *is* rather than what just
+  // happened, so pressing the button on a row that cannot move any further is still true.
+  'inventory.category_position_first': '{name} is first',
+  'inventory.category_position_last': '{name} is last',
+  'inventory.category_position_after': '{name} is after {other}',
   'inventory.category_created_toast': '{name} added',
   'inventory.category_updated_toast': '{name} saved',
   'inventory.category_archived_toast': '{name} archived',
@@ -312,6 +321,27 @@ export const en: Record<string, Message> = {
   'inventory.error_repair_returned_before_sent':
     'A repair cannot come back before it was sent. Check the two dates.',
   'inventory.error_category_name_taken': 'This workspace already has a category with that name.',
+  // The refusal a reorder earns when somebody added, archived or restored a category in another tab
+  // while this page was open. The list in hand no longer describes the workspace, so the server
+  // refuses the whole thing rather than renumbering what it was given and dropping the rest
+  // somewhere nobody chose.
+  //
+  // Three facts, in the order somebody needs them: what happened, that **this arrangement was not
+  // saved**, and that the list on screen is the current one. The middle one used to be missing, and
+  // the sentence went straight from "somebody changed the categories" to "put them in order again"
+  // — which reads as though the drag had landed and only needed repeating. It also said the list had
+  // been refreshed while the screen was still holding the very list the server had refused, so
+  // repeating the drag earned the same refusal for ever. `reseed` is what makes the last clause true.
+  'inventory.error_category_order_stale':
+    'Somebody else changed the categories while this page was open, so this order was not saved. The list below has been refreshed — arrange it again.',
+  // A stated ceiling rather than a silent one. `categories.reorder` is handed every live category at
+  // once, so its input array has a bound; leaving the bound only there would let a workspace grow
+  // past it one category at a time and then find the only procedure that can order them refusing to
+  // run. The number is `MAX_LIVE_CATEGORIES` from the contract, passed through `t` so it is written
+  // in the reader's own digits — and archiving really does make room, because the limit counts the
+  // live rows.
+  'inventory.error_category_limit_reached':
+    'A workspace can keep {max} categories at once, and this one has them all. Archive one it no longer uses to make room.',
   // The classes of failure, for a refusal carrying no reason of its own. A capability switched off
   // answers 404 rather than 403 — that is the module contract — so it lands on `not_found`, which
   // is the right sentence for it: the surface is not there any more, look again.
@@ -437,9 +467,14 @@ export const fa: Record<string, Message> = {
   'inventory.category_new': 'دستهٔ جدید',
   'inventory.category_edit': 'ویرایش دسته‌بندی',
   'inventory.category_name_placeholder': 'لپ‌تاپ، مبلمان، دوربین…',
-  'inventory.category_order': 'ترتیب',
-  'inventory.category_order_hint': 'عدد کمتر جلوتر می‌آید. دسته‌هایی با ترتیب یکسان بر اساس نام مرتب می‌شوند.',
-  'inventory.category_order_invalid': 'عددی درست از ۰ تا ۹۹۹۹ وارد کنید',
+  // فارسی جمله را با هدف آغاز می‌کند، نه با کنش — برعکس انگلیسی.
+  'inventory.category_reorder_hint':
+    'برای تغییر ترتیب نمایش، دسته‌بندی را بکشید یا از پیکان‌های همان ردیف استفاده کنید.',
+  'inventory.category_move_up': 'انتقال {name} به بالا',
+  'inventory.category_move_down': 'انتقال {name} به پایین',
+  'inventory.category_position_first': '{name} در ابتدای فهرست است',
+  'inventory.category_position_last': '{name} در انتهای فهرست است',
+  'inventory.category_position_after': '{name} پس از {other} است',
   'inventory.category_created_toast': '{name} افزوده شد',
   'inventory.category_updated_toast': '{name} ذخیره شد',
   'inventory.category_archived_toast': '{name} بایگانی شد',
@@ -584,6 +619,11 @@ export const fa: Record<string, Message> = {
   'inventory.error_repair_returned_before_sent':
     'تعمیر نمی‌تواند پیش از فرستاده‌شدن بازگردد. دو تاریخ را بررسی کنید.',
   'inventory.error_category_name_taken': 'این فضای کاری از پیش دسته‌بندی‌ای با این نام دارد.',
+  // فارسی جمله را با زمان آغاز می‌کند، نه با فاعل — برعکس انگلیسی.
+  'inventory.error_category_order_stale':
+    'هنگامی که این صفحه باز بود، کس دیگری دسته‌بندی‌ها را تغییر داد؛ بنابراین این ترتیب ذخیره نشد. فهرست زیر تازه شده است — دوباره مرتبش کنید.',
+  'inventory.error_category_limit_reached':
+    'هر فضای کاری هم‌زمان می‌تواند {max} دسته‌بندی داشته باشد و این فضا همه را دارد. برای باز شدن جا، دسته‌بندی‌ای را که دیگر به کار نمی‌آید بایگانی کنید.',
   'inventory.error_not_found':
     'آن دیگر آنجا نیست. شاید کسی حذف یا بایگانی‌اش کرده باشد — صفحه را دوباره بارگذاری کنید.',
   'inventory.error_forbidden': 'اجازهٔ این کار را ندارید.',
@@ -703,9 +743,12 @@ export const ar: Record<string, Message> = {
   'inventory.category_new': 'فئة جديدة',
   'inventory.category_edit': 'تعديل الفئة',
   'inventory.category_name_placeholder': 'حواسيب، أثاث، كاميرات…',
-  'inventory.category_order': 'الترتيب',
-  'inventory.category_order_hint': 'الأصغر يأتي أولًا. الفئات المتساوية تُرتَّب بأسمائها.',
-  'inventory.category_order_invalid': 'أدخل عددًا صحيحًا من ٠ إلى ٩٩٩٩',
+  'inventory.category_reorder_hint': 'اسحب فئة أو استخدم السهمين في صفّها لتغيير ترتيب ظهورها.',
+  'inventory.category_move_up': 'نقل {name} إلى الأعلى',
+  'inventory.category_move_down': 'نقل {name} إلى الأسفل',
+  'inventory.category_position_first': '{name} في أول القائمة',
+  'inventory.category_position_last': '{name} في آخر القائمة',
+  'inventory.category_position_after': '{name} بعد {other}',
   'inventory.category_created_toast': 'تمت إضافة {name}',
   'inventory.category_updated_toast': 'تم حفظ {name}',
   'inventory.category_archived_toast': 'تمت أرشفة {name}',
@@ -851,6 +894,10 @@ export const ar: Record<string, Message> = {
   'inventory.error_repair_already_complete': 'سُجّل هذا الإصلاح منتهيًا بالفعل.',
   'inventory.error_repair_returned_before_sent': 'لا يمكن أن يعود الإصلاح قبل إرساله. راجع التاريخين.',
   'inventory.error_category_name_taken': 'في مساحة العمل هذه فئة بهذا الاسم بالفعل.',
+  'inventory.error_category_order_stale':
+    'غيّر شخص آخر الفئات بينما كانت هذه الصفحة مفتوحة، فلم يُحفَظ هذا الترتيب. القائمة أدناه محدَّثة — أعد ترتيبها.',
+  'inventory.error_category_limit_reached':
+    'يمكن لمساحة العمل أن تضم {max} فئة في وقت واحد، وهذه المساحة بلغت العدد. أرشِف فئة لم تعد تُستعمَل لتوفير مكان.',
   'inventory.error_not_found': 'لم يعد ذلك موجودًا. ربما أزاله أحدهم أو أرشفه — أعد تحميل الصفحة لترى.',
   'inventory.error_forbidden': 'لا تملك صلاحية القيام بذلك.',
   'inventory.error_module_disabled': 'وحدة الأصول مُطفأة في مساحة العمل هذه.',
@@ -963,9 +1010,13 @@ export const de: Record<string, Message> = {
   'inventory.category_new': 'Neue Kategorie',
   'inventory.category_edit': 'Kategorie bearbeiten',
   'inventory.category_name_placeholder': 'Laptops, Möbel, Kameras…',
-  'inventory.category_order': 'Position',
-  'inventory.category_order_hint': 'Kleinere Zahlen stehen vorn. Bei gleicher Position entscheidet der Name.',
-  'inventory.category_order_invalid': 'Ganze Zahl von 0 bis 9999 eingeben',
+  'inventory.category_reorder_hint':
+    'Ziehen Sie eine Kategorie oder nutzen Sie die Pfeile in ihrer Zeile, um die Reihenfolge zu ändern.',
+  'inventory.category_move_up': '{name} nach oben schieben',
+  'inventory.category_move_down': '{name} nach unten schieben',
+  'inventory.category_position_first': '{name} steht an erster Stelle',
+  'inventory.category_position_last': '{name} steht an letzter Stelle',
+  'inventory.category_position_after': '{name} steht hinter {other}',
   'inventory.category_created_toast': '{name} hinzugefügt',
   'inventory.category_updated_toast': '{name} gespeichert',
   'inventory.category_archived_toast': '{name} archiviert',
@@ -1124,6 +1175,10 @@ export const de: Record<string, Message> = {
     'Eine Reparatur kann nicht vor der Abgabe zurückkommen. Prüfen Sie die beiden Daten.',
   'inventory.error_category_name_taken':
     'In diesem Workspace gibt es bereits eine Kategorie mit diesem Namen.',
+  'inventory.error_category_order_stale':
+    'Jemand anderes hat die Kategorien geändert, während diese Seite offen war — diese Reihenfolge wurde nicht gespeichert. Die Liste unten ist wieder aktuell; ordnen Sie sie erneut.',
+  'inventory.error_category_limit_reached':
+    'Ein Workspace kann {max} Kategorien gleichzeitig führen, und dieser hat sie alle. Archivieren Sie eine, die nicht mehr gebraucht wird, um Platz zu schaffen.',
   'inventory.error_not_found':
     'Das ist nicht mehr da. Vielleicht hat es jemand entfernt oder archiviert — laden Sie die Seite neu.',
   'inventory.error_forbidden': 'Dazu sind Sie nicht berechtigt.',
@@ -1246,9 +1301,13 @@ export const tr: Record<string, Message> = {
   'inventory.category_new': 'Yeni kategori',
   'inventory.category_edit': 'Kategoriyi düzenle',
   'inventory.category_name_placeholder': 'Dizüstüler, Mobilya, Kameralar…',
-  'inventory.category_order': 'Sıra',
-  'inventory.category_order_hint': 'Küçük sayı önce gelir. Sırası aynı olan kategoriler ada göre sıralanır.',
-  'inventory.category_order_invalid': '0 ile 9999 arasında bir tam sayı girin',
+  'inventory.category_reorder_hint':
+    'Görünme sırasını değiştirmek için bir kategoriyi sürükleyin ya da satırındaki okları kullanın.',
+  'inventory.category_move_up': '{name} kategorisini yukarı taşı',
+  'inventory.category_move_down': '{name} kategorisini aşağı taşı',
+  'inventory.category_position_first': '{name} ilk sırada',
+  'inventory.category_position_last': '{name} son sırada',
+  'inventory.category_position_after': '{name}, {other} kategorisinden sonra',
   'inventory.category_created_toast': '{name} eklendi',
   'inventory.category_updated_toast': '{name} kaydedildi',
   'inventory.category_archived_toast': '{name} arşivlendi',
@@ -1397,6 +1456,10 @@ export const tr: Record<string, Message> = {
   'inventory.error_repair_returned_before_sent':
     'Bir onarım gönderilmeden önce dönemez. İki tarihi kontrol edin.',
   'inventory.error_category_name_taken': 'Bu çalışma alanında bu adda bir kategori zaten var.',
+  'inventory.error_category_order_stale':
+    'Bu sayfa açıkken başkası kategorileri değiştirdi, bu yüzden bu sıralama kaydedilmedi. Aşağıdaki liste yenilendi — sırayı yeniden verin.',
+  'inventory.error_category_limit_reached':
+    'Bir çalışma alanı aynı anda {max} kategori tutabilir ve bu alanda hepsi dolu. Yer açmak için artık kullanılmayan bir kategoriyi arşivleyin.',
   'inventory.error_not_found':
     'O artık orada değil. Biri kaldırmış ya da arşivlemiş olabilir — sayfayı yeniden yükleyin.',
   'inventory.error_forbidden': 'Bunu yapma yetkiniz yok.',

package/src/client/mock.test.ts

@@ -235,7 +235,7 @@ describe('mock categories', () => {
 
   it('creates, renames and archives without ever deleting', async () => {
     const api = createMockInventoryApi()
-    const made = await api.categories.create({ workspaceId: WS, name: 'Tools', order: 9 })
+    const made = await api.categories.create({ workspaceId: WS, name: 'Tools' })
     expect(made.name).toBe('Tools')
     const renamed = await api.categories.update({ workspaceId: WS, categoryId: made.id, name: 'Hand tools' })
     expect(renamed.name).toBe('Hand tools')
@@ -245,6 +245,76 @@ describe('mock categories', () => {
     await api.categories.archive({ workspaceId: WS, categoryId: made.id, archived: false })
     expect((await api.categories.list({ workspaceId: WS })).map((c) => c.id)).toContain(made.id)
   })
+
+  /**
+   * A new category joins the **end**, and so does a restored one.
+   *
+   * The demo has to agree with the server about this or the settings page contradicts itself in
+   * exactly the environment the product is shown in: a category added while somebody watches
+   * appearing in the middle of a list they just arranged is the defect the *Position* field caused.
+   */
+  it('appends a new category, and a restored one, rather than dropping it into the middle', async () => {
+    const api = createMockInventoryApi()
+    const made = await api.categories.create({ workspaceId: WS, name: 'Tools' })
+    expect((await api.categories.list({ workspaceId: WS })).map((c) => c.name)).toEqual([
+      'Laptops',
+      'Displays',
+      'Furniture',
+      'Cameras',
+      'Tools',
+    ])
+
+    const all = await api.categories.list({ workspaceId: WS, archived: true })
+    const phones = all.find((c) => c.name === 'Phones')
+    await api.categories.archive({ workspaceId: WS, categoryId: phones?.id ?? '', archived: false })
+    const live = await api.categories.list({ workspaceId: WS })
+    expect(live.at(-1)?.name, 'restored at the end, not back on its old number').toBe('Phones')
+    expect(new Set(live.map((c) => c.order)).size, 'and no two live categories share a place').toBe(
+      live.length,
+    )
+    expect(made.name).toBe('Tools')
+  })
+
+  /**
+   * Reordering, including both refusals — a demo that can only show the happy path cannot exercise
+   * the settings page's rollback, which is the half of the feature nobody sees until it matters.
+   */
+  it('reorders the sequence, and refuses a list that no longer describes the workspace', async () => {
+    const api = createMockInventoryApi()
+    const live = await api.categories.list({ workspaceId: WS })
+    const ids = live.map((c) => c.id)
+
+    const moved = await api.categories.reorder({
+      workspaceId: WS,
+      categoryIds: [ids[3] as string, ...ids.slice(0, 3)],
+    })
+    expect(moved.map((c) => c.name)).toEqual(['Cameras', 'Laptops', 'Displays', 'Furniture'])
+    expect((await api.categories.list({ workspaceId: WS })).map((c) => c.name)).toEqual([
+      'Cameras',
+      'Laptops',
+      'Displays',
+      'Furniture',
+    ])
+
+    await expect(
+      api.categories.reorder({ workspaceId: WS, categoryIds: ids.slice(0, 2) }),
+    ).rejects.toMatchObject({ code: 'CONFLICT', data: { reason: 'inventory.category.order_stale' } })
+
+    await expect(
+      api.categories.reorder({
+        workspaceId: WS,
+        categoryIds: [...ids, '01920000-0000-7000-8000-0000000000ff'],
+      }),
+    ).rejects.toMatchObject({ code: 'NOT_FOUND' })
+
+    // Neither refusal wrote anything.
+    expect((await api.categories.list({ workspaceId: WS })).map((c) => c.name)).toEqual([
+      'Cameras',
+      'Laptops',
+      'Displays',
+      'Furniture',
+    ])
+  })
 })
 
 /**

package/src/client/mock.ts

@@ -545,6 +545,14 @@ export function createMockInventoryApi(options: MockInventoryOptions = {}) {
     return category
   }
 
+  /**
+   * One past the highest position in use, archived rows counted — the server's `appended()`.
+   *
+   * Archived rows count because one of them can be restored, and a restored category landing on a
+   * live one's number is the tie that made a "Position" field a bad idea in the first place.
+   */
+  const appendedOrder = () => categories.reduce((max, c) => Math.max(max, c.order), -1) + 1
+
   const openPeriodFor = (id: string) =>
     periods.find((period) => period.assetId === id && period.effectiveTo === null)
 
@@ -766,15 +774,7 @@ export function createMockInventoryApi(options: MockInventoryOptions = {}) {
           .map(stamp)
       },
 
-      create: async ({
-        workspaceId,
-        name,
-        order = 0,
-      }: {
-        workspaceId: string
-        name: string
-        order?: number
-      }) => {
+      create: async ({ workspaceId, name }: { workspaceId: string; name: string }) => {
         remember(workspaceId)
         // The server's unique index is what actually decides, and it answers a duplicate with a
         // sentence rather than a 500. The demo answers the same way.
@@ -789,7 +789,9 @@ export function createMockInventoryApi(options: MockInventoryOptions = {}) {
           id: categoryId(),
           workspaceId: '' as Asset['workspaceId'],
           name,
-          order,
+          // Appended, like the server: a new category joins the end of the sequence rather than
+          // landing at the front tied with whatever is already there.
+          order: appendedOrder(),
           createdAt: now,
           updatedAt: now,
           archivedAt: null,
@@ -806,7 +808,6 @@ export function createMockInventoryApi(options: MockInventoryOptions = {}) {
         workspaceId?: string
         categoryId: string
         name?: string
-        order?: number
       }) => {
         remember(workspaceId)
         const category = findCategory(id)
@@ -832,10 +833,48 @@ export function createMockInventoryApi(options: MockInventoryOptions = {}) {
         remember(workspaceId)
         const category = findCategory(id)
         // Nothing deletes: an asset filed under this category keeps naming it.
-        category.archivedAt = archived === false ? null : new Date().toISOString()
+        const restoring = archived === false
+        category.archivedAt = restoring ? null : new Date().toISOString()
+        // A restore appends, like the server: the position it left with belongs to somebody else by
+        // now, and the end of the list is the one place a person can find it again.
+        if (restoring) category.order = appendedOrder()
         category.updatedAt = new Date().toISOString()
         return stamp(category)
       },
+
+      /**
+       * The sequence, rewritten from the ids — and the two refusals the server makes, because a
+       * demo that cannot reproduce them is a demo of the happy path.
+       *
+       * An id this workspace does not have is `NOT_FOUND`; a list that does not name every live
+       * category exactly once is the stale conflict, reason and all, so the settings page's rollback
+       * can be exercised without a server.
+       */
+      reorder: async ({ workspaceId, categoryIds }: { workspaceId?: string; categoryIds: string[] }) => {
+        remember(workspaceId)
+        const named = new Set(categoryIds)
+        if (named.size !== categoryIds.length)
+          throw new MockApiError('BAD_REQUEST', 'That list of categories names the same one more than once.')
+        for (const id of categoryIds) findCategory(id)
+        const live = categories.filter((category) => !category.archivedAt)
+        if (
+          live.some((category) => !named.has(category.id)) ||
+          categoryIds.some((id) => findCategory(id).archivedAt)
+        )
+          throw new MockApiError(
+            'CONFLICT',
+            'The categories changed while this list was open, so this order was not saved. Reload the list and arrange it again.',
+            'inventory.category.order_stale',
+          )
+        const now = new Date().toISOString()
+        for (const [index, id] of categoryIds.entries()) {
+          const category = findCategory(id)
+          if (category.order === index) continue
+          category.order = index
+          category.updatedAt = now
+        }
+        return categoryIds.map((id) => stamp(findCategory(id)))
+      },
     },
 
     /**

package/src/client/module.ts

@@ -15,7 +15,25 @@ import { INVENTORY_PERMISSIONS } from './permissions.js'
  */
 export const inventoryClientModule = defineClientModule({
   id: 'inventory',
-  name: 'Inventory',
+  /**
+   * A getter, for the reason every label below is one — and now that this field is rendered too, the
+   * reason reaches it.
+   *
+   * `name` was the last string in this file left as an English literal, on the grounds that a
+   * manifest name is data an operator greps rather than a string a reader sees. That stopped being
+   * true: the dashboard's widget picker heads this module's group with `mod.name` directly, so a
+   * Persian reader was shown "Inventory" as a section label in an otherwise Persian panel, and the
+   * shell's settings rail falls back to it for any module whose navigation it cannot read.
+   *
+   * `name` is typed as a plain `string` on `ClientModule`, and a getter satisfies that exactly as
+   * `get label()` does for a nav item. Nothing snapshots it: `defineClientModule` returns the object
+   * unchanged, `registerModule` pushes that same object into an array, and every reader goes through
+   * the property — so the language it resolves in is the one on screen rather than the one that
+   * happened to be loaded at import time.
+   */
+  get name() {
+    return t('nav')
+  },
   icon: 'briefcase',
   messages: inventoryMessageBundles,
 

package/src/client/reorder.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, it } from 'vitest'
+import { moveBy, placementOf, sameOrder } from './reorder.js'
+
+/**
+ * The arithmetic behind dragging a category, and behind the two buttons that do the same thing
+ * without a pointer.
+ *
+ * The settings page is a `.svelte` file and cannot be unit-tested here, which is exactly why this
+ * arithmetic does not live in it. Every case below is one somebody will actually reach: the first
+ * row cannot go up, the last cannot go down, a drag that ends where it started must cost nothing,
+ * and a row that was archived in another tab is not in the list any more.
+ */
+const list = (...ids: string[]) => ids.map((id) => ({ id, name: id.toUpperCase() }))
+const ids = (items: readonly { id: string }[]) => items.map((item) => item.id)
+
+describe('moving a row', () => {
+  it('moves one up', () => {
+    expect(ids(moveBy(list('a', 'b', 'c'), 'c', -1))).toEqual(['a', 'c', 'b'])
+  })
+
+  it('moves one down', () => {
+    expect(ids(moveBy(list('a', 'b', 'c'), 'a', 1))).toEqual(['b', 'a', 'c'])
+  })
+
+  it('moves one to the top and to the bottom', () => {
+    expect(ids(moveBy(list('a', 'b', 'c', 'd'), 'd', -3))).toEqual(['d', 'a', 'b', 'c'])
+    expect(ids(moveBy(list('a', 'b', 'c', 'd'), 'a', 3))).toEqual(['b', 'c', 'd', 'a'])
+  })
+
+  /**
+   * Clamped rather than refused. *Move up* on the row that is already first is a button somebody
+   * will press, and it is not a mistake — the answer is that it is already first.
+   */
+  it('clamps a move that would fall off either end', () => {
+    expect(ids(moveBy(list('a', 'b', 'c'), 'c', -99))).toEqual(['c', 'a', 'b'])
+    expect(ids(moveBy(list('a', 'b', 'c'), 'a', 99))).toEqual(['b', 'c', 'a'])
+  })
+
+  /**
+   * The same array back, by reference — the caller reads that as "nothing to send". An equal copy
+   * would pass every assertion above and post a reorder every time somebody pressed the button on
+   * the row that cannot move.
+   */
+  it('gives back the very same list when nothing moves', () => {
+    const items = list('a', 'b', 'c')
+    expect(moveBy(items, 'a', -1)).toBe(items)
+    expect(moveBy(items, 'c', 1)).toBe(items)
+    expect(moveBy(items, 'b', 0)).toBe(items)
+    expect(moveBy(items, 'nobody', -1)).toBe(items)
+    expect(moveBy([], 'a', 1)).toEqual([])
+  })
+
+  it('leaves the list it was given alone', () => {
+    const items = list('a', 'b', 'c')
+    moveBy(items, 'a', 2)
+    expect(ids(items)).toEqual(['a', 'b', 'c'])
+  })
+
+  it('moves the only row nowhere', () => {
+    const items = list('a')
+    expect(moveBy(items, 'a', -1)).toBe(items)
+    expect(moveBy(items, 'a', 1)).toBe(items)
+  })
+})
+
+describe('saying where a row landed', () => {
+  it('names the row it now follows, rather than a position', () => {
+    expect(placementOf(list('a', 'b', 'c'), 'b')).toEqual({ at: 'after', previous: { id: 'a', name: 'A' } })
+  })
+
+  it('calls the ends the ends', () => {
+    expect(placementOf(list('a', 'b', 'c'), 'a')).toEqual({ at: 'first' })
+    expect(placementOf(list('a', 'b', 'c'), 'c')).toEqual({ at: 'last' })
+  })
+
+  it('calls the only row first, which is true and reads better than last', () => {
+    expect(placementOf(list('a'), 'a')).toEqual({ at: 'first' })
+  })
+
+  it('says a row that is no longer in the list is gone, rather than guessing', () => {
+    // Somebody archived it in another tab while this page was open.
+    expect(placementOf(list('a', 'b'), 'c')).toEqual({ at: 'gone' })
+  })
+})
+
+describe('whether anything actually changed', () => {
+  it('sees a drag that ended where it started', () => {
+    expect(sameOrder(list('a', 'b', 'c'), list('a', 'b', 'c'))).toBe(true)
+  })
+
+  it('sees a real move, a longer list and a different membership', () => {
+    expect(sameOrder(list('a', 'b', 'c'), list('a', 'c', 'b'))).toBe(false)
+    expect(sameOrder(list('a', 'b'), list('a', 'b', 'c'))).toBe(false)
+    expect(sameOrder(list('a', 'b'), list('a', 'z'))).toBe(false)
+  })
+
+  it('calls two empty lists the same', () => {
+    expect(sameOrder([], [])).toBe(true)
+  })
+})

package/src/client/reorder.ts

@@ -0,0 +1,79 @@
+/**
+ * Moving one row up or down a list, and saying where it landed.
+ *
+ * Pure arithmetic, in its own file, for the reason `custody.ts` and `price.ts` are: a `.svelte` file
+ * cannot be unit-tested here, so anything inside one is only ever checked by reading it. The ends of
+ * a list are exactly where an off-by-one lives — moving the first row up, moving the last row down,
+ * dragging something to a position it already occupies — and those are three assertions rather than
+ * three careful reads.
+ *
+ * **A no-op returns the array it was given, by reference.** That is the signal the caller acts on:
+ * nothing moved, so there is nothing to send and nothing to announce as a move. Returning an equal
+ * copy would look identical in a test and cost a request every time somebody pressed *move up* on
+ * the row that is already first.
+ */
+
+/**
+ * The one property `svelte-dnd-action` reads, and therefore the one this file needs.
+ *
+ * The library tracks items by `id` and by nothing else — a list keyed by anything else renders
+ * perfectly and refuses to move, by mouse and by keyboard, with no error at all. A `Category` has
+ * an `id` already, which is the only reason the settings page hands its rows over unwrapped.
+ */
+export interface Ordered {
+  id: string
+}
+
+/**
+ * The list with `id` moved `delta` places, or the same list when that would change nothing.
+ *
+ * `delta` is clamped rather than refused: *move up* on the first row is a thing somebody will press,
+ * and the honest answer is "it is already first", not an error. The input is never mutated.
+ */
+export function moveBy<T extends Ordered>(items: readonly T[], id: string, delta: number): readonly T[] {
+  const from = items.findIndex((item) => item.id === id)
+  if (from === -1) return items
+  const to = Math.min(items.length - 1, Math.max(0, from + delta))
+  if (to === from) return items
+  const next = [...items]
+  const [moved] = next.splice(from, 1)
+  next.splice(to, 0, moved as T)
+  return next
+}
+
+/** Where a row sits now, in the terms a sentence can use — never as a number. */
+export type Placement<T> =
+  | { at: 'first' }
+  | { at: 'last' }
+  /** Somewhere in the middle: the row it now follows is what identifies the spot. */
+  | { at: 'after'; previous: T }
+  /** It is not in this list at all — it was archived or removed while the page was open. */
+  | { at: 'gone' }
+
+/**
+ * Where `id` ended up, for the sentence a screen reader is given.
+ *
+ * **"first", "last" or "after {name}" rather than a position number.** A number is the thing this
+ * whole screen stopped showing: nobody arranges their categories by index, and "moved to position 4
+ * of 9" asks somebody to hold two numbers in their head to work out what a neighbour's name would
+ * have told them outright. A one-row list is `first`, which is true and reads better than `last`.
+ */
+export function placementOf<T extends Ordered>(items: readonly T[], id: string): Placement<T> {
+  const at = items.findIndex((item) => item.id === id)
+  if (at === -1) return { at: 'gone' }
+  if (at === 0) return { at: 'first' }
+  if (at === items.length - 1) return { at: 'last' }
+  return { at: 'after', previous: items[at - 1] as T }
+}
+
+/**
+ * Whether two lists hold the same ids in the same order.
+ *
+ * What decides a request is worth making. A drag that ends where it started fires `finalize` exactly
+ * as a real one does — the library has no opinion about whether anything moved — so without this
+ * every aborted drag would post a reorder and every open screen in the workspace would be told
+ * about a write that changed nothing.
+ */
+export function sameOrder(a: readonly Ordered[], b: readonly Ordered[]): boolean {
+  return a.length === b.length && a.every((item, index) => item.id === b[index]?.id)
+}