DEPOT/i — Distribution & Warehouse Management

DEPOT/i is a distribution-centre warehouse management application: a warehouse and bin/location master, stock held by (item, location, lot), inbound receiving and put-away, wave pick release and pick confirmation, despatch, cycle counting, bin-to-bin replenishment, stock valuation and a monthly GL post. Its central discipline is that stock only ever moves — a put-away, a pick and a replenishment each take quantity out of one bin and put the same quantity into another, so the sum of on-hand across all bins for an item is conserved; only receiving (from outside), despatch (to outside) and a count variance change that total, and each writes a signed movement-ledger row that explains the delta exactly. This manual is the reference for the operator who runs the online screens and the periodic job cycles, and for the developer maintaining the application. It is grounded entirely in the committed source (wms-app/src/sources.mjs, seed.mjs, and the test/wh_*.mjs drivers). Everything runs in library DEPOT.

A. Overview & Architecture ↑ top

A.1 What it does

DEPOT/i runs the full physical flow of a distribution centre:

• Receiving & put-away — walk the open receipt lines booked at the dock, decide a put-away bin (honour an explicit bin, else segregate hazmat to a dedicated rack), move the quantity off the dock into a storage bin respecting the bin's capacity, and journal both sides of the move.
• Wave pick release — take every open despatch order, allocate its lines against pickable stock in forward pick faces first (FEFO, earliest expiry lot first), and write one pick instruction per (order line, source bin) in aisle-walk sequence. Allocation reserves stock without moving it.
• Pick confirmation — the stock physically leaves the pick face and arrives in the staging lane; the reservation is released and the order line records what was picked.
• Despatch — load fully-picked orders onto the carrier; the staged quantity leaves the building and a signed ledger row records exactly what shipped.
• Weekly replenishment & slow-mover review — top a pick face that has fallen below its minimum back up towards its maximum from a reserve bin (rounded up to whole case packs), and re-rank every item's ABC class by shipped throughput.
• Monthly close — post cycle-count variances, value the stock split by location type, and post balanced DR/CR pairs into the SQL GL feed.
• Annual physical inventory & re-slot — count the building wall to wall, correct the book, and stamp each item's velocity class onto the pick faces that hold it so next year's picking walks the fast movers first.

A.2 The conservation invariant

The one property the whole application is built around, and the one the test suites assert at every step, is that a warehouse move conserves stock. Formally: for any item, the sum of WHSTK.SQTY over all bins is unchanged by a put-away, a pick, a pick-confirm or a replenishment — each takes quantity from one bin and gives the same quantity to another. Exactly three events change the site total, and each writes a signed row into the movement ledger WHMOVE that accounts for the delta:

• Receiving — a put-away's ledger row names MFROM (the dock) and MTO (the bin); the goods were already booked to the dock, so put-away is internal and the total does not change. A genuine external receipt into the site is the inbound booking that placed stock on the dock in the first place.
• Despatch — a 'D' row with MQTY negative, MFROM the staging lane and MTO blank (it left the building). This is the one daily step that legitimately reduces the total.
• Count variance — a 'A' (cycle-count) or 'Y' (physical) row with a signed MQTY and both MFROM and MTO blank: nothing moved, the book was wrong.

The COBOL reconciliation report WHMOVRP is the arbiter: it sums the ledger by type and shows the internal moves netting the site's flows, so any cycle's effect on the balance is provable after the fact.

A.3 Component & flow

  DAILY  (WHDAILY)              WEEKLY (WHWEEK)        MONTHLY (WHMONTH)     ANNUAL (WHYEAR)
  -------------------          ---------------        -----------------     ---------------
  WHPUTWY  receive/put-away    WHREPL   replenish     WHCNTPS  count post   WHPHYS   physical
  WHWAVE   pick release        WHSLOW   ABC re-rank    WHVALUE  valuation    WHRESLT  re-slot
  WHPCKPR  print pick list     WHMOVRP  reconcile      WHGLPST  GL post      WHVALUE  valuation
  WHPKCFM  pick confirm                                WHMOVRP  reconcile    WHMOVRP  reconcile
  WHDSPCH  despatch

  ONLINE (WHMENU)
    1 -> WHSTKIQ  stock inquiry (plain DSPF over WHSTK/WHITEM/WHLOC)
    2 -> WHPCKIQ  wave pick-list inquiry (SUBFILE over WHPICK)

              every posting program --writes--> WHMOVE (movement ledger, one accumulating history)
   WHRCPT --> WHSTK <-- WHORD/WHORDL --> WHPICK --> WHSTK(staging) --> out
             ^   \                                                     WHGLFEED (SQL GL feed)
   WHLOC ----+    +-- WHSTKLF (by-location LF)   WHPCKLF (by-status pick LF)
   WHITEM ---+

