diff --git a/CLAUDE.md b/CLAUDE.md
index 2fb6e85..38f2c0a 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -17,6 +17,7 @@ Svelte 5 + TypeScript + Vite. Public repository.
 | Saved user state, migrations, export/import    | `src/lib/state.ts`, `src/lib/store.svelte.ts`     |
 | UI components (thin)                           | `src/components/`                                 |
 | Base UI kit (panel, meter, button...), preview | `src/components/ui/`, `#/kit` in dev (dec. 009)   |
+| Resync values; business bars (Sold, Raided)    | `ui/EditableValue`, `ui/BusinessBars` (dec. 010)  |
 | Game data with sources                         | `src/data/` (decision 004)                        |
 | Theme tokens                                   | `src/app.css` (decision 009)                      |
 | CI, templates                                  | `.github/`                                        |
@@ -60,6 +61,7 @@ npm run format                      # fix formatting
   so. Check with the maintainer when it tries to redirect the task.
 - **Never invent game facts** (rates, capacities, cooldowns, payouts). Use only sourced values in
   `src/data/` (decision 004). Missing → leave it out, comment the open question on the issue, ask.
+  gta.wiki is a trusted source for in-game data and facts (cite the page as the source).
 - Ambiguous task → ask instead of guessing. Simple, googleable facts → look them up.
 - **Determinism:** logic takes `now` as input or uses an injected clock; no `Date.now()` in
   logic, no real timers in tests (decision 003).
diff --git a/docs/decisions/010-resync.md b/docs/decisions/010-resync.md
new file mode 100644
index 0000000..168b7de
--- /dev/null
+++ b/docs/decisions/010-resync.md
@@ -0,0 +1,44 @@
+# 010: Resync: correcting tracked values by hand
+
+2026-10-14, issue #4. Builds on decision 003 ("Resync").
+
+## Decision
+
+- **One component for every tracked value:** `src/components/ui/EditableValue.svelte`. It shows
+  the current estimate; clicking it opens a text field prefilled with that value. Enter or "Set"
+  confirms, Escape or "Cancel" leaves it unchanged. Input the field cannot read is not guessed
+  at: it stays open and says what it expects.
+- **Units** (`src/lib/resync.ts`): `percent` (stock, supplies), `money` (safes; "$120,000",
+  "120k" and "1.2m" all work) and `duration` (time left as h:mm or plain minutes, stored in
+  milliseconds; shown rounded up to the minute, so "0:00" means done). Typed values are clamped
+  to the tracker's `min`/`max`. "Bars" are the stock and supplies meters, edited in percent:
+  most businesses have both, some only stock.
+- **The tracker owns "as of now".** The component calls `onresync(value)`; the tracker stores
+  it with its own clock and keeps counting from there (a play-time tracker sets its saved
+  progress, a real-time cooldown stores `now + timeLeft`). The component never reads a clock.
+- **Presets** are one-click values passed in by the tracker ("Full" sets a bar to 100%,
+  "Collected" empties a safe).
+- **Business bars** (`src/components/ui/BusinessBars.svelte`): stock and, if the business has
+  one, supplies, each an `EditableValue` with its meter, plus the business events "Sold"
+  (empties stock) and "Raided" (a successful police raid empties stock and supplies). Stock has
+  "Full". Raided is hidden for a business without supplies. Trackers pass the bars in percent
+  and store what comes back.
+- **Supplies bought** starts a delivery instead of filling at once: the bars keep
+  `suppliesDueAt` (wall-clock time), the panel counts down, and once due `settleBars` fills
+  supplies to 100%. Trackers store bars as set and settle them whenever they read them, so a
+  delivery that arrives while nobody looks still counts. The wait is 10 minutes for every
+  business and runs on real time for now; which clock the game uses is not confirmed. A raid
+  also cancels a delivery on its way.
+- What each event does, and the delivery, are game data in `src/data/business-events.ts`
+  (decision 004).
+- **Undo takes back the last edit or preset** of that value; in `BusinessBars` one Undo covers
+  the last change to either bar, events included. It subtracts what the edit changed
+  rather than restoring the old number, so progress counted since is kept: a cooldown mistyped
+  as 1:30 instead of 2:00 and undone ten minutes later shows 1:50. The undo lives in the
+  component for the session and is not saved.
+
+## Why
+
+Estimates drift (forgotten pause, disconnects, raids), so correcting a value must be one click
+and a number, everywhere, in the unit the game shows. Keeping the clock out of the component
+lets each tracker use its own clock (decision 003) and keeps the logic testable.
diff --git a/docs/decisions/README.md b/docs/decisions/README.md
index 16c651b..8a0c1c8 100644
--- a/docs/decisions/README.md
+++ b/docs/decisions/README.md
@@ -20,3 +20,4 @@ free number, add one line below. **Replacing one:** write a new decision, then m
 - [007](007-state-store.md) State store: unreadable data blocks saving like a newer version; import overrides
 - [008](008-clock-details.md) Clock details: session play time, opens paused (setting), throttled ticks counted, long gaps asked about
 - [009](009-terminal-design.md) Terminal look: tokens in `app.css`, self-hosted Oswald (OFL), browser-style tabs, base components in `src/components/ui/`
