@kernhq/module-inventory 0.2.0 → 0.4.0

package/src/client/price.test.ts

@@ -1,5 +1,12 @@
 import { describe, expect, it } from 'vitest'
-import { formatPrice, parsePrice } from './price.js'
+import {
+  CURRENCIES,
+  currencyOptions,
+  formatPrice,
+  minorUnitExponent,
+  parsePrice,
+  priceExample,
+} from './price.js'
 
 /**
  * The regression this file exists for.
@@ -9,8 +16,8 @@ import { formatPrice, parsePrice } from './price.js'
  * languages this module ships, silently, with no error anywhere. `abc` and `-5` were worse: they
  * came back `null` and the asset saved with no price at all.
  */
-const minor = (raw: string, locale: string) => {
-  const result = parsePrice(raw, locale)
+const minor = (raw: string, locale: string, currency?: string | null) => {
+  const result = parsePrice(raw, locale, currency)
   return result.ok ? result.minor : 'invalid'
 }
 
@@ -76,6 +83,97 @@ describe('parsePrice', () => {
   })
 })
 
+/**
+ * The second silent 100×, and the one the picker itself created.
+ *
+ * `parsePrice` and `formatPrice` both hard-coded 1/100 while the currency list offers **JPY**,
+ * which has no minor unit at all, and **KWD**, which has three decimal places. So ¥1000 typed into
+ * the field was stored as 100000 minor units — ¥100 000 to anything reading the column honestly —
+ * and every dinar amount was out by a factor of ten. **IRR is the one that stings**: the rial has
+ * no minor unit either, and it is the currency of a language this module ships.
+ */
+describe('the currency decides the minor unit', () => {
+  it('asks the currency rather than assuming hundredths', () => {
+    expect(minorUnitExponent('USD')).toBe(2)
+    expect(minorUnitExponent('EUR')).toBe(2)
+    expect(minorUnitExponent('JPY')).toBe(0)
+    expect(minorUnitExponent('IRR')).toBe(0)
+    expect(minorUnitExponent('KWD')).toBe(3)
+    // No currency on an amount is not a reason to make the field unusable, and two decimals is
+    // what ISO 4217 assigns by default.
+    expect(minorUnitExponent(null)).toBe(2)
+    expect(minorUnitExponent('')).toBe(2)
+    // The contract takes any three letters, so a code `Intl` refuses must not throw out of a form.
+    expect(minorUnitExponent('nonsense')).toBe(2)
+  })
+
+  it('stores ¥1000 as 1000, not as 10', () => {
+    expect(minor('1000', 'en', 'JPY')).toBe(1000)
+    expect(minor('1,000', 'en', 'JPY')).toBe(1000)
+    expect(formatPrice(1000, 'en', 'JPY')).toBe('1000')
+    // What it did before: hundredths, so the amount read back a hundred times too small.
+    expect(formatPrice(1000, 'en')).toBe('10.00')
+  })
+
+  it('keeps all three of a dinar’s decimal places', () => {
+    expect(minor('1.234', 'en', 'KWD')).toBe(1234)
+    expect(minor('1,234.567', 'en', 'KWD')).toBe(1234567)
+    expect(formatPrice(1234567, 'en', 'KWD')).toBe('1234.567')
+    // The old behaviour dropped the third place and was ten times out.
+    expect(minor('1.234', 'en')).toBe('invalid')
+  })
+
+  it('still reads a two-decimal currency exactly as before', () => {
+    expect(minor('19.99', 'en', 'USD')).toBe(1999)
+    expect(minor('1.234,56', 'de', 'EUR')).toBe(123456)
+    expect(formatPrice(123456, 'de', 'EUR')).toBe('1234,56')
+  })
+
+  /**
+   * The point of the whole fix: there is no path where a wrong number is stored quietly. `19.99`
+   * in a yen field is somebody who has not noticed which field they are in, and rounding it to
+   * ¥20 for them is the same class of silence as the `1.234,56` → €1.23 bug this file began with.
+   */
+  it('refuses more decimal places than the currency has, rather than rounding them away', () => {
+    expect(minor('19.99', 'en', 'JPY')).toBe('invalid')
+    expect(minor('0.5', 'en', 'JPY')).toBe('invalid')
+    expect(minor('.5', 'en', 'IRR')).toBe('invalid')
+    expect(minor('1.2345', 'en', 'KWD')).toBe('invalid')
+    expect(minor('1.234', 'en', 'USD')).toBe('invalid')
+  })
+
+  it('round-trips every shipped locale against a currency of each shape', () => {
+    for (const locale of ['en', 'de', 'tr', 'fa', 'ar']) {
+      for (const currency of ['USD', 'JPY', 'KWD', 'IRR']) {
+        for (const value of [0, 7, 2500, 123456, 99999999]) {
+          expect({
+            locale,
+            currency,
+            value,
+            back: minor(formatPrice(value, locale, currency), locale, currency),
+          }).toEqual({ locale, currency, value, back: value })
+        }
+      }
+    }
+  })
+
+  it('holds up an example the field would actually accept', () => {
+    // It said "Enter an amount like 1234.56" in a yen field and then refused 1234.56.
+    expect(priceExample('en', 'JPY')).toBe('1234')
+    expect(priceExample('en', 'KWD')).toBe('1234.567')
+    expect(priceExample('en', 'USD')).toBe('1234.56')
+    expect(priceExample('de', null)).toBe('1234,56')
+    for (const currency of ['USD', 'JPY', 'KWD', 'IRR', 'EUR']) {
+      const example = priceExample('en', currency)
+      expect({ currency, example, ok: parsePrice(example, 'en', currency).ok }).toEqual({
+        currency,
+        example,
+        ok: true,
+      })
+    }
+  })
+})
+
 describe('formatPrice', () => {
   it('has no price to show for no price', () => {
     expect(formatPrice(null, 'en')).toBe('')
@@ -104,3 +202,53 @@ describe('formatPrice', () => {
     expect(formatPrice(123456, 'en')).toBe('1234.56')
   })
 })
+
+/**
+ * The list a money field offers.
+ *
+ * It was `['USD', 'EUR', 'IRR', 'AED']` in a product whose language menu offers Turkish — so a
+ * workspace in Istanbul could not record what it paid for anything. The contract takes any ISO
+ * 4217 code (`z.string().length(3)`) and the server stores whatever arrives, so nothing but the
+ * picker was ever short: four options, one of them missing for one of the five shipped languages.
+ */
+describe('CURRENCIES', () => {
+  it('has a currency for every language this module ships', () => {
+    // The point of the whole fix. `tr` is on the language menu and TRY was not on this list.
+    for (const code of ['USD', 'EUR', 'TRY', 'IRR', 'AED']) expect(CURRENCIES).toContain(code)
+  })
+
+  it('offers codes `Intl` recognises, so a price is never labelled with something invented', () => {
+    for (const code of CURRENCIES) {
+      const formatted = new Intl.NumberFormat('en', { style: 'currency', currency: code }).format(1)
+      // An unknown code comes back as the literal code; a real one gets a symbol or a name, and
+      // either way `Intl` accepts it rather than throwing on a malformed one.
+      expect({ code, formatted: typeof formatted }).toEqual({ code, formatted: 'string' })
+      expect(code).toMatch(/^[A-Z]{3}$/)
+    }
+  })
+
+  it('lists each code once', () => {
+    expect([...new Set(CURRENCIES)]).toEqual([...CURRENCIES])
+  })
+
+  /**
+   * The order the comment above the list claims, which the list did not have.
+   *
+   * It said "the currency of each shipped language first, in the order the locales are listed
+   * everywhere else in this package (en, ar, de, fa, tr)" while the list read `USD, EUR, AED, TRY,
+   * IRR` — en, de, ar, tr, fa, which is no order at all. A rule nothing checks is a rule the next
+   * person appends underneath and quietly breaks, so it is checked.
+   */
+  it('opens with the currency of each shipped language, in the locale order', () => {
+    expect(CURRENCIES.slice(0, 5)).toEqual(['USD', 'AED', 'EUR', 'IRR', 'TRY'])
+  })
+
+  it('puts the empty option first, because an asset with no price has no currency', () => {
+    const options = currencyOptions('—')
+    expect(options[0]).toEqual({ value: '', label: '—' })
+    expect(options.slice(1).map((o) => o.value)).toEqual([...CURRENCIES])
+    // Codes rather than names: ISO 4217 is what the column stores, and a name is one more thing to
+    // translate five times for no gain over what somebody reads on their own bank statement.
+    expect(options.slice(1).every((o) => o.label === o.value)).toBe(true)
+  })
+})

package/src/client/price.ts

@@ -21,6 +21,120 @@
 /** `minor: null` is a real answer — an empty field means "no price", not a bad one. */
 export type PriceResult = { ok: true; minor: number | null } | { ok: false }
 
+/**
+ * The currencies a money field offers, in one place because two forms ask for one.
+ *
+ * The asset form and the repair form put the same question — what is this amount in — and a second
+ * copy of the list is a list that gains a currency in one form and not the other. Codes rather than
+ * names: ISO 4217 is what the column stores, and a currency name is one more thing to translate
+ * five times for no gain over the code somebody already reads on their own bank statement.
+ *
+ * **This list was `['USD', 'EUR', 'IRR', 'AED']` in a product that ships Turkish.** A Turkish
+ * workspace could not record what it paid for anything in lira: the contract takes any three-letter
+ * code (`z.string().length(3)`) and the server stores whatever arrives, so the shortage was the
+ * picker's alone — four options, one of which was missing for one of the five languages on the
+ * language menu. TRY, and the currency of every other locale this module ships, is now here.
+ *
+ * The order is deliberate and is not alphabetical: the currency of each shipped language first, in
+ * the order the locales are listed everywhere else in this package (en, ar, de, fa, tr) — so USD,
+ * AED, EUR, IRR, TRY — then the ones a company in those places is most likely to have paid an
+ * invoice in. A picker sorted A–Z puts AED above USD for a reader in Berlin, which is tidy and
+ * useless.
+ *
+ * **The comment said that while the list said `USD, EUR, AED, TRY, IRR`**, which is no order at
+ * all — en, de, ar, tr, fa — so the rule a sixth currency was supposed to be filed under described
+ * something that had never been true. `price.test.ts` now asserts the first five, because a stated
+ * order nothing checks drifts back the first time somebody appends a code.
+ *
+ * It is still a list, not the whole of ISO 4217: all 180 codes in a `<select>` is not a kindness.
+ *
+ * **What a new asset defaults to is deliberately nothing.** The obvious improvement on "the first
+ * code in the list" is "whatever this workspace uses", and that is right — but a workspace currency
+ * does not exist: `InventorySettings` holds the tag prefix, the tag padding and the two notice
+ * windows, and nothing else, so `defaultCurrency` is a contract change rather than something a
+ * picker can invent. The tempting shortcut is to read it off the reader's locale, and that is
+ * *worse* than no default: two colleagues in one workspace, one reading German and one reading
+ * Turkish, would be handed different pre-selected currencies for the same register, notice nothing,
+ * and store EUR against one laptop and TRY against the next. A currency is a fact about the
+ * company, not about the language somebody happens to read the screen in. So the forms seed from
+ * the *record* — a repair inherits its asset's currency, an edit keeps its own — and a new asset
+ * starts empty, which asks the question instead of answering it wrongly.
+ */
+export const CURRENCIES = [
+  'USD',
+  'AED',
+  'EUR',
+  'IRR',
+  'TRY',
+  'GBP',
+  'SAR',
+  'QAR',
+  'KWD',
+  'EGP',
+  'CHF',
+  'SEK',
+  'NOK',
+  'DKK',
+  'PLN',
+  'CAD',
+  'AUD',
+  'JPY',
+  'CNY',
+  'INR',
+] as const
+
+/**
+ * The options both money fields offer, built once.
+ *
+ * The empty option is first and is a real answer: an asset with no price has no currency either,
+ * and a picker with no way back to "none" is a field somebody can fill in and never clear.
+ */
+export function currencyOptions(noneLabel: string): Array<{ value: string; label: string }> {
+  return [{ value: '', label: noneLabel }, ...CURRENCIES.map((code) => ({ value: code, label: code }))]
+}
+
+const EXPONENTS: Map<string, number> = new Map()
+
+/**
+ * How many decimal places this currency has — asked of the currency, never assumed to be two.
+ *
+ * **This module stored ¥1000 as ¥10 and every KWD amount ten times too small.** `parsePrice` and
+ * `formatPrice` both hard-coded 1/100, and the picker offers JPY, which has *no* minor unit, and
+ * KWD, which has *three* decimal places. So `1000` typed into a yen field became 100000 minor
+ * units, read back as `1000.00`, and was ¥100 000 to anything that read the column honestly — a
+ * silent 100× on exactly the shape of field this file was rewritten to stop silently mangling.
+ *
+ * **IRR is the one that matters most here**, because it is the currency of a language this module
+ * ships: the rial has no minor unit either, so a Persian workspace was the default victim.
+ *
+ * CLDR knows each currency's exponent and `Intl` will hand it over, so nothing is tabulated: a
+ * currency added to `CURRENCIES` next year gets the right answer without anybody remembering this
+ * function exists. A code `Intl` refuses, or one it has never heard of, falls back to two — which
+ * is what ISO 4217 assigns by default, and is the only guess available.
+ *
+ * The locale is fixed at `'en'` deliberately: the exponent is a fact about the *currency*, and
+ * asking under the reader's locale would make the same money parse differently for two colleagues.
+ */
+export function minorUnitExponent(currency: string | null | undefined): number {
+  if (!currency) return 2
+  const cached = EXPONENTS.get(currency)
+  if (cached !== undefined) return cached
+  let exponent = 2
+  try {
+    // `maximumFractionDigits` is optional in the DOM lib and always present in practice for a
+    // currency formatter; `??` is what keeps the two type-checks agreeing about that.
+    exponent =
+      new Intl.NumberFormat('en', { style: 'currency', currency }).resolvedOptions().maximumFractionDigits ??
+      2
+  } catch {
+    // A malformed code — the contract takes any three letters and the picker is not the only way
+    // in. Two decimals is ISO 4217's own default and keeps the field usable.
+  }
+  if (!Number.isInteger(exponent) || exponent < 0 || exponent > 4) exponent = 2
+  EXPONENTS.set(currency, exponent)
+  return exponent
+}
+
 interface Separators {
   group: string
   decimal: string
@@ -86,8 +200,18 @@ function isGroupedInteger(text: string, group: string): boolean {
  *
  * Returns `{ ok: false }` for anything that is not a non-negative number in `locale` — including a
  * negative one, which the contract has no way to mean and the old parser dropped in silence.
+ *
+ * `currency` decides how many decimal places the amount is allowed and what it is scaled by. More
+ * fractional digits than the currency has is a **rejection, not a rounding**: `19.99` in a yen
+ * field is not ¥20, it is somebody who has not noticed which field they are in, and quietly
+ * storing a number nobody typed is the whole class of failure this file exists to end. Omitting
+ * `currency` keeps two decimals, which is what an amount with no currency on it has always meant.
+ *
+ * The scaled integer is built by **concatenating digits**, never by multiplying: `19.99 * 100` is
+ * `1998.9999999999998` in a double, and the `Math.round` that used to hide it would have had to
+ * hide `1234.567 * 1000` too. Digits in, digits out, and no float on the path at all.
  */
-export function parsePrice(raw: string, locale: string): PriceResult {
+export function parsePrice(raw: string, locale: string, currency?: string | null): PriceResult {
   const text = toLatinDigits(raw).replace(BIDI, '').trim()
   if (!text) return { ok: true, minor: null }
 
@@ -103,11 +227,12 @@ export function parsePrice(raw: string, locale: string): PriceResult {
   if (!isGroupedInteger(whole, group)) return { ok: false }
   if (frac !== undefined && !/^\d+$/.test(frac)) return { ok: false }
 
-  const digits = group ? whole.split(group).join('') : whole
-  const value = Number(`${digits}.${frac ?? '0'}`)
-  if (!Number.isFinite(value)) return { ok: false }
+  const exponent = minorUnitExponent(currency)
+  // A currency with no minor unit has no decimal point either, so `frac` of any length fails here.
+  if (frac !== undefined && frac.length > exponent) return { ok: false }
 
-  const minor = Math.round(value * 100)
+  const digits = group ? whole.split(group).join('') : whole
+  const minor = Number(`${digits}${(frac ?? '').padEnd(exponent, '0')}`)
   // A price that cannot survive the round trip through a double is not a price anybody typed.
   if (!Number.isSafeInteger(minor)) return { ok: false }
   return { ok: true, minor }
@@ -119,17 +244,36 @@ export function parsePrice(raw: string, locale: string): PriceResult {
  * The edit form has to seed itself from `priceMinor`, and seeding it with `1234.56` for a German
  * reader would make them look at a number their own locale says is €123,456 — then `parsePrice`
  * would reject it on the grouping rule and they would be told their own data is invalid. What comes
- * out of here is exactly what goes back in.
+ * out of here is exactly what goes back in, for the currency the amount is in.
  */
-export function formatPrice(minor: number | null | undefined, locale: string): string {
+export function formatPrice(
+  minor: number | null | undefined,
+  locale: string,
+  currency?: string | null,
+): string {
   if (minor === null || minor === undefined) return ''
+  const exponent = minorUnitExponent(currency)
+  const value = minor / 10 ** exponent
   try {
     return new Intl.NumberFormat(locale, {
-      minimumFractionDigits: 2,
-      maximumFractionDigits: 2,
+      minimumFractionDigits: exponent,
+      maximumFractionDigits: exponent,
       useGrouping: false,
-    }).format(minor / 100)
+    }).format(value)
   } catch {
-    return String(minor / 100)
+    return String(value)
   }
 }
+
+/**
+ * The amount the "enter an amount like…" error holds up as an example.
+ *
+ * It has to be an amount the field would *accept*, or the error tells somebody to type something
+ * that is also rejected. `1234.56` was hard-coded, so a yen field said "Enter an amount like
+ * 1234.56" and then refused it. Built from the exponent instead: `1234` in yen, `1234.567` in
+ * dinars, and the reader's own separators and digits around it either way.
+ */
+export function priceExample(locale: string, currency?: string | null): string {
+  const exponent = minorUnitExponent(currency)
+  return formatPrice(Number(`1234${'567'.slice(0, exponent).padEnd(exponent, '0')}`), locale, currency)
+}

package/src/client/query.ts

@@ -15,6 +15,12 @@
  * the list and the dashboard card behind it stayed stale until a reload. Every other module keys
  * the list and the row off one singular entity name (`['tracker', 'issue', …]`); so does this one
  * now.
+ *
+ * **The timeline and the custody list hang off the asset's own key**, one segment deeper. That is
+ * what lets custody announce itself as `entity: 'asset'` and refresh all four things it changed —
+ * the row, the list, the detail panel and both of its tabs — from one change event, because
+ * `partialMatchKey` matches on the prefix. A separate `['inventory', 'custody', …]` would need the
+ * server to emit a second entity for the same write.
  */
 export const inventoryKeys = {
   /** Everything under this module, for the blunt invalidation after a write. */
@@ -22,4 +28,34 @@ export const inventoryKeys = {
   assets: (ws: string, filters?: Record<string, unknown>) =>
     filters ? (['inventory', 'asset', ws, filters] as const) : (['inventory', 'asset', ws] as const),
   asset: (ws: string, id: string) => ['inventory', 'asset', ws, id] as const,
+  /** The asset's own timeline. Under the asset, so one `asset` change refreshes it. */
+  assetHistory: (ws: string, id: string) => ['inventory', 'asset', ws, id, 'history'] as const,
+  /** Every custody period for one asset. Under the asset, for the same reason. */
+  assetCustody: (ws: string, id: string) => ['inventory', 'asset', ws, id, 'custody'] as const,
+  /** One asset's repairs. Under the asset, so a repair announced as an `asset` change refreshes it. */
+  assetRepairs: (ws: string, id: string) => ['inventory', 'asset', ws, id, 'repairs'] as const,
+  /** One asset's files, its repairs' included — the panel groups them, so there is one key. */
+  assetAttachments: (ws: string, id: string) => ['inventory', 'asset', ws, id, 'attachments'] as const,
+  /**
+   * The workspace's repairs, which belong to no single asset — the "what is away right now" card.
+   *
+   * Its own entity, because it cannot hang under one asset's key: `src/server/router.ts` therefore
+   * announces a repair twice, once as the asset that changed and once as the repair itself.
+   */
+  repairs: (ws: string, filters?: Record<string, unknown>) =>
+    filters ? (['inventory', 'repair', ws, filters] as const) : (['inventory', 'repair', ws] as const),
+  /**
+   * The register in numbers.
+   *
+   * Under the **asset** prefix on purpose, one segment deep: every number it holds is a count of
+   * assets, so every write that changes one of those counts already announces `entity: 'asset'` and
+   * this is refreshed by the same event. `'stats'` cannot collide with `asset(ws, id)` — that
+   * segment is always a uuid.
+   */
+  stats: (ws: string) => ['inventory', 'asset', ws, 'stats'] as const,
+  /**
+   * The workspace's categories. Its own entity because it has its own change event: a rename
+   * touches every asset row on screen, and `src/server/router.ts` therefore emits both.
+   */
+  categories: (ws: string, archived = false) => ['inventory', 'category', ws, { archived }] as const,
 }

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)
+}

package/src/client/repairs.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest'
+import { repairActions } from './repairs.js'
+
+/**
+ * What the Repairs section is allowed to offer.
+ *
+ * A decision rather than rendering, and wrong in a way nothing else would catch: a *Send for repair*
+ * button on an item that is already at a repairer produces a 409 every single time it is pressed —
+ * the unique index refuses the second open repair — so the interface must not offer it at all.
+ */
+describe('repairActions', () => {
+  it('offers sending it away when nothing is open', () => {
+    expect(repairActions({ open: false, archived: false, may: true })).toEqual(['create'])
+  })
+
+  it('offers completing and correcting while one is open, and never a second send', () => {
+    const actions = repairActions({ open: true, archived: false, may: true })
+    expect(actions).toEqual(['complete', 'edit'])
+    // The one combination that would conflict on every press.
+    expect(actions).not.toContain('create')
+  })
+
+  it('offers nothing without the permission — hidden, not disabled', () => {
+    expect(repairActions({ open: false, archived: false, may: false })).toEqual([])
+    expect(repairActions({ open: true, archived: false, may: false })).toEqual([])
+  })
+
+  it('offers nothing new on an archived item, which the server refuses anyway', () => {
+    expect(repairActions({ open: false, archived: true, may: true })).toEqual([])
+  })
+
+  it('keeps the way out of an open repair reachable even on an archived item', () => {
+    // Archiving is refused while a repair is open, so this state should be unreachable — and if
+    // the data ever says otherwise, hiding *complete* would leave the item stuck at `under_repair`
+    // for ever with no control that could finish it.
+    expect(repairActions({ open: true, archived: true, may: true })).toEqual(['complete', 'edit'])
+  })
+})