A daily flow runs: WHPUTWY moves receipts off the dock into bins → WHWAVE reserves pick-face stock against open orders and writes pick lines → WHPCKPR prints the floor's pick list → WHPKCFM moves the picked stock to the staging lane and releases the reservation → WHDSPCH ships the staged stock and posts the negative ledger rows. Every quantity change writes a WHMOVE row.

A.4 Object inventory

The full catalogue is 10 physical files + 2 logical files + 3 display files + 1 printer file + 1 SQL table (and its index), driven by 16 RPG programs, 1 ILE COBOL program and 5 CL programs. Sections D and F expand each.

B. Online Transactions & Screens ↑ top

B.1 The command/entry line

DEPOT/i has no CICS transaction identifiers and no menu-driven transid switch. On IBM i, each program is reached by name from a 5250 command-entry line, from the WHMENU menu, or from a JOBQ/scheduler for the batch jobs. Before invoking anything, the job's library list must include DEPOT — the tested jobs run with LIBL = QSYS QGPL DEPOT QTEMP and CURLIB = DEPOT. The one-time WHSETUP creates the objects and compiles the programs; WHREFLD seeds the reference data.

The batch drivers take no CALL parameters; a scheduled submission is a bare CALL. Only WHMENU, WHSTKIQ and WHPCKIQ are interactive; every batch program runs to completion and DSPLYs a one-line summary per step.

B.2 Menu & the two inquiry screens

WHMENU (over WHMENUD) is a plain menu: option 1 CALLs WHSTKIQ, option 2 CALLs WHPCKIQ, any other non-blank value shows “Invalid option.”; F3 exits. Both inquiries are read-only — the online layer inspects stock and picks, it does not post movements.

Stock Inquiry — WHSTKIQ / WHSTKD (plain DSPF)

Key an item number and a location; the screen chains the item master (description, unit cost) and the location master (bin type, zone), then walks that item's stock rows for the named bin and shows the on-hand, allocated and the derived pickable figure (SQTY − SALLOC).

Wave Pick List Inquiry — WHPCKIQ / WHPCKD (subfile)

The app's subfile screen. Key a wave number; the program clears the subfile and reloads it from WHPICK for that wave (record PSFL under control PCTL, SFLPAG(5) per page, SFLSIZ(20), ROLLUP/ROLLDOWN paging and SFLEND(*MORE)). It totals the pick lines, units and open-line count into the header fields.

B.3 Controls & audit workflow (no four-eyes maker–checker)

Honest statement: DEPOT/i does not model a true four-eyes maker–checker / separate-authorization workflow, and it has no user-level security or approval gate in the application code: a batch step posts its movements the moment it runs, and the online screens are read-only. The manual documents the control model the application does have:

• Movement ledger (WHMOVE). Every quantity change to WHSTK writes a durable ledger row naming the type, quantity, both bins (where applicable), a business reference and a memo. It is the after-the-fact accountability trail and the arbiter of the conservation invariant.
• Idempotency by stable business key. Every posting program derives its ledger key from a stable business key (receipt+line, wave+pick, order+line, item, count-sheet+line, …) in a disjoint numeric range per program, and guards each write with CHAIN(EN): a re-run regenerates the same key and the guard refuses it rather than double-posting. This is what makes the whole daily chain safely re-runnable (the tests assert the ledger gains no rows on a second WHDAILY).
• Status gating. Each program acts only on rows in the right state and skips the rest: WHPUTWY only puts away receipts in RSTAT='O' (then flips to 'P'); WHWAVE only releases orders in OSTAT='O'; WHPKCFM only confirms picks in PSTAT='O'; WHDSPCH only ships orders whose lines are all fully picked; WHCNTPS only posts count lines in CSTAT='O'.
• Capacity & policy enforcement. Put-away refuses to overfill a bin (the line stays open and is counted a reject); hazmat items are segregated to the dedicated rack; picking draws only from forward pick faces; replenishment moves only in whole case packs.
• Balanced GL. The monthly GL post writes balanced DR/CR pairs and only counts an insert that actually succeeded (if sqlcod = 0), so a refused duplicate never inflates the row count — the feed's SUM(DR) = SUM(CR).