+- [010](010-resync.md) Resync: `EditableValue` for every tracked value, `BusinessBars` with Sold/Raided/Full and supply deliveries, undo keeps progress since
diff --git a/src/components/ui/BusinessBars.svelte b/src/components/ui/BusinessBars.svelte
new file mode 100644
index 0000000..f540786
--- /dev/null
+++ b/src/components/ui/BusinessBars.svelte
@@ -0,0 +1,119 @@
+<script lang="ts">
+  import { BUSINESS_EVENTS, SUPPLY_PURCHASE } from '../../data/business-events'
+  import {
+    applyEvent,
+    buySupplies,
+    formatValue,
+    settleBars,
+    undoBars,
+    type Bars,
+  } from '../../lib/resync'
+  import Button from './Button.svelte'
+  import Countdown from './Countdown.svelte'
+  import EditableValue from './EditableValue.svelte'
+  import Meter from './Meter.svelte'
+
+  interface Props {
+    /** Stock and supplies in percent; leave supplies out for a business with only a stock bar. */
+    bars: Bars
+    /** Wall-clock time, for supply deliveries (real time until confirmed, issue #4). */
+    now: number
+    /** Called with the corrected bars; the tracker stores them as of now (decision 003). */
+    onresync: (bars: Bars) => void
+  }
+
+  let { bars: stored, now, onresync }: Props = $props()
+
+  // The bars as of now, with an arrived delivery filled in. Every change starts from these.
+  const bars = $derived(settleBars(stored, now, SUPPLY_PURCHASE.fillsTo))
+  const dueAt = $derived(bars.suppliesDueAt)
+
+  const events = $derived(
+    Object.values(BUSINESS_EVENTS).filter(
+      (event) => bars.supplies !== undefined || !event.empties.includes('supplies'),
+    ),
+  )
+
+  // One undo for the whole business: the last edit, Full or event, whichever bars it changed.
+  let last = $state<{ before: Bars; after: Bars; label: string } | null>(null)
+
+  function set(after: Bars, label: string) {
+    if (
+      after.stock === bars.stock &&
+      after.supplies === bars.supplies &&
+      after.suppliesDueAt === bars.suppliesDueAt
+    )
+      return
+    last = { before: { ...bars }, after, label }
+    onresync(after)
+  }
+
+  function undo() {
+    if (!last) return
+    onresync(undoBars(last, bars))
+    last = null
+  }
+
+  const FULL = [{ label: 'Full', value: 100 }]
+
+  function buy() {
+    set(buySupplies(bars, now, SUPPLY_PURCHASE.deliveryMs), SUPPLY_PURCHASE.label)
+  }
+</script>
+
+<div class="bars">
+  <EditableValue
+    label="Stock"
+    value={bars.stock}
+    unit="percent"
+    min={0}
+    max={100}
+    presets={FULL}
+    undoable={false}
+    onresync={(stock) => set({ ...bars, stock }, `stock was ${formatValue(bars.stock, 'percent')}`)}
+  >
+    <Meter label="Stock" value={bars.stock} max={100} bare />
+  </EditableValue>
+  {#if bars.supplies !== undefined}
+    <EditableValue
+      label="Supplies"
+      value={bars.supplies}
+      unit="percent"
+      min={0}
+      max={100}
+      undoable={false}
+      onresync={(supplies) =>
+        set({ ...bars, supplies }, `supplies was ${formatValue(bars.supplies ?? 0, 'percent')}`)}
+    >
+      <Meter label="Supplies" value={bars.supplies} max={100} kind="supplies" bare />
+      {#if dueAt !== undefined}
+        <Countdown label="Supplies arrive in" remainingMs={dueAt - now} />
+      {/if}
+      <div class="actions">
+        <Button onclick={buy} disabled={dueAt !== undefined}>{SUPPLY_PURCHASE.label}</Button>
+      </div>
+    </EditableValue>
+  {/if}
+  <div class="actions">
+    {#each events as event (event.label)}
+      <Button onclick={() => set(applyEvent(bars, event), event.label)}>{event.label}</Button>
+    {/each}
+    {#if last}
+      <Button onclick={undo} title="Take back the last change ({last.label})">Undo</Button>
+    {/if}
+  </div>
+</div>
+
+<style>
+  .bars {
+    display: flex;
+    flex-direction: column;
+    gap: var(--space-3);
+  }
+
+  .actions {
+    display: flex;
+    flex-wrap: wrap;
+    gap: var(--space-2);
+  }
+</style>
diff --git a/src/components/ui/EditableValue.svelte b/src/components/ui/EditableValue.svelte
new file mode 100644
index 0000000..978888c
--- /dev/null
+++ b/src/components/ui/EditableValue.svelte
@@ -0,0 +1,238 @@
+<script lang="ts">
+  import { tick, type Snippet } from 'svelte'
+  import {
+    clampValue,
+    formatValue,
+    parseValue,
+    undoValue,
+    type Resync,
+    type ValueUnit,
+  } from '../../lib/resync'
+  import Button from './Button.svelte'
+  import Digits from './Digits.svelte'
+
+  interface Preset {
+    label: string
+    value: number
+  }
+
+  interface Props {
+    label: string
+    /** The tracker's current estimate, in the unit's base: percent, dollars or milliseconds. */
+    value: number
+    unit: ValueUnit
+    min?: number
+    max?: number
+    /** One-click values, e.g. "Sold" setting stock to 0. The tracker decides what each one means. */
+    presets?: Preset[]
+    /** Show an Undo button for the last edit. Off when the parent keeps one undo for several values. */
+    undoable?: boolean
+    /** Shown under the value, e.g. a bare Meter. */
+    children?: Snippet
+    /** Called with the corrected value; the tracker stores it as of now (decision 003). */
+    onresync: (value: number) => void
+  }
+
+  let {
+    label,
+    value,
+    unit,
+    min,
+    max,
+    presets = [],
+    undoable = true,
+    children,
+    onresync,
+  }: Props = $props()
+
+  const HINTS: Record<ValueUnit, string> = {
+    percent: 'A percentage, e.g. 40',
+    money: 'An amount, e.g. 120,000 or 120k',
+    duration: 'Time left as h:mm, e.g. 1:05',
+  }
+
+  const id = $props.id()
+  const bounds = $derived({ min, max })
+  const text = $derived(formatValue(value, unit))
+
+  let editing = $state(false)
+  let draft = $state('')
+  let invalid = $state(false)
+  let last = $state<Resync | null>(null)
+  let valueButton = $state<HTMLButtonElement>()
+  let input = $state<HTMLInputElement>()
+
+  async function startEditing() {
+    draft = text
+    invalid = false
+    editing = true
+    await tick()
+    input?.select()
+  }
+
+  async function stopEditing() {
+    editing = false
+    await tick()
+    valueButton?.focus()
+  }
+
+  function apply(next: number) {
+    const after = clampValue(next, bounds)
+    if (after === value) return
+    if (undoable) last = { before: value, after }
+    onresync(after)
+  }
+
+  function confirm(event: SubmitEvent) {
+    event.preventDefault()
+    const parsed = parseValue(draft, unit)
+    if (parsed === null) {
+      invalid = true
+      return
+    }
+    apply(parsed)
+    stopEditing()
+  }
+
+  function undo() {
+    if (!last) return
+    onresync(undoValue(last, value, bounds))
+    last = null
+  }
+</script>
+
+<div class="editable">
+  <div class="row">
+    <span class="label" id="{id}-label">{label}</span>
+    {#if editing}
+      <form class="edit" onsubmit={confirm}>
+        <input
+          bind:this={input}
+          bind:value={draft}
+          aria-labelledby="{id}-label"
+          aria-invalid={invalid}
+          aria-describedby="{id}-hint"
+          autocomplete="off"
+          inputmode={unit === 'duration' ? 'text' : 'decimal'}
+          oninput={() => (invalid = false)}
+          onkeydown={(event) => {
+            if (event.key === 'Escape') stopEditing()
+          }}
+        />
+        <Button variant="primary" type="submit">Set</Button>
+        <Button onclick={stopEditing}>Cancel</Button>
+      </form>
+    {:else}
+      <button
+        bind:this={valueButton}
+        type="button"
+        class="value"
+        aria-label="Resync {label}, now {text}"
+        title="Click to type the value from the game"
+        onclick={startEditing}><Digits {text} /></button
+      >
+    {/if}
+  </div>
+
+  {@render children?.()}
+
+  {#if editing}
+    <p class="hint" class:invalid id="{id}-hint" aria-live="polite">
+      {invalid ? `Not understood. ${HINTS[unit]}.` : HINTS[unit]}
+    </p>
+  {/if}
+
+  {#if presets.length > 0 || last}
+    <div class="actions">
+      {#each presets as preset (preset.label)}
+        <Button onclick={() => apply(preset.value)}>{preset.label}</Button>
+      {/each}
+      {#if last}
+        <Button
+          onclick={undo}
+          title="Take back the last edit (was {formatValue(last.before, unit)})">Undo</Button
+        >
+      {/if}
+    </div>
+  {/if}
+</div>
+
+<style>
+  .editable {
+    display: flex;
+    flex-direction: column;
+    gap: var(--space-2);
+  }
+
+  .row {
+    align-items: center;
+    display: flex;
+    flex-wrap: wrap;
+    gap: var(--space-2);
+    justify-content: space-between;
+  }
+
+  .label {
+    color: var(--muted);
+    font-family: var(--font-display);
+    font-size: var(--text-sm);
+    letter-spacing: var(--tracking);
+    text-transform: uppercase;
+  }
+
+  .value {
+    background: none;
+    border: 1px dashed var(--line);
+    border-radius: var(--radius);
+    color: var(--fg);
+    cursor: text;
+    font-family: var(--font-display);
+    font-size: var(--text-lg);
+    letter-spacing: var(--tracking);
+    padding: 0 var(--space-2);
+  }
+
+  .value:hover {
+    border-color: var(--accent);
+  }
+
+  .edit {
+    display: flex;
+    flex-wrap: wrap;
+    gap: var(--space-2);
+  }
+
+  input {
+    background: var(--surface);
+    border: 1px solid var(--line);
+    border-radius: var(--radius);
+    color: var(--fg);
+    font-family: var(--font-display);
+    font-size: var(--text-md);
+    letter-spacing: var(--tracking);
+    min-height: 2.25rem;
+    min-width: 0;
+    padding: 0 var(--space-2);
+    width: 8rem;
+  }
+
+  input[aria-invalid='true'] {
+    border-color: var(--danger);
+  }
+
+  .hint {
+    color: var(--muted);
+    font-size: var(--text-xs);
+    margin: 0;
+  }
+
+  .hint.invalid {
+    color: var(--danger);
+  }
+
+  .actions {
+    display: flex;
+    flex-wrap: wrap;
+    gap: var(--space-2);
+  }
+</style>
diff --git a/src/components/ui/Kit.svelte b/src/components/ui/Kit.svelte
index 875db6b..4654a17 100644
--- a/src/components/ui/Kit.svelte
+++ b/src/components/ui/Kit.svelte
@@ -1,13 +1,27 @@
 <script lang="ts">
   // Dev-only preview of the base components (open #/kit with `npm run dev`).
   // Sample numbers only: no game values here (decision 004).
+  import type { Bars } from '../../lib/resync'
+  import BusinessBars from './BusinessBars.svelte'
   import Button from './Button.svelte'
   import Countdown from './Countdown.svelte'
+  import EditableValue from './EditableValue.svelte'
   import Meter from './Meter.svelte'
   import NumberField from './NumberField.svelte'
   import Panel from './Panel.svelte'
 
   let amount = $state(40)
+  let safe = $state(70_000)
+  let bars = $state<Bars>({ stock: 60, supplies: 35 })
+  let stockOnly = $state<Bars>({ stock: 45 })
+
+  // A real-time cooldown, as a tracker would keep it: the moment it is ready.
+  let now = $state(Date.now())
+  let readyAt = $state(Date.now() + 90 * 60_000)
+  $effect(() => {
+    const timer = setInterval(() => (now = Date.now()), 1000)
+    return () => clearInterval(timer)
+  })
 </script>
 
 <div class="grid">
@@ -36,6 +50,36 @@
       onchange={(value) => (amount = value)}
     />
   </Panel>
+
+  <Panel title="Business bars">
+    <BusinessBars {bars} {now} onresync={(value) => (bars = value)} />
+  </Panel>
+
+  <Panel title="Stock only">
+    <BusinessBars bars={stockOnly} {now} onresync={(value) => (stockOnly = value)} />
+  </Panel>
+
+  <Panel title="Resync">
+    <EditableValue
+      label="Safe"
+      value={safe}
+      unit="money"
+      min={0}
+      presets={[{ label: 'Collected', value: 0 }]}
+      onresync={(value) => (safe = value)}
+    />
+    <EditableValue
+      label="Cooldown"
+      value={Math.max(0, readyAt - now)}
+      unit="duration"
+      min={0}
+      presets={[{ label: 'Ready', value: 0 }]}
+      onresync={(value) => {
+        now = Date.now()
+        readyAt = now + value
+      }}
+    />
+  </Panel>
 </div>
 
 <style>
diff --git a/src/components/ui/Meter.svelte b/src/components/ui/Meter.svelte
index 148a3ff..7d543f5 100644
--- a/src/components/ui/Meter.svelte
+++ b/src/components/ui/Meter.svelte
@@ -9,19 +9,23 @@
     kind?: 'stock' | 'supplies'
     /** Text shown next to the label, e.g. "40 / 100" or "$120,000". Defaults to a percentage. */
     valueText?: string
+    /** Only the bar, for when the label and value are shown next to it (e.g. by EditableValue). */
+    bare?: boolean
   }
 
-  let { label, value, max, kind = 'stock', valueText }: Props = $props()
+  let { label, value, max, kind = 'stock', valueText, bare = false }: Props = $props()
 
   const fraction = $derived(meterFraction(value, max))
   const text = $derived(valueText ?? `${Math.round(fraction * 100)}%`)
 </script>
 
 <div class="meter {kind}">
-  <div class="labels">
-    <span class="label">{label}</span>
-    <span class="value">{text}</span>
-  </div>
+  {#if !bare}
+    <div class="labels">
+      <span class="label">{label}</span>
+      <span class="value">{text}</span>
+    </div>
+  {/if}
   <div
     class="track"
     role="meter"
diff --git a/src/data/business-events.ts b/src/data/business-events.ts
new file mode 100644
index 0000000..3026599
--- /dev/null
+++ b/src/data/business-events.ts
@@ -0,0 +1,46 @@
+// What business events do to the stock and supplies bars (decision 004: every value sourced).
+
+export type Bar = 'stock' | 'supplies'
+
+export interface BusinessEvent {
+  label: string
+  /** Bars the event sets to zero. */
+  empties: Bar[]
+  /** Also cancels bought supplies that are still on their way. */
+  cancelsDelivery: boolean
+  source: string
+  checked: string
+}
+
+export const BUSINESS_EVENTS: Record<'sold' | 'raided', BusinessEvent> = {
+  sold: {
+    label: 'Sold',
+    empties: ['stock'],
+    cancelsDelivery: false,
+    source: 'Maintainer, from play (issue #4): selling empties the stock, supplies stay.',
+    checked: '2026-10-14',
+  },
+  raided: {
+    label: 'Raided',
+    empties: ['stock', 'supplies'],
+    cancelsDelivery: true,
+    source:
+      'Maintainer, from play (issue #4): a successful police raid zeroes stock and supplies ' +
+      'and cancels supplies still on their way.',
+    checked: '2026-10-14',
+  },
+}
+
+/** Buying supplies: they arrive after a delay and fill the supplies bar. */
+export const SUPPLY_PURCHASE = {
+  label: 'Supplies bought',
+  deliveryMs: 10 * 60_000,
+  /** Supplies after delivery, in percent. */
+  fillsTo: 100,
+  /** Not confirmed yet which clock the wait runs on; real time until it is (issue #4). */
+  clock: 'real' as const,
+  source:
+    'Maintainer, from play (issue #4): about 10 minutes for every business, then supplies are full. ' +
+    'Community wiki (gta.wiki, Business Supplies) also says about ten minutes for MC businesses.',
+  checked: '2026-10-14',
+}
diff --git a/src/lib/resync.test.ts b/src/lib/resync.test.ts
new file mode 100644
index 0000000..f7759f3
--- /dev/null
+++ b/src/lib/resync.test.ts
@@ -0,0 +1,152 @@
+import { describe, expect, it } from 'vitest'
+import {
+  applyEvent,
+  buySupplies,
+  clampValue,
+  formatValue,
+  parseValue,
+  settleBars,
+  undoBars,
+  undoValue,
+} from './resync'
+
+const MIN = 60_000
+
+describe('formatValue', () => {
+  it('shows percent, money and h:mm', () => {
+    expect(formatValue(39.6, 'percent')).toBe('40%')
+    expect(formatValue(1_234_567, 'money')).toBe('$1,234,567')
+    expect(formatValue(65 * MIN, 'duration')).toBe('1:05')
+  })
+
+  it('rounds time left up to the minute, so 0:00 means done', () => {
+    expect(formatValue(1, 'duration')).toBe('0:01')
+    expect(formatValue(59 * MIN + 1, 'duration')).toBe('1:00')
+    expect(formatValue(0, 'duration')).toBe('0:00')
+    expect(formatValue(-5 * MIN, 'duration')).toBe('0:00')
+  })
+})
+
+describe('parseValue', () => {
+  it('reads percent with or without the sign', () => {
+    expect(parseValue('40', 'percent')).toBe(40)
+    expect(parseValue(' 12.5 % ', 'percent')).toBe(12.5)
+  })
+
+  it('reads money as the game or a person writes it', () => {
+    expect(parseValue('120000', 'money')).toBe(120_000)
+    expect(parseValue('$120,000', 'money')).toBe(120_000)
+    expect(parseValue('120k', 'money')).toBe(120_000)
+    expect(parseValue('1.2M', 'money')).toBe(1_200_000)
+  })
+
+  it('reads h:mm or plain minutes as milliseconds', () => {
+    expect(parseValue('1:05', 'duration')).toBe(65 * MIN)
+    expect(parseValue('0:7', 'duration')).toBe(7 * MIN)
+    expect(parseValue('45', 'duration')).toBe(45 * MIN)
+    expect(parseValue('0', 'duration')).toBe(0)
+  })
+
+  it('rejects empty, negative or malformed input', () => {
+    for (const unit of ['percent', 'money', 'duration'] as const) {
+      expect(parseValue('', unit)).toBeNull()
+      expect(parseValue('-5', unit)).toBeNull()
+      expect(parseValue('abc', unit)).toBeNull()
+    }
+    expect(parseValue('1e3', 'percent')).toBeNull()
+    expect(parseValue('$', 'money')).toBeNull()
+    expect(parseValue('1:60', 'duration')).toBeNull()
+    expect(parseValue('1:2:3', 'duration')).toBeNull()
+  })
+})
+
+describe('clampValue', () => {
+  it('keeps the value inside the bounds', () => {
+    expect(clampValue(120, { min: 0, max: 100 })).toBe(100)
+    expect(clampValue(-1, { min: 0 })).toBe(0)
+    expect(clampValue(5)).toBe(5)
+  })
+})
+
+describe('undoValue', () => {
+  it('restores the old value right after the edit', () => {
+    expect(undoValue({ before: 40, after: 4 }, 4)).toBe(40)
+  })
+
+  it('keeps what the tracker counted since the edit', () => {
+    // Cooldown estimated at 2:00, mistyped as 1:30; 10 minutes later it shows 1:20.
+    const edit = { before: 120 * MIN, after: 90 * MIN }
+    expect(undoValue(edit, 80 * MIN)).toBe(110 * MIN)
+  })
+
+  it('clamps to the bounds', () => {
+    expect(undoValue({ before: 90, after: 10 }, 30, { max: 100 })).toBe(100)
+    expect(undoValue({ before: 0, after: 50 }, 20, { min: 0 })).toBe(0)
+  })
+})
+
+describe('applyEvent', () => {
+  const sold = { empties: ['stock'] as const, cancelsDelivery: false }
+  const raided = { empties: ['stock', 'supplies'] as const, cancelsDelivery: true }
+
+  it('empties the listed bars and keeps the rest', () => {
+    expect(applyEvent({ stock: 80, supplies: 40 }, sold)).toEqual({ stock: 0, supplies: 40 })
+    expect(applyEvent({ stock: 80, supplies: 40 }, raided)).toEqual({
+      stock: 0,
+      supplies: 0,
+    })
+  })
+
+  it('does not add a supplies bar to a business without one', () => {
+    expect(applyEvent({ stock: 80 }, raided)).toEqual({ stock: 0 })
+  })
+
+  it('drops a pending delivery only if the event cancels it', () => {
+    const pending = { stock: 80, supplies: 40, suppliesDueAt: 5 }
+    expect(applyEvent(pending, sold)).toEqual({ stock: 0, supplies: 40, suppliesDueAt: 5 })
+    expect(applyEvent(pending, raided)).toEqual({ stock: 0, supplies: 0 })
+  })
+})
+
+describe('undoBars', () => {
+  it('takes back a raid and keeps what changed since', () => {
+    const edit = { before: { stock: 80, supplies: 40 }, after: { stock: 0, supplies: 0 } }
+    expect(undoBars(edit, { stock: 0, supplies: 0 })).toEqual({ stock: 80, supplies: 40 })
+    expect(undoBars(edit, { stock: 5, supplies: 20 })).toEqual({ stock: 85, supplies: 60 })
+  })
+
+  it('clamps each bar to 0..100 and leaves untouched bars alone', () => {
+    const edit = { before: { stock: 90, supplies: 50 }, after: { stock: 10, supplies: 50 } }
+    expect(undoBars(edit, { stock: 30, supplies: 45 })).toEqual({ stock: 100, supplies: 45 })
+  })
+})
+
+describe('buying supplies', () => {
+  const T = 1_000_000
+  const DELIVERY = 10 * MIN
+
+  it('schedules a delivery and changes nothing until it arrives', () => {
+    const bought = buySupplies({ stock: 20, supplies: 5 }, T, DELIVERY)
+    expect(bought).toEqual({ stock: 20, supplies: 5, suppliesDueAt: T + DELIVERY })
+    expect(settleBars(bought, T + DELIVERY - 1, 100)).toBe(bought)
+  })
+
+  it('fills supplies once the delivery is due', () => {
+    const bought = buySupplies({ stock: 20, supplies: 5 }, T, DELIVERY)
+    expect(settleBars(bought, T + DELIVERY, 100)).toEqual({ stock: 20, supplies: 100 })
+  })
+
+  it('does nothing for a business without supplies', () => {
+    expect(buySupplies({ stock: 20 }, T, DELIVERY)).toEqual({ stock: 20 })
+  })
+
+  it('undo cancels a pending delivery and restores one an edit replaced', () => {
+    const before = { stock: 20, supplies: 5 }
+    const after = buySupplies(before, T, DELIVERY)
+    expect(undoBars({ before, after }, after)).toEqual(before)
+
+    const pending = { stock: 20, supplies: 5, suppliesDueAt: T }
+    const raided = { stock: 0, supplies: 0 }
+    expect(undoBars({ before: pending, after: raided }, raided)).toEqual(pending)
+  })
+})
diff --git a/src/lib/resync.ts b/src/lib/resync.ts
new file mode 100644
index 0000000..69baa64
--- /dev/null
+++ b/src/lib/resync.ts
@@ -0,0 +1,147 @@
+// Resync: correcting a tracked value by hand (decision 003, decision 010).
+// The tracker stores the typed value as of now and keeps counting from there; this module only
+// parses, formats and undoes what the user types.
+
+/** percent: stock and supplies. money: safes, in dollars. duration: time left, in milliseconds. */
+export type ValueUnit = 'percent' | 'money' | 'duration'
+
+export interface ValueBounds {
+  min?: number
+  max?: number
+}
+
+/** One confirmed edit: the value shown just before it, and the value it set. */
+export interface Resync {
+  before: number
+  after: number
+}
+
+const MINUTE_MS = 60_000
+
+export function clampValue(value: number, { min, max }: ValueBounds = {}): number {
+  if (min !== undefined) value = Math.max(min, value)
+  if (max !== undefined) value = Math.min(max, value)
+  return value
+}
+
+/**
+ * Text for a value in its unit: "40%", "$120,000", "1:05" (h:mm). Time left is rounded up to the
+ * minute, so "0:00" only shows once it is done.
+ */
+export function formatValue(value: number, unit: ValueUnit): string {
+  switch (unit) {
+    case 'percent':
+      return `${Math.round(value)}%`
+    case 'money':
+      return `$${Math.round(value).toLocaleString('en-US')}`
+    case 'duration': {
+      const minutes = Math.ceil(Math.max(0, value) / MINUTE_MS)
+      return `${Math.floor(minutes / 60)}:${String(minutes % 60).padStart(2, '0')}`
+    }
+  }
+}
+
+/**
+ * Reads what the user typed, as the game shows it. Returns null for anything that is not a
+ * non-negative value in that unit, so the field can say so instead of guessing.
+ *
+ * - percent: "40" or "40%"
+ * - money: "120000", "$120,000", "120k", "1.2m"
+ * - duration: "1:05" (h:mm) or "45" (minutes); returns milliseconds
+ */
+export function parseValue(text: string, unit: ValueUnit): number | null {
+  const trimmed = text.trim().toLowerCase()
+  switch (unit) {
+    case 'percent':
+      return nonNegative(trimmed.replace(/\s*%$/, ''))
+    case 'money': {
+      const match = /^\$?\s*([\d.,]+)\s*([km]?)$/.exec(trimmed)
+      if (!match) return null
+      const amount = nonNegative((match[1] ?? '').replaceAll(',', ''))
+      if (amount === null) return null
+      const factor = match[2] === 'k' ? 1_000 : match[2] === 'm' ? 1_000_000 : 1
+      return Math.round(amount * factor)
+    }
+    case 'duration': {
+      const clock = /^(\d+):(\d{1,2})$/.exec(trimmed)
+      if (clock) {
+        const minutes = Number(clock[2])
+        if (minutes > 59) return null
+        return (Number(clock[1]) * 60 + minutes) * MINUTE_MS
+      }
+      const minutes = nonNegative(trimmed)
+      return minutes === null ? null : Math.round(minutes * MINUTE_MS)
+    }
+  }
+}
+
+function nonNegative(text: string): number | null {
+  if (!/^\d*\.?\d+$|^\d+\.$/.test(text)) return null
+  return Number(text)
+}
+
+/**
+ * The value to set when undoing `edit`, given the value shown now. Takes back what the edit
+ * changed and keeps what the tracker counted since, so undoing a mistyped cooldown a few minutes
+ * later still lands where the old estimate would be now.
+ */
+export function undoValue(edit: Resync, current: number, bounds: ValueBounds = {}): number {
+  return clampValue(current - (edit.after - edit.before), bounds)
+}
+
+/** A business's bars in percent. Some businesses have only a stock bar. */
+export interface Bars {
+  stock: number
+  supplies?: number
+  /** Wall-clock time bought supplies arrive, while a delivery is on its way. */
+  suppliesDueAt?: number
+}
+
+const PERCENT: ValueBounds = { min: 0, max: 100 }
+
+/**
+ * The bars after an event such as a sale or a raid: the bars it empties go to zero, and a
+ * delivery on its way is dropped if the event cancels it.
+ */
+export function applyEvent(
+  bars: Bars,
+  event: { empties: readonly ('stock' | 'supplies')[]; cancelsDelivery: boolean },
+): Bars {
+  const next = { ...bars }
+  for (const bar of event.empties) if (next[bar] !== undefined) next[bar] = 0
+  if (event.cancelsDelivery) delete next.suppliesDueAt
+  return next
+}
+
+/** The bars after buying supplies at `now`: a delivery arrives `deliveryMs` later. */
+export function buySupplies(bars: Bars, now: number, deliveryMs: number): Bars {
+  if (bars.supplies === undefined) return bars
+  return { ...bars, suppliesDueAt: now + deliveryMs }
+}
+
+/**
+ * The bars as of `now`: a delivery that has arrived fills supplies to `fillsTo` and is done.
+ * Trackers store bars as they were set and settle them whenever they read them.
+ */
+export function settleBars(bars: Bars, now: number, fillsTo: number): Bars {
+  if (bars.suppliesDueAt === undefined || now < bars.suppliesDueAt) return bars
+  const { suppliesDueAt: _, ...rest } = bars
+  return rest.supplies === undefined ? rest : { ...rest, supplies: fillsTo }
+}
+
+/** `undoValue` for each bar, for an edit or event that changed several at once. */
+export function undoBars(edit: { before: Bars; after: Bars }, current: Bars): Bars {
+  const next = { ...current }
+  if (edit.before.suppliesDueAt !== edit.after.suppliesDueAt) {
+    if (edit.before.suppliesDueAt === undefined) delete next.suppliesDueAt
+    else next.suppliesDueAt = edit.before.suppliesDueAt
+  }
+  for (const bar of ['stock', 'supplies'] as const) {
+    const before = edit.before[bar]
+    const after = edit.after[bar]
+    const now = current[bar]
+    if (before === undefined || after === undefined || now === undefined) continue
+    next[bar] = undoValue({ before, after }, now, PERCENT)
+  }
+  return next
+}