In sum, the control posture is durable movement audit + stable-key idempotency + status/state gating + capacity/policy enforcement, rather than a segregation-of-duties approval workflow or a security model.

C. Batch Jobs & the Periodic Cycle ↑ top

DEPOT/i's work runs as four periodic cycles, each packaged as a CL program that adds DEPOT to the library list and CALLs its steps in order: a daily receive-pick-ship chain, a weekly replenishment + slow-mover review, a monthly count-variance close + valuation + GL post, and an annual wall-to-wall physical inventory + pick-face re-slot. Every batch program takes no CALL parameters and stamps hard-coded processing dates (see B.1).

-- run a cycle interactively, or submit it as a batch job
CALL DEPOT/WHDAILY
SBMJOB CMD(CALL PGM(DEPOT/WHDAILY)) JOB(WHDAILY)

C.1 Full batch program set

C.2 Daily / weekly / monthly / annual detail

Daily — WHDAILY (WHPUTWY → WHWAVE → WHPCKPR → WHPKCFM → WHDSPCH)

WHPUTWY walks the open receipt lines. Put-away policy is deterministic: honour an explicit RPUTLOC; else send a hazmat item to C-09-01 (the segregated rack) and everything else to B-05-01 (the default reserve). It sums what is already in the target bin through the location-keyed WHSTKLF path and refuses to overfill (LCAP); it takes the quantity off the dock, adds it into the bin (creating the row if new), writes a 'P' ledger row naming both bins, and flips the receipt to RSTAT='P'. WHWAVE allocates each open order's lines against forward-pick-face stock only, reserving via SALLOC (never moving SQTY), and writes one pick row per source in aisle-walk (LSEQ) order. WHPCKPR prints that wave. WHPKCFM confirms each open pick — SQTY falls in the pick face and rises in the staging lane by the same amount, SALLOC is released, a 'K' ledger row is written, the order line's OPICKQ rolls up. WHDSPCH ships every order whose lines are all fully picked: it draws the quantity off the staging lane, writes a negative 'D' ledger row (MTO blank), and rolls the header to OSTAT='D'.

Expected DSPLY (the wh_daily scenario: receipt R0000101 + order OR000501):
  WHPUTWY PUTAWAY=2 SKIP=0 REJECT=0
  WHWAVE  WAVE=8001 PICKS=2 SHORT=0 SKIP=0
  WHPCKPR LINES=2 UNITS=50
  WHPKCFM CONFIRMED=2 UNITS=50 SKIP=0
  WHDSPCH ORDERS=1 LINES=2 SKIP=0        WG total 840 -> 810, GZ 250 -> 230

Weekly — WHWEEK (WHREPL → WHSLOW → WHMOVRP)

WHREPL walks the item master. For each active item it sums what sits in forward pick faces; if that total is below IMINQ it computes the gap to IMAXQ, rounds it up to a whole case pack (IPKQTY — a picker moves cartons), finds a reserve bin holding that lot with enough free stock, and moves the quantity down (out of reserve, into the pick face), writing a 'T' ledger row naming both bins. It is a pure internal move — the total is unchanged. WHSLOW re-ranks each item's ABC class by units actually shipped ('D' ledger rows): ≥40 → A, ≥10 → B, else C (slow mover). WHMOVRP reconciles the ledger.

Expected DSPLY (the wh_cycles weekly scenario):
  WHREPL MOVED=2 SKIP=...              WG face 20+108=128 (reserve 500-108=392);
  WHSLOW A=1 B=1 C=...                SP face 10+250=260 (reserve 300-250=50)
  WHMOVRP INTERNAL   358.00           108 + 250 units moved internally
  WHMOVRP SHIPPED    -57.00           -45 + -12 shipped

Monthly — WHMONTH (WHCNTPS → WHVALUE → WHGLPST → WHMOVRP)

WHCNTPS posts each open count sheet line: it compares the counted quantity against the book quantity in that bin now, and if they differ corrects SQTY and writes a signed 'A' ledger row (both bins blank — nothing moved). A zero-variance line is left open, not falsely posted. WHVALUE values every stock row at the item's unit cost and reports the total split by location type (reserve / forward / staged — staged stock is already committed revenue). WHGLPST totals the ledger by type, values it at cost, and posts balanced DR/CR pairs into WHGLFEED, continuing the GLSEQ sequence and posting only the movement since the last close. WHMOVRP reconciles.

Expected figures (the wh_cycles monthly scenario):
  WHCNTPS ADJUSTED=1 NET=-3            counted bin 128 -> 125
  WHVALUE RESERVE=6209.50 FORWARD=1832.50 STAGED=...
  GL: 5000-CGS (CGS)   445.50         45x3.5000 + 12x24.0000
      5900-SHR (shrink) 10.50         3 units short x 3.5000
      1400-INV credited 456.00        445.50 shipped + 10.50 shrunk; SUM(DR)=SUM(CR)

Annual — WHYEAR (WHPHYS → WHRESLT → WHVALUE → WHMOVRP)

WHPHYS counts the building. Its deterministic convention: every stocked reserve bin counts 1 unit short (pallet-face shrinkage), every other bin clean; it corrects the book and writes a signed 'Y' ledger row (both bins blank). WHRESLT stamps each item's velocity class (IABC) onto the pick-face bins holding it, but only ever upgrades a slot (A beats B beats C) so a shared bay is deterministic and re-runs are stable; it writes an 'S' ledger row per re-slotted item. WHVALUE re-values, WHMOVRP reconciles.

Expected DSPLY (the wh_cycles annual scenario):
  WHPHYS   ADJUSTED=3 NET=-3          3 reserve bins each -1 (392->391, 200->199, 50->49)
  WHRESLT  RESLOTTED=2 SKIP=...       pick faces re-slotted to the faster class

C.3 Ordering & dependencies

• Within the daily chain the order is fixed and matters: put-away must precede the wave (stock must be in bins), the wave must precede pick-confirm (there must be pick rows), pick-confirm must precede despatch (the goods must be staged and the lines fully picked). WHPCKPR is a report and can print any time after the wave.
• Within the weekly chain replenishment precedes the slow-mover re-rank precedes the report; the re-rank reads shipped-throughput history from the ledger, so it depends on the daily despatches having posted their 'D' rows.
• Within the monthly chain the count post precedes valuation (so the value reflects corrected books) precedes the GL post (which reads the whole ledger) precedes the reconciliation.
• Within the annual chain the physical count precedes the re-slot (which reads the ABC class the weekly runs assigned) precedes the re-value and reconcile.
• Across cycles: the ABC classes WHRESLT uses are set by WHSLOW in the weekly cycle, which in turn depends on the daily despatch history — run the dailies and weeklies of the year before the annual re-slot.

D. Data Files (data dictionary) ↑ top

All files are in library DEPOT, grounded in the DDS/SQL members of sources.mjs. Dates are stored as zoned/packed integers in YYYYMMDD form; money is DECIMAL (unit cost is 11P4, to fractions of a cent). Field types are shown in DDS notation: A=alphanumeric, P=packed decimal, S=zoned decimal.

WHLOC — Location (bin) master (K WHSE, LOCID)

Seeded set: 1 dock (DOCK-IN-01), 2 forward pick faces (A-01-01 LSEQ 100, A-01-02 LSEQ 110), 3 reserve racks (B-05-01/02, C-09-01), 1 staging lane (SHIP-LN-01). Pick faces walk before reserve racks.

WHITEM — Item master (K ITEMNO)

WHSTK — Stock by (item, location, lot) (K ITEMNO, LOCID, LOTNO)

The heart of the system. The composite key is why the same item lives in many bins and the same bin holds several lots. Pickable = SQTY − SALLOC.

WHSTKLF is a logical file over WHSTK keyed LOCID-first then ITEMNO, LOTNO — the by-location access path (“what is in this bin?”), non-unique on LOCID by design.

WHRCPT — Inbound receipt lines (K RCPTNO, RSEQ)

WHORD / WHORDL — Despatch order header / lines

WHPICK — Wave pick instructions (K WAVENO, PSEQ)

WHPCKLF is a logical file over WHPICK keyed PSTAT-first — the by-status access path (read only the open picks to confirm, the confirmed ones to despatch).

WHMOVE — Movement ledger (K MSEQ, UNIQUE)

The durable audit trail and the arbiter of conservation. Every WHSTK quantity change writes one row. MSEQ is a stable, disjoint-per-program key (see F.2), so all programs accumulate into one history and re-runs are refused.

WHCNT — Cycle-count sheets (K CSHEET, CSEQ)

WHCARR — Carrier master (K CARRCD)

WHGLFEED — SQL GL feed (PK GLSEQ)

Index WHGLFACC on (ACCT, DRCR) supports the “posted-to-date” sums WHGLPST reads to post only the incremental movement each close.

Relationships

• WHSTK.ITEMNO → WHITEM.ITEMNO; WHSTK.(WHSE,LOCID) → WHLOC (item + bin masters).
• WHRCPT drives put-away, which creates/updates WHSTK and writes WHMOVE ('P').
• WHORD/WHORDL drive WHWAVE, which writes WHPICK and reserves WHSTK.SALLOC.
• WHPICK drives WHPKCFM, which moves WHSTK and writes WHMOVE ('K'); then WHDSPCH ships and writes WHMOVE ('D').
• WHCNT drives WHCNTPS; WHMOVE feeds WHSLOW (ABC), WHVALUE (via WHITEM cost) and WHGLPST (WHGLFEED).
• WHSTKLF / WHPCKLF are alternate access paths (no data of their own).

E. Operations Runbook ↑ top

E.1 Day-in-the-life

1. One-time build: CALL DEPOT/WHSETUP then CALL DEPOT/WHREFLD; confirm the “setup complete” banner and that WHREFLD reports LOCS=7 ITEMS=5 CARRIERS=2.
2. Book the day's inbound receipts into WHRCPT (RSTAT=O) and the day's despatch orders into WHORD/WHORDL (OSTAT=O).
3. Submit the daily cycle: SBMJOB CMD(CALL PGM(DEPOT/WHDAILY)).
4. Post-check the daily run (below), and use WHSTKIQ / WHPCKIQ to inspect a bin or a wave as questions arise.

Pre-checks: confirm the job's library list includes DEPOT; confirm receipts are RSTAT='O' and orders OSTAT='O' (anything else is skipped).

Post-checks after the daily cycle:

• WHPUTWY PUTAWAY= equals your open receipt lines; REJECT= should be 0 (a non-zero reject means a bin would overfill — the line is left open).
• WHWAVE PICKS= equals the order lines that found pick-face stock; SHORT= counts lines that could not be fully allocated from pick faces.
• WHPKCFM UNITS= equals the picked total; the picked stock is now in SHIP-LN-01 and each pick face fell by exactly what was picked, with SALLOC back to 0.
• WHDSPCH LINES= equals the shipped lines; the staging lane is empty and the site total fell by exactly the shipped quantity (the only step that reduces it).
• Every WHMOVE.MSEQ is unique — the durable audit trail holds (a regression guard the tests verify).

E.2 Month-end & annual close

1. Weekly, through the month: submit WHWEEK — replenish pick faces and re-rank ABC. Confirm WHREPL MOVED= matches the items below their pick-face minimum and WHMOVRP INTERNAL equals the replenished units (a pure internal move).
2. Month-end: raise cycle-count sheets in WHCNT (CSTAT=O), then submit WHMONTH. Confirm WHCNTPS ADJUSTED=/NET=, the WHVALUE split, and that the GL feed is balanced.
3. Reconcile the GL: SUM(DR) must equal SUM(CR) and be non-zero; the feed row count is even (every posting is a pair).
4. Year-end: submit WHYEAR — physical count, re-slot, re-value, reconcile. Confirm the reserve bins each fell by 1 and the pick faces carry the re-slotted velocity class.

SELECT ACCT, DRCR, SUM(AMT) FROM DEPOT.WHGLFEED GROUP BY ACCT, DRCR;
SELECT SUM(CASE WHEN DRCR='D' THEN AMT ELSE 0 END) AS DR,
       SUM(CASE WHEN DRCR='C' THEN AMT ELSE 0 END) AS CR FROM DEPOT.WHGLFEED;

E.3 Reconciling inventory balances

The site balance for an item is reconciled against the movement ledger. Opening on-hand plus every non-internal ledger delta must equal the closing on-hand — internal moves (put-away 'P', pick 'K', replenish 'T', re-slot 'S') net to zero across bins, so only despatch 'D' and count variances 'A'/'Y' change the total.

• Site total — SUM(SQTY) over all WHSTK bins for the item. In the wh_daily scenario WG100001 opens at 840 and closes at 810 after shipping 30; GZ200001 opens 250, closes 230.
• Ledger delta — SUM(MQTY) over the 'D'/'A'/'Y' rows for the item. Despatch rows are negative and, for the wh_daily scenario, sum to exactly −50 (−30 WG, −20 GZ).
• Reconciliation — opening + ledger delta = closing (840 + (−30) = 810). The COBOL WHMOVRP proves the same at building level: internal P/K/T flows net, external D shipped and A/Y adjusted are reported separately.
• GL vs ledger — cost of goods sold on 5000-CGS equals shipped units × unit cost (445.50 in the wh_cycles month); shrinkage on 5900-SHR equals short units × cost (10.50); inventory is credited for the sum (456.00).

SELECT ITEMNO, SUM(SQTY) AS ONHAND FROM DEPOT.WHSTK GROUP BY ITEMNO;
SELECT ITEMNO, MTYPE, SUM(MQTY) FROM DEPOT.WHMOVE
  WHERE MTYPE IN ('D','A','Y') GROUP BY ITEMNO, MTYPE;

E.4 Failure & re-run rules

Each program DSPLYs a one-line summary. Because every posting derives a stable, disjoint ledger key and guards each write with CHAIN(EN), and because each step also gates on record status, the cycles are safe to re-submit.

F. Developer Reference ↑ top

The programs are fixed-form + free-form RPG IV (with one ILE COBOL and one SQLRPGLE), driving keyed DISK files by CHAIN/READE/UPDATE/WRITE. All objects are in library DEPOT.

F.1 Put-away / pick / despatch programs

WHPUTWY — receive & put away

Reads open WHRCPT lines; decides the bin (explicit RPUTLOC, else hazmat → C-09-01 / else B-05-01); sums the target via the location-keyed WHSTKLF and rejects an overfill; moves off the dock into the bin; writes a 'P' ledger row; flips RSTAT='P'.

WHWAVE — wave pick release

For each open order, allocates each line against forward pick faces only (LTYPE='F'), reserving SALLOC without moving SQTY; writes one WHPICK row per source keyed on a pseq that folds in the order digits, the location LSEQ and the order line; marks the line released only if something was actually picked.

WHPKCFM — pick confirmation

For each open pick, subtracts from the pick face (releasing SALLOC) and adds to the staging lane (creating the row if new); writes a positive 'K' ledger row naming both bins; rolls OPICKQ up and flips the line to P when fully picked.

WHDSPCH — despatch

Two passes per order: pass 1 checks every line is OLSTAT='P'; pass 2 draws each line's quantity off the staging lane, writes a negative 'D' ledger row (MTO blank), records OSHIPQ, and rolls the header to OSTAT='D'.

WHREPL / WHSLOW / WHCNTPS / WHVALUE / WHPHYS / WHRESLT

The weekly, monthly and annual programs described in C.2 — replenishment (whole case packs, internal 'T' move), ABC re-rank by shipped throughput, count-variance post ('A'), value-by-location-type, physical count ('Y'), and upgrade-only pick-face re-slot ('S').

F.2 The movement-ledger key scheme (disjoint ranges)

WHMOVE.MSEQ is UNIQUE and each program derives its key from a stable business key inside a disjoint 10-million-wide band, so a re-run regenerates the same key and the CHAIN(EN) guard refuses it — the mechanism that makes every cycle idempotent.

F.3 The GL posting model (WHGLPST)

The monthly post totals the ledger by type, values it at unit cost, reads the posted-to-date sums from WHGLFEED, and posts only the incremental movement as balanced pairs:

• Receipt ('P') — DEBIT 1400-INV (inventory), CREDIT 2100-GRN (goods-received-not-invoiced).
• Despatch ('D') — DEBIT 5000-CGS (cost of goods sold), CREDIT 1400-INV. The ledger holds despatch negative, so the sign is flipped.
• Count variance ('A') — a loss DEBITs 5900-SHR (shrinkage) / CREDITs inventory; a gain reverses it. Shrinkage is carried as a signed net so a later gain unwinds an earlier loss.
• Internal moves ('K', 'T', 'S') never touch the GL — the goods never left the site.

F.4 File-cursor & access-path patterns

• By-location vs by-item. WHSTK is keyed ITEM-first; a capacity check that must sum a bin's contents therefore uses WHSTKLF (LOCID-first). Reading the base PF with a bare location value would position on the leading ITEMNO key and walk the wrong rows — a fixed defect that had let an over-capacity put-away through.
• Re-CHAIN after a moved cursor. A READE loop over a file followed by a CHAIN/UPDATE to that same file moves the cursor; the programs re-CHAIN (or SETGT) before the next read. Where the intervening CHAIN is to a different file (e.g. WHLOC while looping WHSTK) the source notes no re-position is needed.
• Guard-before-side-effect. WHWAVE reserves SALLOC only after the idempotency guard confirms a new pick line — a fixed defect had raised the reservation first, stranding stock against an order with no pick row.
• Conditional release. An order line is flipped to released/picked only when something was actually done for it, so a short or empty line is never falsely advanced and skipped forever.

F.5 Engine-compatibility notes

Two accommodations are documented in the source so the app behaves correctly on the emulator:

• Subfile conditioning indicators (WHPCKD). The emulator's DDS parser reads conditioning indicators one column to the right of the real DDS position, which would split an indicator across a segment boundary (silently dropping N31's condition and mis-reading 31). The SFLDSP/SFLDSPCTL/SFLCLR indicators are therefore written one column left of the standard position; the keyword stays in its normal column. Operationally the subfile displays and clears exactly as described in B.2.
• Subfile clear ordering (WHPCKIQ). The clear (SFLCLR via *IN31) sits after the EXFMT and before the reload, so a re-enquiry never wipes rows before they can be shown.

G. Glossary ↑ top

ABC class / velocity

A ranking of items by throughput: A fast (≥40 units shipped), B (≥10), C slow. Re-ranked weekly by WHSLOW from shipped ledger rows; stamped onto pick-face slots annually by WHRESLT.

Case pack (IPKQTY)

The quantity in one carton — the granularity replenishment moves in (a picker moves cartons, not loose units), so a top-up is rounded up to a whole case pack.

Conservation invariant

The core rule that a warehouse move conserves stock: SUM(SQTY) over all bins for an item is unchanged by put-away, pick, pick-confirm and replenishment. Only receiving, despatch and count variances change it, each with a signed ledger row.

Cycle count / physical count

Counting stock and correcting the book: a cycle count (WHCNTPS, 'A') counts selected sheets monthly; a physical count (WHPHYS, 'Y') counts the whole building annually. Both write a variance row with no bins named.

Dock / staging lane

Non-storage bins: the dock (LTYPE='D') is inbound-only, the staging lane (LTYPE='S') outbound-only. Stock is booked to the dock on receipt and leaves the site from the staging lane on despatch.

FEFO

First-Expiry-First-Out — the pick order that draws the earliest-expiry lot first, using SEXPDT.

Forward pick face vs reserve

A forward pick face (LTYPE='F') is the small, hand-pickable bin picking draws from; a reserve (LTYPE='R') is bulk pallet storage, not hand-pickable, that replenishes the pick face.

Idempotent

Safe to run again with the same result. Every DEPOT/i posting is idempotent by a stable, disjoint ledger key (F.2): a re-run regenerates the same MSEQ and the CHAIN(EN) guard refuses the duplicate.

Movement ledger (WHMOVE)

The durable, unique-keyed audit trail: one row per quantity change, naming type, quantity, both bins (where applicable), a reference and a memo. The arbiter of conservation.

Pickable

On-hand less what a released wave has reserved: SQTY − SALLOC. Shown on the stock inquiry.

Put-away

Moving a received line off the dock into a storage bin (honour explicit bin, else segregate hazmat, else default reserve), respecting bin capacity.

SBMJOB

Submit Job — the IBM i command that queues a program to run as a batch job (e.g. SBMJOB CMD(CALL PGM(DEPOT/WHDAILY))).

Subfile

A 5250 display construct listing many rows on one screen (DDS SFL/SFLCTL). WHPCKIQ's wave pick list is a subfile; the operator keys a wave and the rows reload.

Wave

A batch of order lines released together for picking (WHWAVE), sequenced in aisle-walk (LSEQ) order so a picker walks the aisle once.